From be08103d1d35df5bdddf4ea43140e550fc98f4a5 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Fri, 9 Mar 2018 21:45:58 +0100 Subject: [PATCH 001/122] Init generator --- generator/Cargo.toml | 10 + generator/New-Vulkan-XML-Format | 1 + generator/Vulkan-Docs | 1 + generator/src/bin/generator.rs | 36 + generator/src/lib.rs | 126 + generator/vk.xml | 8459 +++++++++++++++++++++++++++++++ 6 files changed, 8633 insertions(+) create mode 100644 generator/Cargo.toml create mode 160000 generator/New-Vulkan-XML-Format create mode 160000 generator/Vulkan-Docs create mode 100644 generator/src/bin/generator.rs create mode 100644 generator/src/lib.rs create mode 100644 generator/vk.xml diff --git a/generator/Cargo.toml b/generator/Cargo.toml new file mode 100644 index 0000000..a4cca40 --- /dev/null +++ b/generator/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "generator" +version = "0.1.0" +authors = ["Maik Klein "] + +[dependencies] +vkxml = {git = "https://github.com/maikklein/vkxml"} +quote = "0.4.2" +syn = "0.12.14" +heck = "0.3.0" diff --git a/generator/New-Vulkan-XML-Format b/generator/New-Vulkan-XML-Format new file mode 160000 index 0000000..460746d --- /dev/null +++ b/generator/New-Vulkan-XML-Format @@ -0,0 +1 @@ +Subproject commit 460746da3c2dfd1d247b12a619f47f2078a4374b diff --git a/generator/Vulkan-Docs b/generator/Vulkan-Docs new file mode 160000 index 0000000..ce60b9c --- /dev/null +++ b/generator/Vulkan-Docs @@ -0,0 +1 @@ +Subproject commit ce60b9c88745ecded74296dfbe69dae7c1fb2e62 diff --git a/generator/src/bin/generator.rs b/generator/src/bin/generator.rs new file mode 100644 index 0000000..0643e6b --- /dev/null +++ b/generator/src/bin/generator.rs @@ -0,0 +1,36 @@ +extern crate generator; +use std::fs::File; +use generator::*; +use std::collections::HashMap; +use std::io::Write; + +fn main() { + let file = File::open("vk_new.xml").expect("vk"); + let spec = vkxml::Registry::from_file(file).expect(""); + + let commands: HashMap = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Commands(ref cmds) => Some(cmds), + _ => None, + }) + .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) + .collect(); + + let features: Vec<&vkxml::Feature> = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Features(ref features) => Some(features), + _ => None, + }) + .flat_map(|features| features.elements.iter().map(|feature| feature)) + .collect(); + + let source_code: Vec<_> = features.iter().map(|feature| gen_load(feature, &commands)).collect(); + let mut file = File::create("vk_test.rs").expect("vk"); + for source_code in &source_code { + write!(&mut file, "{}", source_code); + } + + +} diff --git a/generator/src/lib.rs b/generator/src/lib.rs new file mode 100644 index 0000000..11fb44c --- /dev/null +++ b/generator/src/lib.rs @@ -0,0 +1,126 @@ +// extern crate serde; +// #[macro_use] +// extern crate serde_derive; +extern crate heck; +#[macro_use] +extern crate quote; +extern crate syn; +pub extern crate vkxml; + +use heck::SnakeCase; + +use syn::Ident; + +pub trait CommandExt { + /// Returns the ident in snake_case and without the 'vk' prefix. + fn is_device_command(&self) -> bool; + /// + /// Returns true if the command is a device level command. This is indicated by + /// the type of the first parameter. + fn command_ident(&self) -> Ident; +} + +impl CommandExt for vkxml::Command { + fn command_ident(&self) -> Ident { + Ident::from(self.name[2..].to_snake_case().as_str()) + } + + fn is_device_command(&self) -> bool { + self.param + .iter() + .nth(0) + .map(|field| match field.basetype.as_str() { + "VkDevice" | "VkCommandBuffer" | "VkQueue" => true, + _ => false, + }) + .unwrap_or(false) + } +} + +pub trait FieldExt { + /// Returns the name of the paramter that doesn't clash with Rusts resevered + /// keywords + fn param_ident(&self) -> Ident; + + /// Returns the basetype ident and removes the 'Vk' prefix + fn type_ident(&self) -> Ident; +} + +impl FieldExt for vkxml::Field { + fn param_ident(&self) -> Ident { + let name = self.name.as_ref().map(|s| s.as_str()).unwrap_or("field"); + let name_corrected = match name { + "type" => "ty", + _ => name, + }; + Ident::from(name_corrected.to_snake_case().as_str()) + } + + fn type_ident(&self) -> Ident { + let prefix = &self.basetype[0..2]; + if prefix == "Vk" { + Ident::from(&self.basetype[2..]) + } else { + Ident::from(&self.basetype[..]) + } + } +} +use std::collections::HashMap; +pub type CommandMap<'a> = HashMap; +pub fn gen_load(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Tokens { + let (device_commands, instance_commands) = feature + .elements + .iter() + .flat_map(|feature| { + if let &vkxml::FeatureElement::Require(ref spec) = feature { + spec.elements + .iter() + .filter_map(|feature_spec| { + if let &vkxml::FeatureReference::CommandReference(ref cmd_ref) = + feature_spec + { + Some(cmd_ref) + } else { + None + } + }) + .collect() + } else { + vec![] + } + }) + .filter_map(|cmd_ref| commands.get(&cmd_ref.name)) + .fold((Vec::new(), Vec::new()), |mut acc, &cmd_ref| { + let basetype = cmd_ref.param[0].basetype.as_str(); + match basetype { + "VkDevice" | "VkCommandBuffer" | "VkQueue" => acc.0.push(cmd_ref), + _ => acc.1.push(cmd_ref), + }; + acc + }); + let name = Ident::from("Test"); + let function_pointers: Vec<_> = instance_commands + .iter() + .map(|cmd| { + let fn_name_raw = cmd.name.as_str(); + let fn_name_snake = cmd.command_ident(); + let params: Vec<_> = cmd.param + .iter() + .map(|field| { + let name = field.param_ident(); + let ty = field.type_ident(); + quote!{#name: vk::#ty} + }) + .collect(); + let return_ty = cmd.return_type.type_ident(); + quote!{ + #fn_name_snake: extern "system" fn(#(#params,)*) -> vk::#return_ty + } + }) + .collect(); + quote!{ + pub struct #name { + #(#function_pointers,)* + } + } +} diff --git a/generator/vk.xml b/generator/vk.xml new file mode 100644 index 0000000..3d7a35b --- /dev/null +++ b/generator/vk.xml @@ -0,0 +1,8459 @@ + + + +Copyright (c) 2015-2018 The Khronos Group Inc. + +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. + +------------------------------------------------------------------------ + +This file, vk.xml, is the Vulkan API Registry. It is a critically important +and normative part of the Vulkan Specification, including a canonical +machine-readable definition of the API, parameter and member validation +language incorporated into the Specification and reference pages, and other +material which is registered by Khronos, such as tags used by extension and +layer authors. The authoritative public version of vk.xml is maintained in +the master branch of the Khronos Vulkan GitHub project. The authoritative +private version is maintained in the 1.0 branch of the member gitlab server. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + #include "vk_platform.h" + + WSI extensions + + + + + + + + + In the current header structure, each platform's interfaces + are confined to a platform-specific header (vulkan_xlib.h, + vulkan_win32.h, etc.). These headers are not self-contained, + and should not include native headers (X11/Xlib.h, + windows.h, etc.). Code should either include vulkan.h after + defining the appropriate VK_USE_PLATFORM_platform_KHR + macros, or include the required native headers prior to + explicitly including the corresponding platform header. + + To accomplish this, the dependencies of native types require + native headers, but the XML defines the content for those + native headers as empty. The actual native header includes + can be restored by modifying the native header tags above + to #include the header file in the 'name' attribute. + + + + + + + + + + + + + + + + + + + + + #define VK_MAKE_VERSION(major, minor, patch) \ + (((major) << 22) | ((minor) << 12) | (patch)) + #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) + #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) + #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) + + // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 + // Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 + // Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 + // Version of this file +#define VK_HEADER_VERSION 70 + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +#else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +#endif +#endif + + + +#define VK_NULL_HANDLE 0 + + + struct ANativeWindow; + + typedef uint32_t VkSampleMask; + typedef uint32_t VkBool32; + typedef uint32_t VkFlags; + typedef uint64_t VkDeviceSize; + + Basic C types, pulled in via vk_platform.h + + + + + + + + + + + Bitmask types + typedef VkFlags VkFramebufferCreateFlags; + typedef VkFlags VkQueryPoolCreateFlags; + typedef VkFlags VkRenderPassCreateFlags; + typedef VkFlags VkSamplerCreateFlags; + typedef VkFlags VkPipelineLayoutCreateFlags; + typedef VkFlags VkPipelineCacheCreateFlags; + typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + typedef VkFlags VkPipelineDynamicStateCreateFlags; + typedef VkFlags VkPipelineColorBlendStateCreateFlags; + typedef VkFlags VkPipelineMultisampleStateCreateFlags; + typedef VkFlags VkPipelineRasterizationStateCreateFlags; + typedef VkFlags VkPipelineViewportStateCreateFlags; + typedef VkFlags VkPipelineTessellationStateCreateFlags; + typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; + typedef VkFlags VkPipelineVertexInputStateCreateFlags; + typedef VkFlags VkPipelineShaderStageCreateFlags; + typedef VkFlags VkDescriptorSetLayoutCreateFlags; + typedef VkFlags VkBufferViewCreateFlags; + typedef VkFlags VkInstanceCreateFlags; + typedef VkFlags VkDeviceCreateFlags; + typedef VkFlags VkDeviceQueueCreateFlags; + typedef VkFlags VkQueueFlags; + typedef VkFlags VkMemoryPropertyFlags; + typedef VkFlags VkMemoryHeapFlags; + typedef VkFlags VkAccessFlags; + typedef VkFlags VkBufferUsageFlags; + typedef VkFlags VkBufferCreateFlags; + typedef VkFlags VkShaderStageFlags; + typedef VkFlags VkImageUsageFlags; + typedef VkFlags VkImageCreateFlags; + typedef VkFlags VkImageViewCreateFlags; + typedef VkFlags VkPipelineCreateFlags; + typedef VkFlags VkColorComponentFlags; + typedef VkFlags VkFenceCreateFlags; + typedef VkFlags VkSemaphoreCreateFlags; + typedef VkFlags VkFormatFeatureFlags; + typedef VkFlags VkQueryControlFlags; + typedef VkFlags VkQueryResultFlags; + typedef VkFlags VkShaderModuleCreateFlags; + typedef VkFlags VkEventCreateFlags; + typedef VkFlags VkCommandPoolCreateFlags; + typedef VkFlags VkCommandPoolResetFlags; + typedef VkFlags VkCommandBufferResetFlags; + typedef VkFlags VkCommandBufferUsageFlags; + typedef VkFlags VkQueryPipelineStatisticFlags; + typedef VkFlags VkMemoryMapFlags; + typedef VkFlags VkImageAspectFlags; + typedef VkFlags VkSparseMemoryBindFlags; + typedef VkFlags VkSparseImageFormatFlags; + typedef VkFlags VkSubpassDescriptionFlags; + typedef VkFlags VkPipelineStageFlags; + typedef VkFlags VkSampleCountFlags; + typedef VkFlags VkAttachmentDescriptionFlags; + typedef VkFlags VkStencilFaceFlags; + typedef VkFlags VkCullModeFlags; + typedef VkFlags VkDescriptorPoolCreateFlags; + typedef VkFlags VkDescriptorPoolResetFlags; + typedef VkFlags VkDependencyFlags; + typedef VkFlags VkSubgroupFeatureFlags; + typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; + typedef VkFlags VkObjectEntryUsageFlagsNVX; + + typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + + + WSI extensions + typedef VkFlags VkCompositeAlphaFlagsKHR; + typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; + typedef VkFlags VkSurfaceTransformFlagsKHR; + typedef VkFlags VkSwapchainCreateFlagsKHR; + typedef VkFlags VkDisplayModeCreateFlagsKHR; + typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + typedef VkFlags VkMirSurfaceCreateFlagsKHR; + typedef VkFlags VkViSurfaceCreateFlagsNN; + typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + typedef VkFlags VkPeerMemoryFeatureFlags; + + typedef VkFlags VkMemoryAllocateFlags; + + typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; + + typedef VkFlags VkDebugReportFlagsEXT; + typedef VkFlags VkCommandPoolTrimFlags; + + typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + typedef VkFlags VkExternalMemoryFeatureFlagsNV; + typedef VkFlags VkExternalMemoryHandleTypeFlags; + + typedef VkFlags VkExternalMemoryFeatureFlags; + + typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + + typedef VkFlags VkExternalSemaphoreFeatureFlags; + + typedef VkFlags VkSemaphoreImportFlags; + + typedef VkFlags VkExternalFenceHandleTypeFlags; + + typedef VkFlags VkExternalFenceFeatureFlags; + + typedef VkFlags VkFenceImportFlags; + + typedef VkFlags VkSurfaceCounterFlagsEXT; + typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + typedef VkFlags VkValidationCacheCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; + typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + + Types which can be void pointers or class pointers, selected at compile time + VK_DEFINE_HANDLE(VkInstance) + VK_DEFINE_HANDLE(VkPhysicalDevice) + VK_DEFINE_HANDLE(VkDevice) + VK_DEFINE_HANDLE(VkQueue) + VK_DEFINE_HANDLE(VkCommandBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) + + WSI extensions + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) + + Types generated from corresponding enums tags below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Extensions + + + + + + + + + + + + + + + + + + WSI extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The PFN_vk*Function types are used by VkAllocationCallbacks below + typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + + The PFN_vkVoidFunction type are used by VkGet*ProcAddr below + typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); + + The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + + The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + + Struct types + + int32_t x + int32_t y + + + int32_t x + int32_t y + int32_t z + + + uint32_t width + uint32_t height + + + uint32_t width + uint32_t height + uint32_t depth + + + float x + float y + float width + float height + float minDepth + float maxDepth + + + VkOffset2D offset + VkExtent2D extent + + + VkRect2D rect + uint32_t baseArrayLayer + uint32_t layerCount + + + VkComponentSwizzle r + VkComponentSwizzle g + VkComponentSwizzle b + VkComponentSwizzle a + + + uint32_t apiVersion + uint32_t driverVersion + uint32_t vendorID + uint32_t deviceID + VkPhysicalDeviceType deviceType + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + VkPhysicalDeviceLimits limits + VkPhysicalDeviceSparseProperties sparseProperties + + + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]extension name + uint32_t specVersionversion of the extension specification implemented + + + char layerName[VK_MAX_EXTENSION_NAME_SIZE]layer name + uint32_t specVersionversion of the layer specification implemented + uint32_t implementationVersionbuild or release version of the layer's library + char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the layer + + + VkStructureType sType + const void* pNext + const char* pApplicationName + uint32_t applicationVersion + const char* pEngineName + uint32_t engineVersion + uint32_t apiVersion + + + void* pUserData + PFN_vkAllocationFunction pfnAllocation + PFN_vkReallocationFunction pfnReallocation + PFN_vkFreeFunction pfnFree + PFN_vkInternalAllocationNotification pfnInternalAllocation + PFN_vkInternalFreeNotification pfnInternalFree + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueCount + const float* pQueuePriorities + + + VkStructureType sType + const void* pNext + VkDeviceCreateFlags flags + uint32_t queueCreateInfoCount + const VkDeviceQueueCreateInfo* pQueueCreateInfos + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNames + const VkPhysicalDeviceFeatures* pEnabledFeatures + + + VkStructureType sType + const void* pNext + VkInstanceCreateFlags flags + const VkApplicationInfo* pApplicationInfo + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNamesExtension names to be enabled + + + VkQueueFlags queueFlagsQueue flags + uint32_t queueCount + uint32_t timestampValidBits + VkExtent3D minImageTransferGranularityMinimum alignment requirement for image transfers + + + uint32_t memoryTypeCount + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES] + uint32_t memoryHeapCount + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] + + + VkStructureType sType + const void* pNext + VkDeviceSize allocationSizeSize of memory allocation + uint32_t memoryTypeIndexIndex of the of the memory type to allocate from + + + VkDeviceSize sizeSpecified in bytes + VkDeviceSize alignmentSpecified in bytes + uint32_t memoryTypeBitsBitmask of the allowed memory type indices into memoryTypes[] for this object + + + VkImageAspectFlags aspectMask + VkExtent3D imageGranularity + VkSparseImageFormatFlags flags + + + VkSparseImageFormatProperties formatProperties + uint32_t imageMipTailFirstLod + VkDeviceSize imageMipTailSizeSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailOffsetSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailStrideSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + + + VkMemoryPropertyFlags propertyFlagsMemory properties of this memory type + uint32_t heapIndexIndex of the memory heap allocations of this memory type are taken from + + + VkDeviceSize sizeAvailable memory in the heap + VkMemoryHeapFlags flagsFlags for the heap + + + VkStructureType sType + const void* pNext + VkDeviceMemory memoryMapped memory object + VkDeviceSize offsetOffset within the memory object where the range starts + VkDeviceSize sizeSize of the range within the memory object + + + VkFormatFeatureFlags linearTilingFeaturesFormat features in case of linear tiling + VkFormatFeatureFlags optimalTilingFeaturesFormat features in case of optimal tiling + VkFormatFeatureFlags bufferFeaturesFormat features supported by buffers + + + VkExtent3D maxExtentmax image dimensions for this resource type + uint32_t maxMipLevelsmax number of mipmap levels for this resource type + uint32_t maxArrayLayersmax array size for this resource type + VkSampleCountFlags sampleCountssupported sample counts for this resource type + VkDeviceSize maxResourceSizemax size (in bytes) of this resource type + + + VkBuffer bufferBuffer used for this descriptor slot when the descriptor is UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC]. VK_NULL_HANDLE otherwise. + VkDeviceSize offsetBase offset from buffer start in bytes to update in the descriptor set. + VkDeviceSize rangeSize in bytes of the buffer resource for this descriptor update. + + + VkSampler samplerSampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise. + VkImageView imageViewImage view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise. + VkImageLayout imageLayoutLayout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE). + + + VkStructureType sType + const void* pNext + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + VkDescriptorType descriptorTypeDescriptor type to write (determines which members of the array pointed by pDescriptors are going to be used) + const VkDescriptorImageInfo* pImageInfoSampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types. + const VkDescriptorBufferInfo* pBufferInfoRaw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types. + const VkBufferView* pTexelBufferViewBuffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types. + + + VkStructureType sType + const void* pNext + VkDescriptorSet srcSetSource descriptor set + uint32_t srcBindingBinding within the source descriptor set to copy from + uint32_t srcArrayElementArray element within the source binding to copy from + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to copy to + uint32_t dstArrayElementArray element within the destination binding to copy to + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flagsBuffer creation flags + VkDeviceSize sizeSpecified in bytes + VkBufferUsageFlags usageBuffer usage flags + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + + + VkStructureType sType + const void* pNext + VkBufferViewCreateFlagsflags + VkBuffer buffer + VkFormat formatOptionally specifies format of elements + VkDeviceSize offsetSpecified in bytes + VkDeviceSize rangeView size specified in bytes + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t arrayLayer + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t baseArrayLayer + uint32_t layerCount + + + VkImageAspectFlags aspectMask + uint32_t baseMipLevel + uint32_t levelCount + uint32_t baseArrayLayer + uint32_t layerCount + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkBuffer bufferBuffer to sync + VkDeviceSize offsetOffset within the buffer to sync + VkDeviceSize sizeAmount of bytes to sync + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkImageLayout oldLayoutCurrent layout of the image + VkImageLayout newLayoutNew layout to transition the image to + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkImage imageImage to sync + VkImageSubresourceRange subresourceRangeSubresource range to sync + + + VkStructureType sType + const void* pNext + VkImageCreateFlags flagsImage creation flags + VkImageType imageType + VkFormat format + VkExtent3D extent + uint32_t mipLevels + uint32_t arrayLayers + VkSampleCountFlagBits samples + VkImageTiling tiling + VkImageUsageFlags usageImage usage flags + VkSharingMode sharingModeCross-queue-family sharing mode + uint32_t queueFamilyIndexCountNumber of queue families to share across + const uint32_t* pQueueFamilyIndicesArray of queue family indices to share across + VkImageLayout initialLayoutInitial image layout for all subresources + + + VkDeviceSize offsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceSize rowPitchSpecified in bytes + VkDeviceSize arrayPitchSpecified in bytes + VkDeviceSize depthPitchSpecified in bytes + + + VkStructureType sType + const void* pNext + VkImageViewCreateFlags flags + VkImage image + VkImageViewType viewType + VkFormat format + VkComponentMapping components + VkImageSubresourceRange subresourceRange + + + VkDeviceSize srcOffsetSpecified in bytes + VkDeviceSize dstOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + + + VkDeviceSize resourceOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlagsflags + + + VkImageSubresource subresource + VkOffset3D offset + VkExtent3D extent + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlagsflags + + + VkBuffer buffer + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseImageMemoryBind* pBinds + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + uint32_t bufferBindCount + const VkSparseBufferMemoryBindInfo* pBufferBinds + uint32_t imageOpaqueBindCount + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds + uint32_t imageBindCount + const VkSparseImageMemoryBindInfo* pImageBinds + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D extentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images + + + VkDeviceSize bufferOffsetSpecified in bytes + uint32_t bufferRowLengthSpecified in texels + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + + VkStructureType sType + const void* pNext + VkShaderModuleCreateFlags flags + size_t codeSizeSpecified in bytes + const uint32_t* pCodeBinary code of size codeSize + + + uint32_t bindingBinding number for this entry + VkDescriptorType descriptorTypeType of the descriptors in this binding + uint32_t descriptorCountNumber of descriptors in this binding + VkShaderStageFlags stageFlagsShader stages this binding is visible to + const VkSampler* pImmutableSamplersImmutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements) + + + VkStructureType sType + const void* pNext + VkDescriptorSetLayoutCreateFlags flags + uint32_t bindingCountNumber of bindings in the descriptor set layout + const VkDescriptorSetLayoutBinding* pBindingsArray of descriptor set layout bindings + + + VkDescriptorType type + uint32_t descriptorCount + + + VkStructureType sType + const void* pNext + VkDescriptorPoolCreateFlags flags + uint32_t maxSets + uint32_t poolSizeCount + const VkDescriptorPoolSize* pPoolSizes + + + VkStructureType sType + const void* pNext + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSetLayout* pSetLayouts + + + uint32_t constantIDThe SpecConstant ID specified in the BIL + uint32_t offsetOffset of the value in the data block + size_t sizeSize in bytes of the SpecConstant + + + uint32_t mapEntryCountNumber of entries in the map + const VkSpecializationMapEntry* pMapEntriesArray of map entries + size_t dataSizeSize in bytes of pData + const void* pDataPointer to SpecConstant data + + + VkStructureType sType + const void* pNext + VkPipelineShaderStageCreateFlags flags + VkShaderStageFlagBits stageShader stage + VkShaderModule moduleModule containing entry point + const char* pNameNull-terminated entry point name + const VkSpecializationInfo* pSpecializationInfo + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + VkPipelineShaderStageCreateInfo stage + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + uint32_t bindingVertex buffer binding id + uint32_t strideDistance between vertices in bytes (0 = no advancement) + VkVertexInputRate inputRateThe rate at which the vertex data is consumed + + + uint32_t locationlocation of the shader vertex attrib + uint32_t bindingVertex buffer binding id + VkFormat formatformat of source data + uint32_t offsetOffset of first element in bytes from base of vertex + + + VkStructureType sType + const void* pNext + VkPipelineVertexInputStateCreateFlags flags + uint32_t vertexBindingDescriptionCountnumber of bindings + const VkVertexInputBindingDescription* pVertexBindingDescriptions + uint32_t vertexAttributeDescriptionCountnumber of attributes + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions + + + VkStructureType sType + const void* pNext + VkPipelineInputAssemblyStateCreateFlags flags + VkPrimitiveTopology topology + VkBool32 primitiveRestartEnable + + + VkStructureType sType + const void* pNext + VkPipelineTessellationStateCreateFlags flags + uint32_t patchControlPoints + + + VkStructureType sType + const void* pNext + VkPipelineViewportStateCreateFlags flags + uint32_t viewportCount + const VkViewport* pViewports + uint32_t scissorCount + const VkRect2D* pScissors + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationStateCreateFlags flags + VkBool32 depthClampEnable + VkBool32 rasterizerDiscardEnable + VkPolygonMode polygonModeoptional (GL45) + VkCullModeFlags cullMode + VkFrontFace frontFace + VkBool32 depthBiasEnable + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + float lineWidth + + + VkStructureType sType + const void* pNext + VkPipelineMultisampleStateCreateFlags flags + VkSampleCountFlagBits rasterizationSamplesNumber of samples used for rasterization + VkBool32 sampleShadingEnableoptional (GL45) + float minSampleShadingoptional (GL45) + const VkSampleMask* pSampleMaskArray of sampleMask words + VkBool32 alphaToCoverageEnable + VkBool32 alphaToOneEnable + + + VkBool32 blendEnable + VkBlendFactor srcColorBlendFactor + VkBlendFactor dstColorBlendFactor + VkBlendOp colorBlendOp + VkBlendFactor srcAlphaBlendFactor + VkBlendFactor dstAlphaBlendFactor + VkBlendOp alphaBlendOp + VkColorComponentFlags colorWriteMask + + + VkStructureType sType + const void* pNext + VkPipelineColorBlendStateCreateFlags flags + VkBool32 logicOpEnable + VkLogicOp logicOp + uint32_t attachmentCount# of pAttachments + const VkPipelineColorBlendAttachmentState* pAttachments + float blendConstants[4] + + + VkStructureType sType + const void* pNext + VkPipelineDynamicStateCreateFlags flags + uint32_t dynamicStateCount + const VkDynamicState* pDynamicStates + + + VkStencilOp failOp + VkStencilOp passOp + VkStencilOp depthFailOp + VkCompareOp compareOp + uint32_t compareMask + uint32_t writeMask + uint32_t reference + + + VkStructureType sType + const void* pNext + VkPipelineDepthStencilStateCreateFlags flags + VkBool32 depthTestEnable + VkBool32 depthWriteEnable + VkCompareOp depthCompareOp + VkBool32 depthBoundsTestEnableoptional (depth_bounds_test) + VkBool32 stencilTestEnable + VkStencilOpState front + VkStencilOpState back + float minDepthBounds + float maxDepthBounds + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + const VkPipelineVertexInputStateCreateInfo* pVertexInputState + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState + const VkPipelineTessellationStateCreateInfo* pTessellationState + const VkPipelineViewportStateCreateInfo* pViewportState + const VkPipelineRasterizationStateCreateInfo* pRasterizationState + const VkPipelineMultisampleStateCreateInfo* pMultisampleState + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState + const VkPipelineColorBlendStateCreateInfo* pColorBlendState + const VkPipelineDynamicStateCreateInfo* pDynamicState + VkPipelineLayout layoutInterface layout of the pipeline + VkRenderPass renderPass + uint32_t subpass + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkPipelineCacheCreateFlags flags + size_t initialDataSizeSize of initial data to populate cache, in bytes + const void* pInitialDataInitial data to populate cache + + + VkShaderStageFlags stageFlagsWhich stages use the range + uint32_t offsetStart of the range, in bytes + uint32_t sizeSize of the range, in bytes + + + VkStructureType sType + const void* pNext + VkPipelineLayoutCreateFlags flags + uint32_t setLayoutCountNumber of descriptor sets interfaced by the pipeline + const VkDescriptorSetLayout* pSetLayoutsArray of setCount number of descriptor set layout objects defining the layout of the + uint32_t pushConstantRangeCountNumber of push-constant ranges used by the pipeline + const VkPushConstantRange* pPushConstantRangesArray of pushConstantRangeCount number of ranges used by various shader stages + + + VkStructureType sType + const void* pNext + VkSamplerCreateFlags flags + VkFilter magFilterFilter mode for magnification + VkFilter minFilterFilter mode for minifiation + VkSamplerMipmapMode mipmapModeMipmap selection mode + VkSamplerAddressMode addressModeU + VkSamplerAddressMode addressModeV + VkSamplerAddressMode addressModeW + float mipLodBias + VkBool32 anisotropyEnable + float maxAnisotropy + VkBool32 compareEnable + VkCompareOp compareOp + float minLod + float maxLod + VkBorderColor borderColor + VkBool32 unnormalizedCoordinates + + + VkStructureType sType + const void* pNext + VkCommandPoolCreateFlags flagsCommand pool creation flags + uint32_t queueFamilyIndex + + + VkStructureType sType + const void* pNext + VkCommandPool commandPool + VkCommandBufferLevel level + uint32_t commandBufferCount + + + VkStructureType sType + const void* pNext + VkRenderPass renderPassRender pass for secondary command buffers + uint32_t subpass + VkFramebuffer framebufferFramebuffer for secondary command buffers + VkBool32 occlusionQueryEnableWhether this secondary command buffer may be executed during an occlusion query + VkQueryControlFlags queryFlagsQuery flags used by this secondary command buffer, if executed during an occlusion query + VkQueryPipelineStatisticFlags pipelineStatisticsPipeline statistics that may be counted for this secondary command buffer + + + VkStructureType sType + const void* pNext + VkCommandBufferUsageFlags flagsCommand buffer usage flags + const VkCommandBufferInheritanceInfo* pInheritanceInfoPointer to inheritance info for secondary command buffers + + + VkStructureType sType + const void* pNext + VkRenderPass renderPass + VkFramebuffer framebuffer + VkRect2D renderArea + uint32_t clearValueCount + const VkClearValue* pClearValues + + + float float32[4] + int32_t int32[4] + uint32_t uint32[4] + + + float depth + uint32_t stencil + + + VkClearColorValue color + VkClearDepthStencilValue depthStencil + + + VkImageAspectFlags aspectMask + uint32_t colorAttachment + VkClearValue clearValue + + + VkAttachmentDescriptionFlags flags + VkFormat format + VkSampleCountFlagBits samples + VkAttachmentLoadOp loadOpLoad operation for color or depth data + VkAttachmentStoreOp storeOpStore operation for color or depth data + VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data + VkAttachmentStoreOp stencilStoreOpStore operation for stencil data + VkImageLayout initialLayout + VkImageLayout finalLayout + + + uint32_t attachment + VkImageLayout layout + + + VkSubpassDescriptionFlags flags + VkPipelineBindPoint pipelineBindPointMust be VK_PIPELINE_BIND_POINT_GRAPHICS for now + uint32_t inputAttachmentCount + const VkAttachmentReference* pInputAttachments + uint32_t colorAttachmentCount + const VkAttachmentReference* pColorAttachments + const VkAttachmentReference* pResolveAttachments + const VkAttachmentReference* pDepthStencilAttachment + uint32_t preserveAttachmentCount + const uint32_t* pPreserveAttachments + + + uint32_t srcSubpass + uint32_t dstSubpass + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkDependencyFlags dependencyFlags + + + VkStructureType sType + const void* pNext + VkRenderPassCreateFlags flags + uint32_t attachmentCount + const VkAttachmentDescription* pAttachments + uint32_t subpassCount + const VkSubpassDescription* pSubpasses + uint32_t dependencyCount + const VkSubpassDependency* pDependencies + + + VkStructureType sType + const void* pNext + VkEventCreateFlags flagsEvent creation flags + + + VkStructureType sType + const void* pNext + VkFenceCreateFlags flagsFence creation flags + + + VkBool32 robustBufferAccessout of bounds buffer accesses are well defined + VkBool32 fullDrawIndexUint32full 32-bit range of indices for indexed draw calls + VkBool32 imageCubeArrayimage views which are arrays of cube maps + VkBool32 independentBlendblending operations are controlled per-attachment + VkBool32 geometryShadergeometry stage + VkBool32 tessellationShadertessellation control and evaluation stage + VkBool32 sampleRateShadingper-sample shading and interpolation + VkBool32 dualSrcBlendblend operations which take two sources + VkBool32 logicOplogic operations + VkBool32 multiDrawIndirectmulti draw indirect + VkBool32 drawIndirectFirstInstanceindirect draws can use non-zero firstInstance + VkBool32 depthClampdepth clamping + VkBool32 depthBiasClampdepth bias clamping + VkBool32 fillModeNonSolidpoint and wireframe fill modes + VkBool32 depthBoundsdepth bounds test + VkBool32 wideLineslines with width greater than 1 + VkBool32 largePointspoints with size greater than 1 + VkBool32 alphaToOnethe fragment alpha component can be forced to maximum representable alpha value + VkBool32 multiViewportviewport arrays + VkBool32 samplerAnisotropyanisotropic sampler filtering + VkBool32 textureCompressionETC2ETC texture compression formats + VkBool32 textureCompressionASTC_LDRASTC LDR texture compression formats + VkBool32 textureCompressionBCBC1-7 texture compressed formats + VkBool32 occlusionQueryPreciseprecise occlusion queries returning actual sample counts + VkBool32 pipelineStatisticsQuerypipeline statistics query + VkBool32 vertexPipelineStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages + VkBool32 fragmentStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in the fragment stage + VkBool32 shaderTessellationAndGeometryPointSizetessellation and geometry stages can export point size + VkBool32 shaderImageGatherExtendedimage gather with run-time values and independent offsets + VkBool32 shaderStorageImageExtendedFormatsthe extended set of formats can be used for storage images + VkBool32 shaderStorageImageMultisamplemultisample images can be used for storage images + VkBool32 shaderStorageImageReadWithoutFormatread from storage image does not require format qualifier + VkBool32 shaderStorageImageWriteWithoutFormatwrite to storage image does not require format qualifier + VkBool32 shaderUniformBufferArrayDynamicIndexingarrays of uniform buffers can be accessed with dynamically uniform indices + VkBool32 shaderSampledImageArrayDynamicIndexingarrays of sampled images can be accessed with dynamically uniform indices + VkBool32 shaderStorageBufferArrayDynamicIndexingarrays of storage buffers can be accessed with dynamically uniform indices + VkBool32 shaderStorageImageArrayDynamicIndexingarrays of storage images can be accessed with dynamically uniform indices + VkBool32 shaderClipDistanceclip distance in shaders + VkBool32 shaderCullDistancecull distance in shaders + VkBool32 shaderFloat6464-bit floats (doubles) in shaders + VkBool32 shaderInt6464-bit integers in shaders + VkBool32 shaderInt1616-bit integers in shaders + VkBool32 shaderResourceResidencyshader can use texture operations that return resource residency information (requires sparseNonResident support) + VkBool32 shaderResourceMinLodshader can use texture operations that specify minimum resource LOD + VkBool32 sparseBindingSparse resources support: Resource memory can be managed at opaque page level rather than object level + VkBool32 sparseResidencyBufferSparse resources support: GPU can access partially resident buffers + VkBool32 sparseResidencyImage2DSparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images + VkBool32 sparseResidencyImage3DSparse resources support: GPU can access partially resident 3D images + VkBool32 sparseResidency2SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 2 samples + VkBool32 sparseResidency4SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 4 samples + VkBool32 sparseResidency8SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 8 samples + VkBool32 sparseResidency16SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 16 samples + VkBool32 sparseResidencyAliasedSparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) + VkBool32 variableMultisampleRatemultisample rate must be the same for all pipelines in a subpass + VkBool32 inheritedQueriesQueries may be inherited from primary to secondary command buffers + + + VkBool32 residencyStandard2DBlockShapeSparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard2DMultisampleBlockShapeSparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard3DBlockShapeSparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyAlignedMipSizeSparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail + VkBool32 residencyNonResidentStrictSparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded + + + resource maximum sizes + uint32_t maxImageDimension1Dmax 1D image dimension + uint32_t maxImageDimension2Dmax 2D image dimension + uint32_t maxImageDimension3Dmax 3D image dimension + uint32_t maxImageDimensionCubemax cubemap image dimension + uint32_t maxImageArrayLayersmax layers for image arrays + uint32_t maxTexelBufferElementsmax texel buffer size (fstexels) + uint32_t maxUniformBufferRangemax uniform buffer range (bytes) + uint32_t maxStorageBufferRangemax storage buffer range (bytes) + uint32_t maxPushConstantsSizemax size of the push constants pool (bytes) + memory limits + uint32_t maxMemoryAllocationCountmax number of device memory allocations supported + uint32_t maxSamplerAllocationCountmax number of samplers that can be allocated on a device + VkDeviceSize bufferImageGranularityGranularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage + VkDeviceSize sparseAddressSpaceSizeTotal address space available for sparse allocations (bytes) + descriptor set limits + uint32_t maxBoundDescriptorSetsmax number of descriptors sets that can be bound to a pipeline + uint32_t maxPerStageDescriptorSamplersmax number of samplers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorUniformBuffersmax number of uniform buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageBuffersmax number of storage buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorSampledImagesmax number of sampled images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageImagesmax number of storage images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorInputAttachmentsmax number of input attachments allowed per-stage in a descriptor set + uint32_t maxPerStageResourcesmax number of resources allowed by a single stage + uint32_t maxDescriptorSetSamplersmax number of samplers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersmax number of uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersDynamicmax number of dynamic uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersmax number of storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersDynamicmax number of dynamic storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetSampledImagesmax number of sampled images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageImagesmax number of storage images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetInputAttachmentsmax number of input attachments allowed in all stages in a descriptor set + vertex stage limits + uint32_t maxVertexInputAttributesmax number of vertex input attribute slots + uint32_t maxVertexInputBindingsmax number of vertex input binding slots + uint32_t maxVertexInputAttributeOffsetmax vertex input attribute offset added to vertex buffer offset + uint32_t maxVertexInputBindingStridemax vertex input binding stride + uint32_t maxVertexOutputComponentsmax number of output components written by vertex shader + tessellation control stage limits + uint32_t maxTessellationGenerationLevelmax level supported by tessellation primitive generator + uint32_t maxTessellationPatchSizemax patch size (vertices) + uint32_t maxTessellationControlPerVertexInputComponentsmax number of input components per-vertex in TCS + uint32_t maxTessellationControlPerVertexOutputComponentsmax number of output components per-vertex in TCS + uint32_t maxTessellationControlPerPatchOutputComponentsmax number of output components per-patch in TCS + uint32_t maxTessellationControlTotalOutputComponentsmax total number of per-vertex and per-patch output components in TCS + tessellation evaluation stage limits + uint32_t maxTessellationEvaluationInputComponentsmax number of input components per vertex in TES + uint32_t maxTessellationEvaluationOutputComponentsmax number of output components per vertex in TES + geometry stage limits + uint32_t maxGeometryShaderInvocationsmax invocation count supported in geometry shader + uint32_t maxGeometryInputComponentsmax number of input components read in geometry stage + uint32_t maxGeometryOutputComponentsmax number of output components written in geometry stage + uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage + uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage + fragment stage limits + uint32_t maxFragmentInputComponentsmax number of input compontents read in fragment stage + uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage + uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending + uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers + compute stage limits + uint32_t maxComputeSharedMemorySizemax total storage size of work group local storage (bytes) + uint32_t maxComputeWorkGroupCount[3]max num of compute work groups that may be dispatched by a single command (x,y,z) + uint32_t maxComputeWorkGroupInvocationsmax total compute invocations in a single local work group + uint32_t maxComputeWorkGroupSize[3]max local size of a compute work group (x,y,z) + uint32_t subPixelPrecisionBitsnumber bits of subpixel precision in screen x and y + uint32_t subTexelPrecisionBitsnumber bits of precision for selecting texel weights + uint32_t mipmapPrecisionBitsnumber bits of precision for selecting mipmap weights + uint32_t maxDrawIndexedIndexValuemax index value for indexed draw calls (for 32-bit indices) + uint32_t maxDrawIndirectCountmax draw count for indirect draw calls + float maxSamplerLodBiasmax absolute sampler LOD bias + float maxSamplerAnisotropymax degree of sampler anisotropy + uint32_t maxViewportsmax number of active viewports + uint32_t maxViewportDimensions[2]max viewport dimensions (x,y) + float viewportBoundsRange[2]viewport bounds range (min,max) + uint32_t viewportSubPixelBitsnumber bits of subpixel precision for viewport + size_t minMemoryMapAlignmentmin required alignment of pointers returned by MapMemory (bytes) + VkDeviceSize minTexelBufferOffsetAlignmentmin required alignment for texel buffer offsets (bytes) + VkDeviceSize minUniformBufferOffsetAlignmentmin required alignment for uniform buffer sizes and offsets (bytes) + VkDeviceSize minStorageBufferOffsetAlignmentmin required alignment for storage buffer offsets (bytes) + int32_t minTexelOffsetmin texel offset for OpTextureSampleOffset + uint32_t maxTexelOffsetmax texel offset for OpTextureSampleOffset + int32_t minTexelGatherOffsetmin texel offset for OpTextureGatherOffset + uint32_t maxTexelGatherOffsetmax texel offset for OpTextureGatherOffset + float minInterpolationOffsetfurthest negative offset for interpolateAtOffset + float maxInterpolationOffsetfurthest positive offset for interpolateAtOffset + uint32_t subPixelInterpolationOffsetBitsnumber of subpixel bits for interpolateAtOffset + uint32_t maxFramebufferWidthmax width for a framebuffer + uint32_t maxFramebufferHeightmax height for a framebuffer + uint32_t maxFramebufferLayersmax layer count for a layered framebuffer + VkSampleCountFlags framebufferColorSampleCountssupported color sample counts for a framebuffer + VkSampleCountFlags framebufferDepthSampleCountssupported depth sample counts for a framebuffer + VkSampleCountFlags framebufferStencilSampleCountssupported stencil sample counts for a framebuffer + VkSampleCountFlags framebufferNoAttachmentsSampleCountssupported sample counts for a framebuffer with no attachments + uint32_t maxColorAttachmentsmax number of color attachments per subpass + VkSampleCountFlags sampledImageColorSampleCountssupported color sample counts for a non-integer sampled image + VkSampleCountFlags sampledImageIntegerSampleCountssupported sample counts for an integer image + VkSampleCountFlags sampledImageDepthSampleCountssupported depth sample counts for a sampled image + VkSampleCountFlags sampledImageStencilSampleCountssupported stencil sample counts for a sampled image + VkSampleCountFlags storageImageSampleCountssupported sample counts for a storage image + uint32_t maxSampleMaskWordsmax number of sample mask words + VkBool32 timestampComputeAndGraphicstimestamps on graphics and compute queues + float timestampPeriodnumber of nanoseconds it takes for timestamp query value to increment by 1 + uint32_t maxClipDistancesmax number of clip distances + uint32_t maxCullDistancesmax number of cull distances + uint32_t maxCombinedClipAndCullDistancesmax combined number of user clipping + uint32_t discreteQueuePrioritiesdistinct queue priorities available + float pointSizeRange[2]range (min,max) of supported point sizes + float lineWidthRange[2]range (min,max) of supported line widths + float pointSizeGranularitygranularity of supported point sizes + float lineWidthGranularitygranularity of supported line widths + VkBool32 strictLinesline rasterization follows preferred rules + VkBool32 standardSampleLocationssupports standard sample locations for all supported sample counts + VkDeviceSize optimalBufferCopyOffsetAlignmentoptimal offset of buffer copies + VkDeviceSize optimalBufferCopyRowPitchAlignmentoptimal pitch of buffer copies + VkDeviceSize nonCoherentAtomSizeminimum size and alignment for non-coherent host-mapped device memory access + + + VkStructureType sType + const void* pNext + VkSemaphoreCreateFlags flagsSemaphore creation flags + + + VkStructureType sType + const void* pNext + VkQueryPoolCreateFlags flags + VkQueryType queryType + uint32_t queryCount + VkQueryPipelineStatisticFlags pipelineStatisticsOptional + + + VkStructureType sType + const void* pNext + VkFramebufferCreateFlags flags + VkRenderPass renderPass + uint32_t attachmentCount + const VkImageView* pAttachments + uint32_t width + uint32_t height + uint32_t layers + + + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + uint32_t x + uint32_t y + uint32_t z + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + const VkPipelineStageFlags* pWaitDstStageMask + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + WSI extensions + + VkDisplayKHR displayHandle of the display object + const char* displayNameName of the display + VkExtent2D physicalDimensionsIn millimeters? + VkExtent2D physicalResolutionMax resolution for CRT? + VkSurfaceTransformFlagsKHR supportedTransformsone or more bits from VkSurfaceTransformFlagsKHR + VkBool32 planeReorderPossibleVK_TRUE if the overlay plane's z-order can be changed on this display. + VkBool32 persistentContentVK_TRUE if this is a "smart" display that supports self-refresh/internal buffering. + + + VkDisplayKHR currentDisplayDisplay the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use. + uint32_t currentStackIndexCurrent z-order of the plane. + + + VkExtent2D visibleRegionVisible scanout region. + uint32_t refreshRateNumber of times per second the display is updated. + + + VkDisplayModeKHR displayModeHandle of this display mode. + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkStructureType sType + const void* pNext + VkDisplayModeCreateFlagsKHR flags + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkDisplayPlaneAlphaFlagsKHR supportedAlphaTypes of alpha blending supported, if any. + VkOffset2D minSrcPositionDoes the plane have any position and extent restrictions? + VkOffset2D maxSrcPosition + VkExtent2D minSrcExtent + VkExtent2D maxSrcExtent + VkOffset2D minDstPosition + VkOffset2D maxDstPosition + VkExtent2D minDstExtent + VkExtent2D maxDstExtent + + + VkStructureType sType + const void* pNext + VkDisplaySurfaceCreateFlagsKHR flags + VkDisplayModeKHR displayModeThe mode to use when displaying this surface + uint32_t planeIndexThe plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount. + uint32_t planeStackIndexThe z-order of the plane. + VkSurfaceTransformFlagBitsKHR transformTransform to apply to the images as part of the scanout operation + float globalAlphaGlobal alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR + VkDisplayPlaneAlphaFlagBitsKHR alphaModeWhat type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha. + VkExtent2D imageExtentsize of the images to use with this surface + + + VkStructureType sType + const void* pNext + VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display. + VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in. + VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. + + + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + + + VkStructureType sType + const void* pNext + VkAndroidSurfaceCreateFlagsKHR flags + struct ANativeWindow* window + + + VkStructureType sType + const void* pNext + VkMirSurfaceCreateFlagsKHR flags + MirConnection* connection + MirSurface* mirSurface + + + VkStructureType sType + const void* pNext + VkViSurfaceCreateFlagsNN flags + void* window + + + VkStructureType sType + const void* pNext + VkWaylandSurfaceCreateFlagsKHR flags + struct wl_display* display + struct wl_surface* surface + + + VkStructureType sType + const void* pNext + VkWin32SurfaceCreateFlagsKHR flags + HINSTANCE hinstance + HWND hwnd + + + VkStructureType sType + const void* pNext + VkXlibSurfaceCreateFlagsKHR flags + Display* dpy + Window window + + + VkStructureType sType + const void* pNext + VkXcbSurfaceCreateFlagsKHR flags + xcb_connection_t* connection + xcb_window_t window + + + VkFormat formatSupported pair of rendering format + VkColorSpaceKHR colorSpaceand color space for the surface + + + VkStructureType sType + const void* pNext + VkSwapchainCreateFlagsKHR flags + VkSurfaceKHR surfaceThe swapchain's target surface + uint32_t minImageCountMinimum number of presentation images the application needs + VkFormat imageFormatFormat of the presentation images + VkColorSpaceKHR imageColorSpaceColorspace of the presentation images + VkExtent2D imageExtentDimensions of the presentation images + uint32_t imageArrayLayersDetermines the number of views for multiview/stereo presentation + VkImageUsageFlags imageUsageBits indicating how the presentation images will be used + VkSharingMode imageSharingModeSharing mode used for the presentation images + uint32_t queueFamilyIndexCountNumber of queue families having access to the images in case of concurrent sharing mode + const uint32_t* pQueueFamilyIndicesArray of queue family indices having access to the images in case of concurrent sharing mode + VkSurfaceTransformFlagBitsKHR preTransformThe transform, relative to the device's natural orientation, applied to the image content prior to presentation + VkCompositeAlphaFlagBitsKHR compositeAlphaThe alpha blending mode used when compositing this surface with other surfaces in the window system + VkPresentModeKHR presentModeWhich presentation mode to use for presents on this swap chain + VkBool32 clippedSpecifies whether presentable images may be affected by window clip regions + VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCountNumber of semaphores to wait for before presenting + const VkSemaphore* pWaitSemaphoresSemaphores to wait for before presenting + uint32_t swapchainCountNumber of swapchains to present in this call + const VkSwapchainKHR* pSwapchainsSwapchains to present an image from + const uint32_t* pImageIndicesIndices of which presentable images to present + VkResult* pResultsOptional (i.e. if non-NULL) VkResult for each swapchain + + + VkStructureType sType + const void* pNext + VkDebugReportFlagsEXT flagsIndicates which events call this callback + PFN_vkDebugReportCallbackEXT pfnCallbackFunction pointer of a callback function + void* pUserDataUser data provided to callback function + + + VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT + const void* pNext + uint32_t disabledValidationCheckCountNumber of validation checks to disable + VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable + + + VkStructureType sType + const void* pNext + VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + const char* pObjectNameName to apply to the object + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + uint64_t tagNameThe name of the tag to set on the object + size_t tagSizeThe length in bytes of the tag data + const void* pTagTag data to attach to the object + + + VkStructureType sType + const void* pNext + const char* pMarkerNameName of the debug marker + float color[4]Optional color for debug marker + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + VkImageFormatProperties imageFormatProperties + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE handle + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeoutMilliseconds + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureType sType + const void* pNext + VkBool32 computeBindingPointSupport + + + VkStructureType sType + const void* pNext + uint32_t maxIndirectCommandsLayoutTokenCount + uint32_t maxObjectEntryCounts + uint32_t minSequenceCountBufferOffsetAlignment + uint32_t minSequenceIndexBufferOffsetAlignment + uint32_t minCommandsTokenBufferOffsetAlignment + + + VkIndirectCommandsTokenTypeNVX tokenType + VkBuffer bufferbuffer containing tableEntries and additional data for indirectCommands + VkDeviceSize offsetoffset from the base address of the buffer + + + VkIndirectCommandsTokenTypeNVX tokenType + uint32_t bindingUnitBinding unit for vertex attribute / descriptor set, offset for pushconstants + uint32_t dynamicCountNumber of variable dynamic values for descriptor set / push constants + uint32_t divisorRate the which the array is advanced per element (must be power of 2, minimum 1) + + + VkStructureType sType + const void* pNext + VkPipelineBindPoint pipelineBindPoint + VkIndirectCommandsLayoutUsageFlagsNVX flags + uint32_t tokenCount + const VkIndirectCommandsLayoutTokenNVX* pTokens + + + VkStructureType sType + const void* pNext + VkObjectTableNVX objectTable + VkIndirectCommandsLayoutNVX indirectCommandsLayout + uint32_t indirectCommandsTokenCount + const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens + uint32_t maxSequencesCount + VkCommandBuffer targetCommandBuffer + VkBuffer sequencesCountBuffer + VkDeviceSize sequencesCountOffset + VkBuffer sequencesIndexBuffer + VkDeviceSize sequencesIndexOffset + + + VkStructureType sType + const void* pNext + VkObjectTableNVX objectTable + VkIndirectCommandsLayoutNVX indirectCommandsLayout + uint32_t maxSequencesCount + + + VkStructureType sType + const void* pNext + uint32_t objectCount + const VkObjectEntryTypeNVX* pObjectEntryTypes + const uint32_t* pObjectEntryCounts + const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags + + uint32_t maxUniformBuffersPerDescriptor + uint32_t maxStorageBuffersPerDescriptor + uint32_t maxStorageImagesPerDescriptor + uint32_t maxSampledImagesPerDescriptor + uint32_t maxPipelineLayouts + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkPipeline pipeline + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkPipelineLayout pipelineLayout + VkDescriptorSet descriptorSet + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkBuffer buffer + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkBuffer buffer + VkIndexType indexType + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkPipelineLayout pipelineLayout + VkShaderStageFlags stageFlags + + + VkStructureType sType + void* pNext + VkPhysicalDeviceFeatures features + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceProperties properties + + + + VkStructureType sType + void* pNext + VkFormatProperties formatProperties + + + + VkStructureType sType + void* pNext + VkImageFormatProperties imageFormatProperties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + + + + VkStructureType sType + void* pNext + VkQueueFamilyProperties queueFamilyProperties + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceMemoryProperties memoryProperties + + + + VkStructureType sType + void* pNext + VkSparseImageFormatProperties properties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + + + + VkStructureType sType + void* pNext + uint32_t maxPushDescriptors + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentRegionKHR* pRegionsThe regions that have changed + + + uint32_t rectangleCountNumber of rectangles in pRectangles + const VkRectLayerKHR* pRectanglesArray of rectangles that have changed in a swapchain's image(s) + + + VkOffset2D offsetupper-left corner of a rectangle that has not changed, in pixels of a presentation images + VkExtent2D extentDimensions of a rectangle that has not changed, in pixels of a presentation images + uint32_t layerLayer of a swapchain's image(s), for stereoscopic-3D images + + + VkStructureType sType + void* pNext + VkBool32 variablePointersStorageBuffer + VkBool32 variablePointers + + + + VkExternalMemoryFeatureFlags externalMemoryFeatures + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlags compatibleHandleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flags + VkBufferUsageFlags usage + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + void* pNext + uint8_t deviceUUID[VK_UUID_SIZE] + uint8_t driverUUID[VK_UUID_SIZE] + uint8_t deviceLUID[VK_LUID_SIZE] + uint32_t deviceNodeMask + VkBool32 deviceLUIDValid + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeouts + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures + + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreValuesCount + const uint64_t* pWaitSemaphoreValues + uint32_t signalSemaphoreValuesCount + const uint64_t* pSignalSemaphoreValues + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes + VkExternalFenceHandleTypeFlags compatibleHandleTypes + VkExternalFenceFeatureFlags externalFenceFeatures + + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + void* pNext + VkBool32 multiviewMultiple views in a renderpass + VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader + VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader + + + + VkStructureType sType + void* pNext + uint32_t maxMultiviewViewCountmax number of views in a subpass + uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass + + + + VkStructureType sType + const void* pNext + uint32_t subpassCount + const uint32_t* pViewMasks + uint32_t dependencyCount + const int32_t* pViewOffsets + uint32_t correlationMaskCount + const uint32_t* pCorrelationMasks + + + + VkStructureType sType + void* pNext + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + VkSurfaceCounterFlagsEXT supportedSurfaceCounters + + + VkStructureType sType + const void* pNext + VkDisplayPowerStateEXT powerState + + + VkStructureType sType + const void* pNext + VkDeviceEventTypeEXT deviceEvent + + + VkStructureType sType + const void* pNext + VkDisplayEventTypeEXT displayEvent + + + VkStructureType sType + const void* pNext + VkSurfaceCounterFlagsEXT surfaceCounters + + + VkStructureType sType + void* pNext + uint32_t physicalDeviceCount + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE] + VkBool32 subsetAllocation + + + + VkStructureType sType + const void* pNext + VkMemoryAllocateFlags flags + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + + + + VkStructureType sType + const void* pNext + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + uint32_t splitInstanceBindRegionCount + const VkRect2D* pSplitInstanceBindRegions + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + uint32_t deviceRenderAreaCount + const VkRect2D* pDeviceRenderAreas + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const uint32_t* pWaitSemaphoreDeviceIndices + uint32_t commandBufferCount + const uint32_t* pCommandBufferDeviceMasks + uint32_t signalSemaphoreCount + const uint32_t* pSignalSemaphoreDeviceIndices + + + + VkStructureType sType + const void* pNext + uint32_t resourceDeviceIndex + uint32_t memoryDeviceIndex + + + + VkStructureType sType + const void* pNext + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE] + VkDeviceGroupPresentModeFlagsKHR modes + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint32_t imageIndex + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t deviceMask + + + VkStructureType sType + const void* pNext + uint32_t swapchainCount + const uint32_t* pDeviceMasks + VkDeviceGroupPresentModeFlagBitsKHR mode + + + VkStructureType sType + const void* pNext + uint32_t physicalDeviceCount + const VkPhysicalDevice* pPhysicalDevices + + + + VkStructureType sType + const void* pNext + VkDeviceGroupPresentModeFlagsKHR modes + + + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write + VkDescriptorType descriptorTypeDescriptor type to write + size_t offsetOffset into pData where the descriptors to update are stored + size_t strideStride between two descriptors in pData when writing more than one descriptor + + + + VkStructureType sType + void* pNext + VkDescriptorUpdateTemplateCreateFlags flags + uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template + VkDescriptorUpdateTemplateType templateType + VkDescriptorSetLayout descriptorSetLayout + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayoutpipelineLayoutIf used for push descriptors, this is the only allowed layout + uint32_t set + + + + float x + float y + + + Display primary in chromaticity coordinates + VkStructureType sType + const void* pNext + From SMPTE 2086 + VkXYColorEXT displayPrimaryRedDisplay primary's Red + VkXYColorEXT displayPrimaryGreenDisplay primary's Green + VkXYColorEXT displayPrimaryBlueDisplay primary's Blue + VkXYColorEXT whitePointDisplay primary's Blue + float maxLuminanceDisplay maximum luminance + float minLuminanceDisplay minimum luminance + From CTA 861.3 + float maxContentLightLevelContent maximum luminance + float maxFrameAverageLightLevel + + + uint64_t refreshDurationNumber of nanoseconds from the start of one refresh cycle to the next + + + uint32_t presentIDApplication-provided identifier, previously given to vkQueuePresentKHR + uint64_t desiredPresentTimeEarliest time an image should have been presented, previously given to vkQueuePresentKHR + uint64_t actualPresentTimeTime the image was actually displayed + uint64_t earliestPresentTimeEarliest time the image could have been displayed + uint64_t presentMarginHow early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentTimeGOOGLE* pTimesThe earliest times to present images + + + uint32_t presentIDApplication-provided identifier + uint64_t desiredPresentTimeEarliest time an image should be presented + + + VkStructureType sType + const void* pNext + VkIOSSurfaceCreateFlagsMVK flags + const void* pView + + + VkStructureType sType + const void* pNext + VkMacOSSurfaceCreateFlagsMVK flags + const void* pView + + + float xcoeff + float ycoeff + + + VkStructureType sType + const void* pNext + VkBool32 viewportWScalingEnable + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + VkViewportCoordinateSwizzleNV x + VkViewportCoordinateSwizzleNV y + VkViewportCoordinateSwizzleNV z + VkViewportCoordinateSwizzleNV w + + + VkStructureType sType + const void* pNext + VkPipelineViewportSwizzleStateCreateFlagsNV flags + uint32_t viewportCount + const VkViewportSwizzleNV* pViewportSwizzles + + + VkStructureType sType + void* pNext + uint32_t maxDiscardRectanglesmax number of active discard rectangles + + + VkStructureType sType + const void* pNext + VkPipelineDiscardRectangleStateCreateFlagsEXT flags + VkDiscardRectangleModeEXT discardRectangleMode + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + VkStructureType sType + void* pNext + VkBool32 perViewPositionAllComponents + + + uint32_t subpass + uint32_t inputAttachmentIndex + VkImageAspectFlags aspectMask + + + + VkStructureType sType + const void* pNext + uint32_t aspectReferenceCount + const VkInputAttachmentAspectReference* pAspectReferences + + + + VkStructureType sType + const void* pNext + VkSurfaceKHR surface + + + VkStructureType sType + void* pNext + VkSurfaceCapabilitiesKHR surfaceCapabilities + + + VkStructureType sType + void* pNext + VkSurfaceFormatKHR surfaceFormat + + + VkStructureType sType + void* pNext + VkImageUsageFlags sharedPresentSupportedUsageFlagsSupported image usage flags if swapchain created using a shared present mode + + + VkStructureType sType + void* pNext + VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock + VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block + VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant + VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs + + + + VkStructureType sType + void* pNext + uint32_t subgroupSizeThe size of a subgroup for this queue. + VkShaderStageFlags supportedStagesBitfield of what shader stages support subgroup operations + VkSubgroupFeatureFlags supportedOperationsBitfield of what subgroup operations are supported. + VkBool32 quadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + void* pNext + VkMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkSparseImageMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkPointClippingBehavior pointClippingBehavior + + + + VkStructureType sType + void* pNext + VkBool32 prefersDedicatedAllocation + VkBool32 requiresDedicatedAllocation + + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + + VkStructureType sType + const void* pNext + VkImageUsageFlags usage + + + + VkStructureType sType + const void* pNext + VkTessellationDomainOrigin domainOrigin + + + + VkStructureType sType + const void* pNext + VkSamplerYcbcrConversion conversion + + + + VkStructureType sType + const void* pNext + VkFormat format + VkSamplerYcbcrModelConversion ycbcrModel + VkSamplerYcbcrRange ycbcrRange + VkComponentMapping components + VkChromaLocation xChromaOffset + VkChromaLocation yChromaOffset + VkFilter chromaFilter + VkBool32 forceExplicitReconstruction + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + void* pNext + VkBool32 samplerYcbcrConversionSampler color conversion supported + + + + VkStructureType sType + void* pNext + uint32_t combinedImageSamplerDescriptorCount + + + + VkStructureType sType + void* pNext + VkBool32 supportsTextureGatherLODBiasAMD + + + VkStructureType sType + const void* pNext + VkBool32 protectedSubmitSubmit protected command buffers + + + VkStructureType sType + void* pNext + VkBool32 protectedMemory + + + VkStructureType sType + void* pNext + VkBool32 protectedNoFault + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueIndex + + + VkStructureType sType + const void* pNext + VkPipelineCoverageToColorStateCreateFlagsNV flags + VkBool32 coverageToColorEnable + uint32_t coverageToColorLocation + + + VkStructureType sType + void* pNext + VkBool32 filterMinmaxSingleComponentFormats + VkBool32 filterMinmaxImageComponentMapping + + + float x + float y + + + VkStructureType sType + const void* pNext + VkSampleCountFlagBits sampleLocationsPerPixel + VkExtent2D sampleLocationGridSize + uint32_t sampleLocationsCount + const VkSampleLocationEXT* pSampleLocations + + + uint32_t attachmentIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + uint32_t subpassIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + const void* pNext + uint32_t attachmentInitialSampleLocationsCount + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations + uint32_t postSubpassSampleLocationsCount + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations + + + VkStructureType sType + const void* pNext + VkBool32 sampleLocationsEnable + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + void* pNext + VkSampleCountFlags sampleLocationSampleCounts + VkExtent2D maxSampleLocationGridSize + float sampleLocationCoordinateRange[2] + uint32_t sampleLocationSubPixelBits + VkBool32 variableSampleLocations + + + VkStructureType sType + void* pNext + VkExtent2D maxSampleLocationGridSize + + + VkStructureType sType + const void* pNext + VkSamplerReductionModeEXT reductionMode + + + VkStructureType sType + void* pNext + VkBool32 advancedBlendCoherentOperations + + + VkStructureType sType + void* pNext + uint32_t advancedBlendMaxColorAttachments + VkBool32 advancedBlendIndependentBlend + VkBool32 advancedBlendNonPremultipliedSrcColor + VkBool32 advancedBlendNonPremultipliedDstColor + VkBool32 advancedBlendCorrelatedOverlap + VkBool32 advancedBlendAllOperations + + + VkStructureType sType + const void* pNext + VkBool32 srcPremultiplied + VkBool32 dstPremultiplied + VkBlendOverlapEXT blendOverlap + + + VkStructureType sType + const void* pNext + VkPipelineCoverageModulationStateCreateFlagsNV flags + VkCoverageModulationModeNV coverageModulationMode + VkBool32 coverageModulationTableEnable + uint32_t coverageModulationTableCount + const float* pCoverageModulationTable + + + VkStructureType sType + const void* pNext + uint32_t viewFormatCount + const VkFormat* pViewFormats + + + VkStructureType sType + const void* pNext + VkValidationCacheCreateFlagsEXT flags + size_t initialDataSize + const void* pInitialData + + + VkStructureType sType + const void* pNext + VkValidationCacheEXT validationCache + + + VkStructureType sType + void* pNext + uint32_t maxPerSetDescriptors + VkDeviceSize maxMemoryAllocationSize + + + + VkStructureType sType + void* pNext + VkBool32 supported + + + + VkStructureType sType + void* pNext + VkBool32 shaderDrawParameters + + + VkStructureType sType + const void* pNext + const void* handle + int stride + int format + int usage + + + uint32_t numUsedVgprs + uint32_t numUsedSgprs + uint32_t ldsSizePerLocalWorkGroup + size_t ldsUsageSizeInBytes + size_t scratchMemUsageInBytes + + + VkShaderStageFlags shaderStageMask + VkShaderResourceUsageAMD resourceUsage + uint32_t numPhysicalVgprs + uint32_t numPhysicalSgprs + uint32_t numAvailableVgprs + uint32_t numAvailableSgprs + uint32_t computeWorkGroupSize[3] + + + VkStructureType sType + const void* pNext + VkQueueGlobalPriorityEXT globalPriority + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + const char* pObjectName + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + uint64_t tagName + size_t tagSize + const void* pTag + + + VkStructureType sType + const void* pNext + const char* pLabelName + float color[4] + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCreateFlagsEXT flags + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageType + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback + void* pUserData + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCallbackDataFlagsEXT flags + const char* pMessageIdName + int32_t messageIdNumber + const char* pMessage + uint32_t queueLabelCount + VkDebugUtilsLabelEXT* pQueueLabels + uint32_t cmdBufLabelCount + VkDebugUtilsLabelEXT* pCmdBufLabels + uint32_t objectCount + VkDebugUtilsObjectNameInfoEXT* pObjects + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + void* pHostPointer + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + void* pNext + VkDeviceSize minImportedHostPointerAlignment + + + VkStructureType sType + void* pNextPointer to next structure + float primitiveOverestimationSizeThe size in pixels the primitive is enlarged at each edge during conservative rasterization + float maxExtraPrimitiveOverestimationSizeThe maximum additional overestimation the client can specify in the pipeline state + float extraPrimitiveOverestimationSizeGranularityThe granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize + VkBool32 primitiveUnderestimationtrue if the implementation supports conservative rasterization underestimation mode + VkBool32 conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines + VkBool32 degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized + VkBool32 degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized + VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input + variable + VkBool32 conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags + VkConservativeRasterizationModeEXT conservativeRasterizationMode + float extraPrimitiveOverestimationSize + + + uint32_t binding + uint32_t divisor + + + VkStructureType sType + const void* pNext + uint32_t vertexBindingDivisorCount + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors + + + VkStructureType sType + void* pNext + uint32_t maxVertexAttribDivisormax value of vertex attribute divisor + + + + Vulkan enumerant (token) definitions + + + + + + + + + + + + + + + + + + + + + + + + + + + + Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in + their own numeric namespaces. The "name" attribute is the C enum + type name, and is pulled in from a type tag definition above + (slightly clunky, but retains the type / enum distinction). "type" + attributes of "enum" or "bitmask" indicate that these values should + be generated inside an appropriate definition. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge + enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not + alias! + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Return codes (positive values) + + + + + + + Error codes (negative values) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Flags + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WSI Extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VkResult vkCreateInstance + const VkInstanceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkInstance* pInstance + + + void vkDestroyInstance + VkInstance instance + const VkAllocationCallbacks* pAllocator + + + VkResult vkEnumeratePhysicalDevices + VkInstance instance + uint32_t* pPhysicalDeviceCount + VkPhysicalDevice* pPhysicalDevices + + + PFN_vkVoidFunction vkGetDeviceProcAddr + VkDevice device + const char* pName + + + PFN_vkVoidFunction vkGetInstanceProcAddr + VkInstance instance + const char* pName + + + void vkGetPhysicalDeviceProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties* pProperties + + + void vkGetPhysicalDeviceQueueFamilyProperties + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties* pQueueFamilyProperties + + + void vkGetPhysicalDeviceMemoryProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties* pMemoryProperties + + + void vkGetPhysicalDeviceFeatures + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures* pFeatures + + + void vkGetPhysicalDeviceFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties* pFormatProperties + + + VkResult vkGetPhysicalDeviceImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkImageFormatProperties* pImageFormatProperties + + + VkResult vkCreateDevice + VkPhysicalDevice physicalDevice + const VkDeviceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDevice* pDevice + + + void vkDestroyDevice + VkDevice device + const VkAllocationCallbacks* pAllocator + + + VkResult vkEnumerateInstanceVersion + uint32_t* pApiVersion + + + VkResult vkEnumerateInstanceLayerProperties + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateInstanceExtensionProperties + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + VkResult vkEnumerateDeviceLayerProperties + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateDeviceExtensionProperties + VkPhysicalDevice physicalDevice + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + void vkGetDeviceQueue + VkDevice device + uint32_t queueFamilyIndex + uint32_t queueIndex + VkQueue* pQueue + + + VkResult vkQueueSubmit + VkQueue queue + uint32_t submitCount + const VkSubmitInfo* pSubmits + VkFence fence + + + VkResult vkQueueWaitIdle + VkQueue queue + + + VkResult vkDeviceWaitIdle + VkDevice device + + all sname:VkQueue objects created from pname:device + + + + VkResult vkAllocateMemory + VkDevice device + const VkMemoryAllocateInfo* pAllocateInfo + const VkAllocationCallbacks* pAllocator + VkDeviceMemory* pMemory + + + void vkFreeMemory + VkDevice device + VkDeviceMemory memory + const VkAllocationCallbacks* pAllocator + + + VkResult vkMapMemory + VkDevice device + VkDeviceMemory memory + VkDeviceSize offset + VkDeviceSize size + VkMemoryMapFlags flags + void** ppData + + + void vkUnmapMemory + VkDevice device + VkDeviceMemory memory + + + VkResult vkFlushMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + VkResult vkInvalidateMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + void vkGetDeviceMemoryCommitment + VkDevice device + VkDeviceMemory memory + VkDeviceSize* pCommittedMemoryInBytes + + + void vkGetBufferMemoryRequirements + VkDevice device + VkBuffer buffer + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindBufferMemory + VkDevice device + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageMemoryRequirements + VkDevice device + VkImage image + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindImageMemory + VkDevice device + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageSparseMemoryRequirements + VkDevice device + VkImage image + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements* pSparseMemoryRequirements + + + void vkGetPhysicalDeviceSparseImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + uint32_t* pPropertyCount + VkSparseImageFormatProperties* pProperties + + + VkResult vkQueueBindSparse + VkQueue queue + uint32_t bindInfoCount + const VkBindSparseInfo* pBindInfo + VkFence fence + + + VkResult vkCreateFence + VkDevice device + const VkFenceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + void vkDestroyFence + VkDevice device + VkFence fence + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + + + VkResult vkGetFenceStatus + VkDevice device + VkFence fence + + + VkResult vkWaitForFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + VkBool32 waitAll + uint64_t timeout + + + VkResult vkCreateSemaphore + VkDevice device + const VkSemaphoreCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSemaphore* pSemaphore + + + void vkDestroySemaphore + VkDevice device + VkSemaphore semaphore + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateEvent + VkDevice device + const VkEventCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkEvent* pEvent + + + void vkDestroyEvent + VkDevice device + VkEvent event + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetEventStatus + VkDevice device + VkEvent event + + + VkResult vkSetEvent + VkDevice device + VkEvent event + + + VkResult vkResetEvent + VkDevice device + VkEvent event + + + VkResult vkCreateQueryPool + VkDevice device + const VkQueryPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkQueryPool* pQueryPool + + + void vkDestroyQueryPool + VkDevice device + VkQueryPool queryPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetQueryPoolResults + VkDevice device + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + size_t dataSize + void* pData + VkDeviceSize stride + VkQueryResultFlags flags + + + VkResult vkCreateBuffer + VkDevice device + const VkBufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBuffer* pBuffer + + + void vkDestroyBuffer + VkDevice device + VkBuffer buffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateBufferView + VkDevice device + const VkBufferViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBufferView* pView + + + void vkDestroyBufferView + VkDevice device + VkBufferView bufferView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateImage + VkDevice device + const VkImageCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImage* pImage + + + void vkDestroyImage + VkDevice device + VkImage image + const VkAllocationCallbacks* pAllocator + + + void vkGetImageSubresourceLayout + VkDevice device + VkImage image + const VkImageSubresource* pSubresource + VkSubresourceLayout* pLayout + + + VkResult vkCreateImageView + VkDevice device + const VkImageViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImageView* pView + + + void vkDestroyImageView + VkDevice device + VkImageView imageView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateShaderModule + VkDevice device + const VkShaderModuleCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkShaderModule* pShaderModule + + + void vkDestroyShaderModule + VkDevice device + VkShaderModule shaderModule + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineCache + VkDevice device + const VkPipelineCacheCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineCache* pPipelineCache + + + void vkDestroyPipelineCache + VkDevice device + VkPipelineCache pipelineCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPipelineCacheData + VkDevice device + VkPipelineCache pipelineCache + size_t* pDataSize + void* pData + + + VkResult vkMergePipelineCaches + VkDevice device + VkPipelineCache dstCache + uint32_t srcCacheCount + const VkPipelineCache* pSrcCaches + + + VkResult vkCreateGraphicsPipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkGraphicsPipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateComputePipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkComputePipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + void vkDestroyPipeline + VkDevice device + VkPipeline pipeline + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineLayout + VkDevice device + const VkPipelineLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineLayout* pPipelineLayout + + + void vkDestroyPipelineLayout + VkDevice device + VkPipelineLayout pipelineLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateSampler + VkDevice device + const VkSamplerCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSampler* pSampler + + + void vkDestroySampler + VkDevice device + VkSampler sampler + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorSetLayout + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorSetLayout* pSetLayout + + + void vkDestroyDescriptorSetLayout + VkDevice device + VkDescriptorSetLayout descriptorSetLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorPool + VkDevice device + const VkDescriptorPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorPool* pDescriptorPool + + + void vkDestroyDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + VkDescriptorPoolResetFlags flags + + any sname:VkDescriptorSet objects allocated from pname:descriptorPool + + + + VkResult vkAllocateDescriptorSets + VkDevice device + const VkDescriptorSetAllocateInfo* pAllocateInfo + VkDescriptorSet* pDescriptorSets + + + VkResult vkFreeDescriptorSets + VkDevice device + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + + + void vkUpdateDescriptorSets + VkDevice device + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + uint32_t descriptorCopyCount + const VkCopyDescriptorSet* pDescriptorCopies + + + VkResult vkCreateFramebuffer + VkDevice device + const VkFramebufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFramebuffer* pFramebuffer + + + void vkDestroyFramebuffer + VkDevice device + VkFramebuffer framebuffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateRenderPass + VkDevice device + const VkRenderPassCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkRenderPass* pRenderPass + + + void vkDestroyRenderPass + VkDevice device + VkRenderPass renderPass + const VkAllocationCallbacks* pAllocator + + + void vkGetRenderAreaGranularity + VkDevice device + VkRenderPass renderPass + VkExtent2D* pGranularity + + + VkResult vkCreateCommandPool + VkDevice device + const VkCommandPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCommandPool* pCommandPool + + + void vkDestroyCommandPool + VkDevice device + VkCommandPool commandPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolResetFlags flags + + + VkResult vkAllocateCommandBuffers + VkDevice device + const VkCommandBufferAllocateInfo* pAllocateInfo + VkCommandBuffer* pCommandBuffers + + + void vkFreeCommandBuffers + VkDevice device + VkCommandPool commandPool + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkBeginCommandBuffer + VkCommandBuffer commandBuffer + const VkCommandBufferBeginInfo* pBeginInfo + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkEndCommandBuffer + VkCommandBuffer commandBuffer + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkResetCommandBuffer + VkCommandBuffer commandBuffer + VkCommandBufferResetFlags flags + + + void vkCmdBindPipeline + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + + + void vkCmdSetViewport + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewport* pViewports + + + void vkCmdSetScissor + VkCommandBuffer commandBuffer + uint32_t firstScissor + uint32_t scissorCount + const VkRect2D* pScissors + + + void vkCmdSetLineWidth + VkCommandBuffer commandBuffer + float lineWidth + + + void vkCmdSetDepthBias + VkCommandBuffer commandBuffer + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + + + void vkCmdSetBlendConstants + VkCommandBuffer commandBuffer + const float blendConstants[4] + + + void vkCmdSetDepthBounds + VkCommandBuffer commandBuffer + float minDepthBounds + float maxDepthBounds + + + void vkCmdSetStencilCompareMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t compareMask + + + void vkCmdSetStencilWriteMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t writeMask + + + void vkCmdSetStencilReference + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t reference + + + void vkCmdBindDescriptorSets + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t firstSet + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + uint32_t dynamicOffsetCount + const uint32_t* pDynamicOffsets + + + void vkCmdBindIndexBuffer + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkIndexType indexType + + + void vkCmdBindVertexBuffers + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + + + void vkCmdDraw + VkCommandBuffer commandBuffer + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + void vkCmdDrawIndexed + VkCommandBuffer commandBuffer + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + void vkCmdDrawIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDispatch + VkCommandBuffer commandBuffer + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + void vkCmdDispatchIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + + + void vkCmdCopyBuffer + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferCopy* pRegions + + + void vkCmdCopyImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageCopy* pRegions + + + void vkCmdBlitImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageBlit* pRegions + VkFilter filter + + + void vkCmdCopyBufferToImage + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdCopyImageToBuffer + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdUpdateBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize dataSize + const void* pData + + + void vkCmdFillBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize size + uint32_t data + + + void vkCmdClearColorImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearColorValue* pColor + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearDepthStencilImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearDepthStencilValue* pDepthStencil + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearAttachments + VkCommandBuffer commandBuffer + uint32_t attachmentCount + const VkClearAttachment* pAttachments + uint32_t rectCount + const VkClearRect* pRects + + + void vkCmdResolveImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageResolve* pRegions + + + void vkCmdSetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdResetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdWaitEvents + VkCommandBuffer commandBuffer + uint32_t eventCount + const VkEvent* pEvents + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdPipelineBarrier + VkCommandBuffer commandBuffer + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkDependencyFlags dependencyFlags + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdBeginQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + VkQueryControlFlags flags + + + void vkCmdEndQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + + + void vkCmdResetQueryPool + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + + + void vkCmdWriteTimestamp + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkQueryPool queryPool + uint32_t query + + + void vkCmdCopyQueryPoolResults + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize stride + VkQueryResultFlags flags + + + void vkCmdPushConstants + VkCommandBuffer commandBuffer + VkPipelineLayout layout + VkShaderStageFlags stageFlags + uint32_t offset + uint32_t size + const void* pValues + + + void vkCmdBeginRenderPass + VkCommandBuffer commandBuffer + const VkRenderPassBeginInfo* pRenderPassBegin + VkSubpassContents contents + + + void vkCmdNextSubpass + VkCommandBuffer commandBuffer + VkSubpassContents contents + + + void vkCmdEndRenderPass + VkCommandBuffer commandBuffer + + + void vkCmdExecuteCommands + VkCommandBuffer commandBuffer + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkCreateAndroidSurfaceKHR + VkInstance instance + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPropertiesKHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlanePropertiesKHR* pProperties + + + VkResult vkGetDisplayPlaneSupportedDisplaysKHR + VkPhysicalDevice physicalDevice + uint32_t planeIndex + uint32_t* pDisplayCount + VkDisplayKHR* pDisplays + + + VkResult vkGetDisplayModePropertiesKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModePropertiesKHR* pProperties + + + VkResult vkCreateDisplayModeKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + const VkDisplayModeCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDisplayModeKHR* pMode + + + VkResult vkGetDisplayPlaneCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkDisplayModeKHR mode + uint32_t planeIndex + VkDisplayPlaneCapabilitiesKHR* pCapabilities + + + VkResult vkCreateDisplayPlaneSurfaceKHR + VkInstance instance + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateSharedSwapchainsKHR + VkDevice device + uint32_t swapchainCount + const VkSwapchainCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchains + + + VkResult vkCreateMirSurfaceKHR + VkInstance instance + const VkMirSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + MirConnection* connection + + + void vkDestroySurfaceKHR + VkInstance instance + VkSurfaceKHR surface + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPhysicalDeviceSurfaceSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + VkSurfaceKHR surface + VkBool32* pSupported + + + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pSurfaceFormatCount + VkSurfaceFormatKHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pPresentModeCount + VkPresentModeKHR* pPresentModes + + + VkResult vkCreateSwapchainKHR + VkDevice device + const VkSwapchainCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchain + + + void vkDestroySwapchainKHR + VkDevice device + VkSwapchainKHR swapchain + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetSwapchainImagesKHR + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pSwapchainImageCount + VkImage* pSwapchainImages + + + VkResult vkAcquireNextImageKHR + VkDevice device + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t* pImageIndex + + + VkResult vkQueuePresentKHR + VkQueue queue + const VkPresentInfoKHR* pPresentInfo + + + VkResult vkCreateViSurfaceNN + VkInstance instance + const VkViSurfaceCreateInfoNN* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateWaylandSurfaceKHR + VkInstance instance + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + struct wl_display* display + + + VkResult vkCreateWin32SurfaceKHR + VkInstance instance + const VkWin32SurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + + + VkResult vkCreateXlibSurfaceKHR + VkInstance instance + const VkXlibSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + Display* dpy + VisualID visualID + + + VkResult vkCreateXcbSurfaceKHR + VkInstance instance + const VkXcbSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + xcb_connection_t* connection + xcb_visualid_t visual_id + + + VkResult vkCreateDebugReportCallbackEXT + VkInstance instance + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugReportCallbackEXT* pCallback + + + void vkDestroyDebugReportCallbackEXT + VkInstance instance + VkDebugReportCallbackEXT callback + const VkAllocationCallbacks* pAllocator + + + void vkDebugReportMessageEXT + VkInstance instance + VkDebugReportFlagsEXT flags + VkDebugReportObjectTypeEXT objectType + uint64_t object + size_t location + int32_t messageCode + const char* pLayerPrefix + const char* pMessage + + + VkResult vkDebugMarkerSetObjectNameEXT + VkDevice device + const VkDebugMarkerObjectNameInfoEXT* pNameInfo + + + VkResult vkDebugMarkerSetObjectTagEXT + VkDevice device + const VkDebugMarkerObjectTagInfoEXT* pTagInfo + + + void vkCmdDebugMarkerBeginEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + void vkCmdDebugMarkerEndEXT + VkCommandBuffer commandBuffer + + + void vkCmdDebugMarkerInsertEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkExternalMemoryHandleTypeFlagsNV externalHandleType + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties + + + VkResult vkGetMemoryWin32HandleNV + VkDevice device + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE* pHandle + + + void vkCmdDrawIndirectCountAMD + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirectCountAMD + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + void vkCmdProcessCommandsNVX + VkCommandBuffer commandBuffer + const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo + + + void vkCmdReserveSpaceForCommandsNVX + VkCommandBuffer commandBuffer + const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo + + + VkResult vkCreateIndirectCommandsLayoutNVX + VkDevice device + const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout + + + void vkDestroyIndirectCommandsLayoutNVX + VkDevice device + VkIndirectCommandsLayoutNVX indirectCommandsLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateObjectTableNVX + VkDevice device + const VkObjectTableCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkObjectTableNVX* pObjectTable + + + void vkDestroyObjectTableNVX + VkDevice device + VkObjectTableNVX objectTable + const VkAllocationCallbacks* pAllocator + + + VkResult vkRegisterObjectsNVX + VkDevice device + VkObjectTableNVX objectTable + uint32_t objectCount + const VkObjectTableEntryNVX* const* ppObjectTableEntries + const uint32_t* pObjectIndices + + + VkResult vkUnregisterObjectsNVX + VkDevice device + VkObjectTableNVX objectTable + uint32_t objectCount + const VkObjectEntryTypeNVX* pObjectEntryTypes + const uint32_t* pObjectIndices + + + void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX + VkPhysicalDevice physicalDevice + VkDeviceGeneratedCommandsFeaturesNVX* pFeatures + VkDeviceGeneratedCommandsLimitsNVX* pLimits + + + void vkGetPhysicalDeviceFeatures2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures2* pFeatures + + + + void vkGetPhysicalDeviceProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties2* pProperties + + + + void vkGetPhysicalDeviceFormatProperties2 + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties2* pFormatProperties + + + + VkResult vkGetPhysicalDeviceImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo + VkImageFormatProperties2* pImageFormatProperties + + + + void vkGetPhysicalDeviceQueueFamilyProperties2 + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties2* pQueueFamilyProperties + + + + void vkGetPhysicalDeviceMemoryProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties2* pMemoryProperties + + + + void vkGetPhysicalDeviceSparseImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo + uint32_t* pPropertyCount + VkSparseImageFormatProperties2* pProperties + + + + void vkCmdPushDescriptorSetKHR + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t set + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + + + void vkTrimCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolTrimFlags flags + + + + void vkGetPhysicalDeviceExternalBufferProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo + VkExternalBufferProperties* pExternalBufferProperties + + + + VkResult vkGetMemoryWin32HandleKHR + VkDevice device + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkGetMemoryWin32HandlePropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties + + + VkResult vkGetMemoryFdKHR + VkDevice device + const VkMemoryGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkGetMemoryFdPropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + int fd + VkMemoryFdPropertiesKHR* pMemoryFdProperties + + + void vkGetPhysicalDeviceExternalSemaphoreProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo + VkExternalSemaphoreProperties* pExternalSemaphoreProperties + + + + VkResult vkGetSemaphoreWin32HandleKHR + VkDevice device + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportSemaphoreWin32HandleKHR + VkDevice device + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo + + + VkResult vkGetSemaphoreFdKHR + VkDevice device + const VkSemaphoreGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportSemaphoreFdKHR + VkDevice device + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo + + + void vkGetPhysicalDeviceExternalFenceProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo + VkExternalFenceProperties* pExternalFenceProperties + + + + VkResult vkGetFenceWin32HandleKHR + VkDevice device + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportFenceWin32HandleKHR + VkDevice device + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo + + + VkResult vkGetFenceFdKHR + VkDevice device + const VkFenceGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportFenceFdKHR + VkDevice device + const VkImportFenceFdInfoKHR* pImportFenceFdInfo + + + VkResult vkReleaseDisplayEXT + VkPhysicalDevice physicalDevice + VkDisplayKHR display + + + VkResult vkAcquireXlibDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + VkDisplayKHR display + + + VkResult vkGetRandROutputDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + RROutput rrOutput + VkDisplayKHR* pDisplay + + + VkResult vkDisplayPowerControlEXT + VkDevice device + VkDisplayKHR display + const VkDisplayPowerInfoEXT* pDisplayPowerInfo + + + VkResult vkRegisterDeviceEventEXT + VkDevice device + const VkDeviceEventInfoEXT* pDeviceEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkRegisterDisplayEventEXT + VkDevice device + VkDisplayKHR display + const VkDisplayEventInfoEXT* pDisplayEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkGetSwapchainCounterEXT + VkDevice device + VkSwapchainKHR swapchain + VkSurfaceCounterFlagBitsEXT counter + uint64_t* pCounterValue + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilities2EXT* pSurfaceCapabilities + + + VkResult vkEnumeratePhysicalDeviceGroups + VkInstance instance + uint32_t* pPhysicalDeviceGroupCount + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties + + + + void vkGetDeviceGroupPeerMemoryFeatures + VkDevice device + uint32_t heapIndex + uint32_t localDeviceIndex + uint32_t remoteDeviceIndex + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures + + + + VkResult vkBindBufferMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindBufferMemoryInfo* pBindInfos + + + + VkResult vkBindImageMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindImageMemoryInfo* pBindInfos + + + + void vkCmdSetDeviceMask + VkCommandBuffer commandBuffer + uint32_t deviceMask + + + + VkResult vkGetDeviceGroupPresentCapabilitiesKHR + VkDevice device + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities + + + VkResult vkGetDeviceGroupSurfacePresentModesKHR + VkDevice device + VkSurfaceKHR surface + VkDeviceGroupPresentModeFlagsKHR* pModes + + + VkResult vkAcquireNextImage2KHR + VkDevice device + const VkAcquireNextImageInfoKHR* pAcquireInfo + uint32_t* pImageIndex + + + void vkCmdDispatchBase + VkCommandBuffer commandBuffer + uint32_t baseGroupX + uint32_t baseGroupY + uint32_t baseGroupZ + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + + VkResult vkGetPhysicalDevicePresentRectanglesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pRectCount + VkRect2D* pRects + + + VkResult vkCreateDescriptorUpdateTemplate + VkDevice device + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate + + + + void vkDestroyDescriptorUpdateTemplate + VkDevice device + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const VkAllocationCallbacks* pAllocator + + + + void vkUpdateDescriptorSetWithTemplate + VkDevice device + VkDescriptorSet descriptorSet + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const void* pData + + + + void vkCmdPushDescriptorSetWithTemplateKHR + VkCommandBuffer commandBuffer + VkDescriptorUpdateTemplate descriptorUpdateTemplate + VkPipelineLayout layout + uint32_t set + const void* pData + + + void vkSetHdrMetadataEXT + VkDevice device + uint32_t swapchainCount + const VkSwapchainKHR* pSwapchains + const VkHdrMetadataEXT* pMetadata + + + VkResult vkGetSwapchainStatusKHR + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkGetRefreshCycleDurationGOOGLE + VkDevice device + VkSwapchainKHR swapchain + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties + + + VkResult vkGetPastPresentationTimingGOOGLE + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pPresentationTimingCount + VkPastPresentationTimingGOOGLE* pPresentationTimings + + + VkResult vkCreateIOSSurfaceMVK + VkInstance instance + const VkIOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateMacOSSurfaceMVK + VkInstance instance + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + void vkCmdSetViewportWScalingNV + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + void vkCmdSetDiscardRectangleEXT + VkCommandBuffer commandBuffer + uint32_t firstDiscardRectangle + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + void vkCmdSetSampleLocationsEXT + VkCommandBuffer commandBuffer + const VkSampleLocationsInfoEXT* pSampleLocationsInfo + + + void vkGetPhysicalDeviceMultisamplePropertiesEXT + VkPhysicalDevice physicalDevice + VkSampleCountFlagBits samples + VkMultisamplePropertiesEXT* pMultisampleProperties + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + VkSurfaceCapabilities2KHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + uint32_t* pSurfaceFormatCount + VkSurfaceFormat2KHR* pSurfaceFormats + + + void vkGetBufferMemoryRequirements2 + VkDevice device + const VkBufferMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageMemoryRequirements2 + VkDevice device + const VkImageMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageSparseMemoryRequirements2 + VkDevice device + const VkImageSparseMemoryRequirementsInfo2* pInfo + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements + + + + VkResult vkCreateSamplerYcbcrConversion + VkDevice device + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSamplerYcbcrConversion* pYcbcrConversion + + + + void vkDestroySamplerYcbcrConversion + VkDevice device + VkSamplerYcbcrConversion ycbcrConversion + const VkAllocationCallbacks* pAllocator + + + + void vkGetDeviceQueue2 + VkDevice device + const VkDeviceQueueInfo2* pQueueInfo + VkQueue* pQueue + + + VkResult vkCreateValidationCacheEXT + VkDevice device + const VkValidationCacheCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkValidationCacheEXT* pValidationCache + + + void vkDestroyValidationCacheEXT + VkDevice device + VkValidationCacheEXT validationCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetValidationCacheDataEXT + VkDevice device + VkValidationCacheEXT validationCache + size_t* pDataSize + void* pData + + + VkResult vkMergeValidationCachesEXT + VkDevice device + VkValidationCacheEXT dstCache + uint32_t srcCacheCount + const VkValidationCacheEXT* pSrcCaches + + + void vkGetDescriptorSetLayoutSupport + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + VkDescriptorSetLayoutSupport* pSupport + + + + VkResult vkGetSwapchainGrallocUsageANDROID + VkDevice device + VkFormat format + VkImageUsageFlags imageUsage + int* grallocUsage + + + VkResult vkAcquireImageANDROID + VkDevice device + VkImage image + int nativeFenceFd + VkSemaphore semaphore + VkFence fence + + + VkResult vkQueueSignalReleaseImageANDROID + VkQueue queue + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + VkImage image + int* pNativeFenceFd + + + VkResult vkGetShaderInfoAMD + VkDevice device + VkPipeline pipeline + VkShaderStageFlagBits shaderStage + VkShaderInfoTypeAMD infoType + size_t* pInfoSize + void* pInfo + + + VkResult vkSetDebugUtilsObjectNameEXT + VkDevice device + const VkDebugUtilsObjectNameInfoEXT* pNameInfo + + + VkResult vkSetDebugUtilsObjectTagEXT + VkDevice device + const VkDebugUtilsObjectTagInfoEXT* pTagInfo + + + void vkQueueBeginDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkQueueEndDebugUtilsLabelEXT + VkQueue queue + + + void vkQueueInsertDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdBeginDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdEndDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + + + void vkCmdInsertDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + VkResult vkCreateDebugUtilsMessengerEXT + VkInstance instance + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugUtilsMessengerEXT* pMessenger + + + void vkDestroyDebugUtilsMessengerEXT + VkInstance instance + VkDebugUtilsMessengerEXT messenger + const VkAllocationCallbacks* pAllocator + + + void vkSubmitDebugUtilsMessageEXT + VkInstance instance + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageTypes + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData + + + VkResult vkGetMemoryHostPointerPropertiesEXT + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + const void* pHostPointer + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties + + + void vkCmdWriteBufferMarkerAMD + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkBuffer dstBuffer + VkDeviceSize dstOffset + uint32_t marker + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum + offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in VK_KHR_device_group below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in other extensions, below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + enum offset=0 was mistakenly used for the 1.1 core enum + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES + (value=1000094000). Fortunately, no conflict resulted. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 6691e7e79fd65a08f650622aabbd396a9302647d Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Fri, 9 Mar 2018 22:05:31 +0100 Subject: [PATCH 002/122] Remove vk:: prefix for types --- generator/src/bin/generator.rs | 2 +- generator/src/lib.rs | 25 +++++++++++++++++-------- 2 files changed, 18 insertions(+), 9 deletions(-) diff --git a/generator/src/bin/generator.rs b/generator/src/bin/generator.rs index 0643e6b..7c66db3 100644 --- a/generator/src/bin/generator.rs +++ b/generator/src/bin/generator.rs @@ -5,7 +5,7 @@ use std::collections::HashMap; use std::io::Write; fn main() { - let file = File::open("vk_new.xml").expect("vk"); + let file = File::open("New-Vulkan-XML-Format/vk_new.xml").expect("vknew"); let spec = vkxml::Registry::from_file(file).expect(""); let commands: HashMap = spec.elements diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 11fb44c..d347938 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -57,12 +57,21 @@ impl FieldExt for vkxml::Field { } fn type_ident(&self) -> Ident { - let prefix = &self.basetype[0..2]; - if prefix == "Vk" { - Ident::from(&self.basetype[2..]) - } else { - Ident::from(&self.basetype[..]) - } + let new_name = match self.basetype.as_str() { + "void" => "c_void", + "char" => "c_char", + "float" => "c_float", + "long" => "c_ulong", + _ => { + let prefix = &self.basetype[0..2]; + if prefix == "Vk" { + &self.basetype[2..] + } else { + self.basetype.as_str() + } + } + }; + Ident::from(new_name) } } use std::collections::HashMap; @@ -109,12 +118,12 @@ pub fn gen_load(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Token .map(|field| { let name = field.param_ident(); let ty = field.type_ident(); - quote!{#name: vk::#ty} + quote!{#name: #ty} }) .collect(); let return_ty = cmd.return_type.type_ident(); quote!{ - #fn_name_snake: extern "system" fn(#(#params,)*) -> vk::#return_ty + #fn_name_snake: extern "system" fn(#(#params,)*) -> #return_ty } }) .collect(); From 2c9d4ed71d3f1ec79dd2204fca6d28664183545a Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Fri, 9 Mar 2018 22:43:45 +0100 Subject: [PATCH 003/122] Better version idents --- generator/src/lib.rs | 78 ++++++++++++++++++++++++++++++-------------- 1 file changed, 53 insertions(+), 25 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index d347938..90f6b56 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -11,6 +11,18 @@ use heck::SnakeCase; use syn::Ident; +pub trait FeatureExt { + fn version_string(&self) -> String; +} +impl FeatureExt for vkxml::Feature { + fn version_string(&self) -> String { + let version = format!("{:.10}", self.version); + let first_0 = version.find("0").expect("should have at least one 0"); + // + 1 is correct here because we always have 10 zeroes. + let (version, _) = version.split_at(first_0 + 1); + version.replace(".", "_") + } +} pub trait CommandExt { /// Returns the ident in snake_case and without the 'vk' prefix. fn is_device_command(&self) -> bool; @@ -100,36 +112,52 @@ pub fn gen_load(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Token }) .filter_map(|cmd_ref| commands.get(&cmd_ref.name)) .fold((Vec::new(), Vec::new()), |mut acc, &cmd_ref| { - let basetype = cmd_ref.param[0].basetype.as_str(); - match basetype { - "VkDevice" | "VkCommandBuffer" | "VkQueue" => acc.0.push(cmd_ref), - _ => acc.1.push(cmd_ref), + if cmd_ref.is_device_command() { + acc.0.push(cmd_ref); + } else { + acc.1.push(cmd_ref); }; acc }); let name = Ident::from("Test"); - let function_pointers: Vec<_> = instance_commands - .iter() - .map(|cmd| { - let fn_name_raw = cmd.name.as_str(); - let fn_name_snake = cmd.command_ident(); - let params: Vec<_> = cmd.param - .iter() - .map(|field| { - let name = field.param_ident(); - let ty = field.type_ident(); - quote!{#name: #ty} - }) - .collect(); - let return_ty = cmd.return_type.type_ident(); - quote!{ - #fn_name_snake: extern "system" fn(#(#params,)*) -> #return_ty + fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quote::Tokens { + let function_pointers: Vec<_> = commands + .iter() + .map(|cmd| { + let fn_name_raw = cmd.name.as_str(); + let fn_name_snake = cmd.command_ident(); + let params: Vec<_> = cmd.param + .iter() + .map(|field| { + let name = field.param_ident(); + let ty = field.type_ident(); + quote!{#name: #ty} + }) + .collect(); + let return_ty = cmd.return_type.type_ident(); + quote!{ + #fn_name_snake: extern "system" fn(#(#params,)*) -> #return_ty + } + }) + .collect(); + quote!{ + pub struct #ident { + #(#function_pointers,)* } - }) - .collect(); - quote!{ - pub struct #name { - #(#function_pointers,)* } } + let version = feature.version_string(); + let instance = generate_function_pointers( + Ident::from(format!("InstanceFnV{}", version).as_str()), + &instance_commands, + ); + let device = generate_function_pointers( + Ident::from(format!("DeviceFnV{}", version).as_str()), + &instance_commands, + ); + quote! { + #instance + + #device + } } From b622fd7993cf0eb4eedcf805ecbdd7312afb5cdf Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Fri, 9 Mar 2018 23:43:43 +0100 Subject: [PATCH 004/122] Add clone --- generator/src/lib.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 90f6b56..ba33887 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -140,10 +140,20 @@ pub fn gen_load(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Token } }) .collect(); + let names: Vec<_> = commands.iter().map(|cmd| cmd.command_ident()).collect(); + let names_left = &names; + let names_right = &names; quote!{ pub struct #ident { #(#function_pointers,)* } + impl ::std::clone::Clone for #ident { + pub fn clone(&self) -> Self { + #ident{ + #(#names_left: self.#names_right,)* + } + } + } } } let version = feature.version_string(); From eb70d0e899938077dbc1cae231f208aa767344bd Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Fri, 9 Mar 2018 23:44:10 +0100 Subject: [PATCH 005/122] cargo fmt --- ash/src/entry.rs | 11 +- ash/src/extensions/android_surface.rs | 5 +- ash/src/extensions/debug_marker.rs | 45 +- ash/src/extensions/debug_report.rs | 5 +- ash/src/extensions/display_swapchain.rs | 7 +- ash/src/extensions/ios_surface.rs | 5 +- ash/src/extensions/macos_surface.rs | 5 +- ash/src/extensions/mir_surface.rs | 5 +- ash/src/extensions/surface.rs | 5 +- ash/src/extensions/swapchain.rs | 7 +- ash/src/extensions/wayland_surface.rs | 5 +- ash/src/extensions/win32_surface.rs | 5 +- ash/src/extensions/xcb_surface.rs | 5 +- ash/src/extensions/xlib_surface.rs | 5 +- ash/src/instance.rs | 40 +- ash/src/lib.rs | 6 +- ash/src/version.rs | 13 +- ash/src/vk.rs | 2534 ++++++++++++----------- examples/src/bin/texture.rs | 222 +- 19 files changed, 1455 insertions(+), 1480 deletions(-) diff --git a/ash/src/entry.rs b/ash/src/entry.rs index a663932..ead666b 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -85,10 +85,8 @@ pub trait EntryV1_0 { return Err(InstanceError::VkError(err_code)); } let instance_fp = - ::InstanceFp::load( - &self.static_fn(), - instance, - ).map_err(InstanceError::LoadError)?; + ::InstanceFp::load(&self.static_fn(), instance) + .map_err(InstanceError::LoadError)?; Ok(Instance::from_raw(instance, instance_fp)) } @@ -161,9 +159,8 @@ impl Entry { .unwrap_or(ptr::null_mut()) }).map_err(LoadingError::StaticLoadError)?; - let entry_fn = unsafe { - V::EntryFp::load(&static_fn) - }.map_err(LoadingError::EntryLoadError)?; + let entry_fn = + unsafe { V::EntryFp::load(&static_fn) }.map_err(LoadingError::EntryLoadError)?; Ok(Entry { static_fn, diff --git a/ash/src/extensions/android_surface.rs b/ash/src/extensions/android_surface.rs index e59d03e..ec6869c 100644 --- a/ash/src/extensions/android_surface.rs +++ b/ash/src/extensions/android_surface.rs @@ -18,10 +18,7 @@ impl AndroidSurface { instance: &I, ) -> Result> { let surface_fn = vk::AndroidSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(AndroidSurface { handle: instance.handle(), diff --git a/ash/src/extensions/debug_marker.rs b/ash/src/extensions/debug_marker.rs index 64705e4..874a238 100644 --- a/ash/src/extensions/debug_marker.rs +++ b/ash/src/extensions/debug_marker.rs @@ -3,7 +3,7 @@ use prelude::*; use std::mem; use vk; use std::ffi::CStr; -use version::{InstanceV1_0, DeviceV1_0}; +use version::{DeviceV1_0, InstanceV1_0}; #[derive(Clone)] pub struct DebugMarker { @@ -13,13 +13,10 @@ pub struct DebugMarker { impl DebugMarker { pub fn new( instance: &I, - device: &D + device: &D, ) -> Result> { let debug_marker_fn = vk::DebugMarkerFn::load(|name| unsafe { - mem::transmute(instance.get_device_proc_addr( - device.handle(), - name.as_ptr(), - )) + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) })?; Ok(DebugMarker { debug_marker_fn: debug_marker_fn, @@ -33,46 +30,36 @@ impl DebugMarker { pub unsafe fn debug_marker_set_object_name_ext( &self, device: vk::Device, - name_info: &vk::DebugMarkerObjectNameInfoEXT + name_info: &vk::DebugMarkerObjectNameInfoEXT, ) -> VkResult<()> { - let err_code = self.debug_marker_fn.debug_marker_set_object_name_ext( - device, - name_info - ); + let err_code = self.debug_marker_fn + .debug_marker_set_object_name_ext(device, name_info); match err_code { vk::Result::Success => Ok(()), - _ => Err(err_code) + _ => Err(err_code), } } pub unsafe fn cmd_debug_marker_begin_ext( &self, command_buffer: vk::CommandBuffer, - marker_info: &vk::DebugMarkerMarkerInfoEXT + marker_info: &vk::DebugMarkerMarkerInfoEXT, ) { - self.debug_marker_fn.cmd_debug_marker_begin_ext( - command_buffer, - marker_info - ); + self.debug_marker_fn + .cmd_debug_marker_begin_ext(command_buffer, marker_info); } - pub unsafe fn cmd_debug_marker_end_ext( - &self, - command_buffer: vk::CommandBuffer, - ) { - self.debug_marker_fn.cmd_debug_marker_end_ext( - command_buffer, - ); + pub unsafe fn cmd_debug_marker_end_ext(&self, command_buffer: vk::CommandBuffer) { + self.debug_marker_fn + .cmd_debug_marker_end_ext(command_buffer); } pub unsafe fn cmd_debug_marker_insert_ext( &self, command_buffer: vk::CommandBuffer, - marker_info: &vk::DebugMarkerMarkerInfoEXT + marker_info: &vk::DebugMarkerMarkerInfoEXT, ) { - self.debug_marker_fn.cmd_debug_marker_insert_ext( - command_buffer, - marker_info - ); + self.debug_marker_fn + .cmd_debug_marker_insert_ext(command_buffer, marker_info); } } diff --git a/ash/src/extensions/debug_report.rs b/ash/src/extensions/debug_report.rs index 76a9173..1fd3f8c 100644 --- a/ash/src/extensions/debug_report.rs +++ b/ash/src/extensions/debug_report.rs @@ -18,10 +18,7 @@ impl DebugReport { instance: &I, ) -> Result> { let debug_report_fn = vk::DebugReportFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(DebugReport { handle: instance.handle(), diff --git a/ash/src/extensions/display_swapchain.rs b/ash/src/extensions/display_swapchain.rs index c8b9f96..3fb0a22 100644 --- a/ash/src/extensions/display_swapchain.rs +++ b/ash/src/extensions/display_swapchain.rs @@ -4,7 +4,7 @@ use std::mem; use vk; use std::ffi::CStr; use RawPtr; -use version::{InstanceV1_0, DeviceV1_0}; +use version::{DeviceV1_0, InstanceV1_0}; #[derive(Clone)] pub struct DisplaySwapchain { @@ -18,10 +18,7 @@ impl DisplaySwapchain { device: &D, ) -> Result> { let swapchain_fn = vk::DisplaySwapchainFn::load(|name| unsafe { - mem::transmute(instance.get_device_proc_addr( - device.handle(), - name.as_ptr(), - )) + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) })?; Ok(DisplaySwapchain { handle: device.handle(), diff --git a/ash/src/extensions/ios_surface.rs b/ash/src/extensions/ios_surface.rs index 2e4bd45..1c477b0 100644 --- a/ash/src/extensions/ios_surface.rs +++ b/ash/src/extensions/ios_surface.rs @@ -18,10 +18,7 @@ impl IOSSurface { instance: &I, ) -> Result> { let surface_fn = vk::IOSSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(IOSSurface { handle: instance.handle(), diff --git a/ash/src/extensions/macos_surface.rs b/ash/src/extensions/macos_surface.rs index 92a1bbc..ed8abba 100644 --- a/ash/src/extensions/macos_surface.rs +++ b/ash/src/extensions/macos_surface.rs @@ -18,10 +18,7 @@ impl MacOSSurface { instance: &I, ) -> Result> { let surface_fn = vk::MacOSSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(MacOSSurface { handle: instance.handle(), diff --git a/ash/src/extensions/mir_surface.rs b/ash/src/extensions/mir_surface.rs index 79be38f..679dd43 100644 --- a/ash/src/extensions/mir_surface.rs +++ b/ash/src/extensions/mir_surface.rs @@ -18,10 +18,7 @@ impl MirSurface { instance: &I, ) -> Result> { let surface_fn = vk::MirSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(MirSurface { handle: instance.handle(), diff --git a/ash/src/extensions/surface.rs b/ash/src/extensions/surface.rs index 06851af..1c8f5c6 100644 --- a/ash/src/extensions/surface.rs +++ b/ash/src/extensions/surface.rs @@ -19,10 +19,7 @@ impl Surface { instance: &I, ) -> Result> { let surface_fn = vk::SurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(Surface { handle: instance.handle(), diff --git a/ash/src/extensions/swapchain.rs b/ash/src/extensions/swapchain.rs index 3def593..988c324 100644 --- a/ash/src/extensions/swapchain.rs +++ b/ash/src/extensions/swapchain.rs @@ -5,7 +5,7 @@ use std::mem; use vk; use std::ffi::CStr; use RawPtr; -use version::{InstanceV1_0, DeviceV1_0}; +use version::{DeviceV1_0, InstanceV1_0}; #[derive(Clone)] pub struct Swapchain { @@ -19,10 +19,7 @@ impl Swapchain { device: &D, ) -> Result> { let swapchain_fn = vk::SwapchainFn::load(|name| unsafe { - mem::transmute(instance.get_device_proc_addr( - device.handle(), - name.as_ptr(), - )) + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) })?; Ok(Swapchain { handle: device.handle(), diff --git a/ash/src/extensions/wayland_surface.rs b/ash/src/extensions/wayland_surface.rs index 09625cf..855b7df 100644 --- a/ash/src/extensions/wayland_surface.rs +++ b/ash/src/extensions/wayland_surface.rs @@ -18,10 +18,7 @@ impl WaylandSurface { instance: &I, ) -> Result> { let surface_fn = vk::WaylandSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(WaylandSurface { handle: instance.handle(), diff --git a/ash/src/extensions/win32_surface.rs b/ash/src/extensions/win32_surface.rs index 403271c..c2439f9 100644 --- a/ash/src/extensions/win32_surface.rs +++ b/ash/src/extensions/win32_surface.rs @@ -18,10 +18,7 @@ impl Win32Surface { instance: &I, ) -> Result> { let surface_fn = vk::Win32SurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(Win32Surface { handle: instance.handle(), diff --git a/ash/src/extensions/xcb_surface.rs b/ash/src/extensions/xcb_surface.rs index 9cdef8b..04fb2a6 100644 --- a/ash/src/extensions/xcb_surface.rs +++ b/ash/src/extensions/xcb_surface.rs @@ -18,10 +18,7 @@ impl XcbSurface { instance: &I, ) -> Result> { let surface_fn = vk::XcbSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(XcbSurface { handle: instance.handle(), diff --git a/ash/src/extensions/xlib_surface.rs b/ash/src/extensions/xlib_surface.rs index 5dd5f52..76bcb9c 100644 --- a/ash/src/extensions/xlib_surface.rs +++ b/ash/src/extensions/xlib_surface.rs @@ -18,10 +18,7 @@ impl XlibSurface { instance: &I, ) -> Result> { let surface_fn = vk::XlibSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr( - instance.handle(), - name.as_ptr(), - )) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(XlibSurface { handle: instance.handle(), diff --git a/ash/src/instance.rs b/ash/src/instance.rs index d0ce99a..887e26d 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -85,11 +85,10 @@ pub trait InstanceV1_0 { if err_code != vk::Result::Success { return Err(DeviceError::VkError(err_code)); } - let device_fn = - <::Fp as FunctionPointers>::DeviceFp::load( - self.fp_v1_0(), - device, - ).map_err(|err| DeviceError::LoadError(err))?; + let device_fn = <::Fp as FunctionPointers>::DeviceFp::load( + self.fp_v1_0(), + device, + ).map_err(|err| DeviceError::LoadError(err))?; Ok(Device::from_raw(device, device_fn)) } @@ -102,10 +101,8 @@ pub trait InstanceV1_0 { } unsafe fn destroy_instance(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) { - self.fp_v1_0().destroy_instance( - self.handle(), - allocation_callbacks.as_raw_ptr(), - ); + self.fp_v1_0() + .destroy_instance(self.handle(), allocation_callbacks.as_raw_ptr()); } fn get_physical_device_format_properties( @@ -158,10 +155,8 @@ pub trait InstanceV1_0 { ) -> vk::PhysicalDeviceMemoryProperties { unsafe { let mut memory_prop = mem::uninitialized(); - self.fp_v1_0().get_physical_device_memory_properties( - physical_device, - &mut memory_prop, - ); + self.fp_v1_0() + .get_physical_device_memory_properties(physical_device, &mut memory_prop); memory_prop } } @@ -172,10 +167,8 @@ pub trait InstanceV1_0 { ) -> vk::PhysicalDeviceProperties { unsafe { let mut prop = mem::uninitialized(); - self.fp_v1_0().get_physical_device_properties( - physical_device, - &mut prop, - ); + self.fp_v1_0() + .get_physical_device_properties(physical_device, &mut prop); prop } } @@ -208,10 +201,8 @@ pub trait InstanceV1_0 { ) -> vk::PhysicalDeviceFeatures { unsafe { let mut prop = mem::uninitialized(); - self.fp_v1_0().get_physical_device_features( - physical_device, - &mut prop, - ); + self.fp_v1_0() + .get_physical_device_features(physical_device, &mut prop); prop } } @@ -219,11 +210,8 @@ pub trait InstanceV1_0 { fn enumerate_physical_devices(&self) -> VkResult> { unsafe { let mut num = mem::uninitialized(); - self.fp_v1_0().enumerate_physical_devices( - self.handle(), - &mut num, - ptr::null_mut(), - ); + self.fp_v1_0() + .enumerate_physical_devices(self.handle(), &mut num, ptr::null_mut()); let mut physical_devices = Vec::::with_capacity(num as usize); let err_code = self.fp_v1_0().enumerate_physical_devices( self.handle(), diff --git a/ash/src/lib.rs b/ash/src/lib.rs index ba433cb..a4691bb 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -1,8 +1,8 @@ -extern crate libc; -extern crate shared_library; #[macro_use] extern crate lazy_static; -pub use instance::{Instance, DeviceError}; +extern crate libc; +extern crate shared_library; +pub use instance::{DeviceError, Instance}; pub use device::Device; pub use entry::{Entry, InstanceError, LoadingError}; diff --git a/ash/src/version.rs b/ash/src/version.rs index 72aa85f..07af411 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -36,10 +36,7 @@ impl EntryLoader for EntryFpV1_0 { } unsafe fn load(static_fn: &vk::StaticFn) -> Result> { let entry_fn = vk::EntryFnV1_0::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr( - vk::Instance::null(), - name.as_ptr(), - )) + mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) })?; Ok(EntryFpV1_0 { entry_fn: entry_fn }) } @@ -73,7 +70,9 @@ impl DeviceLoader for DeviceFpV1_0 { let device_fn = vk::DeviceFnV1_0::load(|name| { mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) })?; - Ok(DeviceFpV1_0 { device_fn: device_fn }) + Ok(DeviceFpV1_0 { + device_fn: device_fn, + }) } } @@ -88,7 +87,9 @@ impl InstanceLoader for InstanceFpV1_0 { let instance_fn = vk::InstanceFnV1_0::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) })?; - Ok(InstanceFpV1_0 { instance_fn: instance_fn }) + Ok(InstanceFpV1_0 { + instance_fn: instance_fn, + }) } } diff --git a/ash/src/vk.rs b/ash/src/vk.rs index bdd8aa5..5291504 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -200,7 +200,7 @@ macro_rules! vk_version_patch { } pub mod types { -#![allow(non_camel_case_types, dead_code)] + #![allow(non_camel_case_types, dead_code)] use std::ops::*; use std::fmt; use std::ffi::CStr; @@ -1301,10 +1301,9 @@ pub mod types { impl fmt::Debug for LayerProperties { fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { fmt.debug_struct("LayerProperties") - .field( - "layer_name", - &unsafe { CStr::from_ptr(&self.layer_name[0]) }, - ) + .field("layer_name", &unsafe { + CStr::from_ptr(&self.layer_name[0]) + }) .field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { @@ -2542,7 +2541,7 @@ pub mod types { pub s_type: StructureType, pub p_next: *const c_void, pub p_marker_name: *const c_char, - pub color: [f32; 4] + pub color: [f32; 4], } #[repr(C)] @@ -2600,12 +2599,12 @@ pub mod types { #[derive(Copy, Clone)] pub union ClearValue { pub depth: ClearDepthStencilValue, - pub color: ClearColorValue + pub color: ClearColorValue, } #[repr(C)] #[derive(Copy, Clone)] - pub union ClearColorValue{ + pub union ClearColorValue { pub float32: [f32; 4], pub int32: [i32; 4], pub uint32: [u32; 4], @@ -3434,13 +3433,19 @@ pub mod types { pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: FormatFeatureFlags = FormatFeatureFlags { flags: 0b100000000 }; pub const FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b1000000000 }; - pub const FORMAT_FEATURE_BLIT_SRC_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b10000000000 }; - pub const FORMAT_FEATURE_BLIT_DST_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b100000000000 }; + FormatFeatureFlags { + flags: 0b1000000000, + }; + pub const FORMAT_FEATURE_BLIT_SRC_BIT: FormatFeatureFlags = FormatFeatureFlags { + flags: 0b10000000000, + }; + pub const FORMAT_FEATURE_BLIT_DST_BIT: FormatFeatureFlags = FormatFeatureFlags { + flags: 0b100000000000, + }; pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b1000000000000 }; + FormatFeatureFlags { + flags: 0b1000000000000, + }; vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); pub const IMAGE_USAGE_TRANSFER_SRC_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b1 }; @@ -3515,22 +3520,30 @@ pub mod types { PipelineStageFlags { flags: 0b10000000 }; pub const PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: PipelineStageFlags = PipelineStageFlags { flags: 0b100000000 }; - pub const PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1000000000 }; - pub const PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10000000000 }; - pub const PIPELINE_STAGE_COMPUTE_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b100000000000 }; - pub const PIPELINE_STAGE_TRANSFER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1000000000000 }; - pub const PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10000000000000 }; - pub const PIPELINE_STAGE_HOST_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b100000000000000 }; - pub const PIPELINE_STAGE_ALL_GRAPHICS_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1000000000000000 }; - pub const PIPELINE_STAGE_ALL_COMMANDS_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10000000000000000 }; + pub const PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b1000000000, + }; + pub const PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b10000000000, + }; + pub const PIPELINE_STAGE_COMPUTE_SHADER_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b100000000000, + }; + pub const PIPELINE_STAGE_TRANSFER_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b1000000000000, + }; + pub const PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b10000000000000, + }; + pub const PIPELINE_STAGE_HOST_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b100000000000000, + }; + pub const PIPELINE_STAGE_ALL_GRAPHICS_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b1000000000000000, + }; + pub const PIPELINE_STAGE_ALL_COMMANDS_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b10000000000000000, + }; vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); pub const IMAGE_ASPECT_COLOR_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b1 }; @@ -3556,18 +3569,30 @@ pub mod types { pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b1 }; - pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b10}; - pub const QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b100}; - pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b1000}; - pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b10000}; + pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b10 }; + pub const QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b100 }; + pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: + QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b1000 }; + pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b10000 }; pub const QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b100000 }; pub const QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b1000000 }; - pub const QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b10000000}; - pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b100000000}; - pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b1000000000}; - pub const QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = QueryPipelineStatisticFlags {flags: 0b10000000000}; + pub const QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: + QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b10000000 }; + pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: + QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b100000000 }; + pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: + QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { + flags: 0b1000000000, + }; + pub const QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { + flags: 0b10000000000, + }; vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); pub const QUERY_RESULT_64_BIT: QueryResultFlags = QueryResultFlags { flags: 0b1 }; @@ -3620,8 +3645,9 @@ pub mod types { pub const SHADER_STAGE_FRAGMENT_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b10000 }; pub const SHADER_STAGE_COMPUTE_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b100000 }; pub const SHADER_STAGE_ALL_GRAPHICS: ShaderStageFlags = ShaderStageFlags { flags: 0b11111 }; - pub const SHADER_STAGE_ALL: ShaderStageFlags = - ShaderStageFlags { flags: 0b1111111111111111111111111111111 }; + pub const SHADER_STAGE_ALL: ShaderStageFlags = ShaderStageFlags { + flags: 0b1111111111111111111111111111111, + }; vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); pub const CULL_MODE_NONE: CullModeFlags = CullModeFlags { flags: 0b0 }; @@ -3653,16 +3679,30 @@ pub mod types { pub const ACCESS_SHADER_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b1000000 }; pub const ACCESS_COLOR_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000000 }; pub const ACCESS_COLOR_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b100000000 }; - pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: AccessFlags = - AccessFlags { flags: 0b1000000000 }; - pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: AccessFlags = - AccessFlags { flags: 0b10000000000 }; - pub const ACCESS_TRANSFER_READ_BIT: AccessFlags = AccessFlags { flags: 0b100000000000 }; - pub const ACCESS_TRANSFER_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b1000000000000 }; - pub const ACCESS_HOST_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000000000000 }; - pub const ACCESS_HOST_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b100000000000000 }; - pub const ACCESS_MEMORY_READ_BIT: AccessFlags = AccessFlags { flags: 0b1000000000000000 }; - pub const ACCESS_MEMORY_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b10000000000000000 }; + pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { + flags: 0b1000000000, + }; + pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b10000000000, + }; + pub const ACCESS_TRANSFER_READ_BIT: AccessFlags = AccessFlags { + flags: 0b100000000000, + }; + pub const ACCESS_TRANSFER_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b1000000000000, + }; + pub const ACCESS_HOST_READ_BIT: AccessFlags = AccessFlags { + flags: 0b10000000000000, + }; + pub const ACCESS_HOST_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b100000000000000, + }; + pub const ACCESS_MEMORY_READ_BIT: AccessFlags = AccessFlags { + flags: 0b1000000000000000, + }; + pub const ACCESS_MEMORY_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b10000000000000000, + }; vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); pub const DEPENDENCY_BY_REGION_BIT: DependencyFlags = DependencyFlags { flags: 0b1 }; @@ -3750,45 +3790,43 @@ pub mod types { DebugReportFlagsEXT { flags: 0b10000 }; vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); + pub type PFN_vkAllocationFunction = + unsafe extern "system" fn(*mut c_void, size_t, size_t, SystemAllocationScope) + -> *mut c_void; - pub type PFN_vkAllocationFunction = unsafe extern "system" fn(*mut c_void, - size_t, - size_t, - SystemAllocationScope) - -> *mut c_void; - - pub type PFN_vkReallocationFunction = unsafe extern "system" fn(*mut c_void, - *mut c_void, - size_t, - size_t, - SystemAllocationScope) - -> *mut c_void; + pub type PFN_vkReallocationFunction = + unsafe extern "system" fn(*mut c_void, *mut c_void, size_t, size_t, SystemAllocationScope) + -> *mut c_void; pub type PFN_vkFreeFunction = unsafe extern "system" fn(*mut c_void, *mut c_void); pub type PFN_vkInternalAllocationNotification = - unsafe extern "system" fn(*mut c_void, - size_t, - InternalAllocationType, - SystemAllocationScope); + unsafe extern "system" fn( + *mut c_void, + size_t, + InternalAllocationType, + SystemAllocationScope, + ); - pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn(*mut c_void, - size_t, - InternalAllocationType, - SystemAllocationScope); + pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn( + *mut c_void, + size_t, + InternalAllocationType, + SystemAllocationScope, + ); pub type PFN_vkVoidFunction = unsafe extern "system" fn(); - pub type PFN_vkDebugReportCallbackEXT = unsafe extern "system" fn(DebugReportFlagsEXT, - DebugReportObjectTypeEXT, - uint64_t, - size_t, - int32_t, - *const c_char, - *const c_char, - *mut c_void) - -> Bool32; - + pub type PFN_vkDebugReportCallbackEXT = unsafe extern "system" fn( + DebugReportFlagsEXT, + DebugReportObjectTypeEXT, + uint64_t, + size_t, + int32_t, + *const c_char, + *const c_char, + *mut c_void, + ) -> Bool32; } // FIX: Need better error handling for extensions @@ -3853,1237 +3891,1237 @@ macro_rules! vk_functions { } pub mod cmds { -#![allow(dead_code)] + #![allow(dead_code)] use super::*; vk_functions!{ - StaticFn, - "vkGetInstanceProcAddr", get_instance_proc_addr( - instance: Instance, - p_name: *const c_char, - ) -> PFN_vkVoidFunction; -} + StaticFn, + "vkGetInstanceProcAddr", get_instance_proc_addr( + instance: Instance, + p_name: *const c_char, + ) -> PFN_vkVoidFunction; + } vk_functions!{ - EntryFnV1_0, - "vkCreateInstance", create_instance( - p_create_info: *const InstanceCreateInfo, - p_allocator: *const AllocationCallbacks, - p_instance: *mut Instance, - ) -> Result; + EntryFnV1_0, + "vkCreateInstance", create_instance( + p_create_info: *const InstanceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_instance: *mut Instance, + ) -> Result; - "vkEnumerateInstanceExtensionProperties", enumerate_instance_extension_properties( - p_layer_name: *const c_char, - p_property_count: *mut uint32_t, - p_properties: *mut ExtensionProperties, - ) -> Result; + "vkEnumerateInstanceExtensionProperties", enumerate_instance_extension_properties( + p_layer_name: *const c_char, + p_property_count: *mut uint32_t, + p_properties: *mut ExtensionProperties, + ) -> Result; - "vkEnumerateInstanceLayerProperties", enumerate_instance_layer_properties( - p_property_count: *mut uint32_t, - p_properties: *mut LayerProperties, - ) -> Result; -} + "vkEnumerateInstanceLayerProperties", enumerate_instance_layer_properties( + p_property_count: *mut uint32_t, + p_properties: *mut LayerProperties, + ) -> Result; + } vk_functions!{ - InstanceFnV1_0, + InstanceFnV1_0, - "vkDestroyInstance", destroy_instance( - instance: Instance, - p_allocator: *const AllocationCallbacks, - ) -> (); + "vkDestroyInstance", destroy_instance( + instance: Instance, + p_allocator: *const AllocationCallbacks, + ) -> (); - "vkEnumeratePhysicalDevices", enumerate_physical_devices( - instance: Instance, - p_physical_device_count: *mut uint32_t, - p_physical_devices: *mut PhysicalDevice, - ) -> Result; + "vkEnumeratePhysicalDevices", enumerate_physical_devices( + instance: Instance, + p_physical_device_count: *mut uint32_t, + p_physical_devices: *mut PhysicalDevice, + ) -> Result; - "vkGetPhysicalDeviceFeatures", get_physical_device_features( - physical_device: PhysicalDevice, - p_features: *mut PhysicalDeviceFeatures, - ) -> (); + "vkGetPhysicalDeviceFeatures", get_physical_device_features( + physical_device: PhysicalDevice, + p_features: *mut PhysicalDeviceFeatures, + ) -> (); - "vkGetPhysicalDeviceFormatProperties", get_physical_device_format_properties( - physical_device: PhysicalDevice, - format: Format, - p_format_properties: *mut FormatProperties, - ) -> (); + "vkGetPhysicalDeviceFormatProperties", get_physical_device_format_properties( + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *mut FormatProperties, + ) -> (); - "vkGetPhysicalDeviceImageFormatProperties", get_physical_device_image_format_properties( - physical_device: PhysicalDevice, - format: Format, - typ: ImageType, - tiling: ImageTiling, - usage: ImageUsageFlags, - flags: ImageCreateFlags, - p_image_format_properties: *mut ImageFormatProperties, - ) -> Result; + "vkGetPhysicalDeviceImageFormatProperties", get_physical_device_image_format_properties( + physical_device: PhysicalDevice, + format: Format, + typ: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + p_image_format_properties: *mut ImageFormatProperties, + ) -> Result; - "vkGetPhysicalDeviceProperties", get_physical_device_properties( - physical_device: PhysicalDevice, - p_properties: *mut PhysicalDeviceProperties, - ) -> (); + "vkGetPhysicalDeviceProperties", get_physical_device_properties( + physical_device: PhysicalDevice, + p_properties: *mut PhysicalDeviceProperties, + ) -> (); - "vkGetPhysicalDeviceQueueFamilyProperties", get_physical_device_queue_family_properties( - physical_device: PhysicalDevice, - p_queue_family_property_count: *mut uint32_t, - p_queue_family_properties: *mut QueueFamilyProperties, - ) -> (); + "vkGetPhysicalDeviceQueueFamilyProperties", get_physical_device_queue_family_properties( + physical_device: PhysicalDevice, + p_queue_family_property_count: *mut uint32_t, + p_queue_family_properties: *mut QueueFamilyProperties, + ) -> (); - "vkGetPhysicalDeviceMemoryProperties", get_physical_device_memory_properties( - physical_device: PhysicalDevice, - p_memory_properties: *mut PhysicalDeviceMemoryProperties, - ) -> (); + "vkGetPhysicalDeviceMemoryProperties", get_physical_device_memory_properties( + physical_device: PhysicalDevice, + p_memory_properties: *mut PhysicalDeviceMemoryProperties, + ) -> (); - "vkGetDeviceProcAddr", get_device_proc_addr( - device: Device, - p_name: *const c_char, - ) -> PFN_vkVoidFunction; + "vkGetDeviceProcAddr", get_device_proc_addr( + device: Device, + p_name: *const c_char, + ) -> PFN_vkVoidFunction; - "vkCreateDevice", create_device( - physical_device: PhysicalDevice, - p_create_info: *const DeviceCreateInfo, - p_allocator: *const AllocationCallbacks, - p_device: *mut Device, - ) -> Result; + "vkCreateDevice", create_device( + physical_device: PhysicalDevice, + p_create_info: *const DeviceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_device: *mut Device, + ) -> Result; - "vkEnumerateDeviceExtensionProperties", enumerate_device_extension_properties( - physical_device: PhysicalDevice, - p_layer_name: *const c_char, - p_property_count: *mut uint32_t, - p_properties: *mut ExtensionProperties, - ) -> Result; + "vkEnumerateDeviceExtensionProperties", enumerate_device_extension_properties( + physical_device: PhysicalDevice, + p_layer_name: *const c_char, + p_property_count: *mut uint32_t, + p_properties: *mut ExtensionProperties, + ) -> Result; - "vkEnumerateDeviceLayerProperties", enumerate_device_layer_properties( - physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, - p_properties: *mut LayerProperties, - ) -> Result; + "vkEnumerateDeviceLayerProperties", enumerate_device_layer_properties( + physical_device: PhysicalDevice, + p_property_count: *mut uint32_t, + p_properties: *mut LayerProperties, + ) -> Result; - "vkGetPhysicalDeviceSparseImageFormatProperties", get_physical_device_sparse_image_format_properties( - physical_device: PhysicalDevice, - format: Format, - typ: ImageType, - samples: SampleCountFlags, - usage: ImageUsageFlags, - tiling: ImageTiling, - p_property_count: *mut uint32_t, - p_properties: *mut SparseImageFormatProperties, - ) -> (); -} + "vkGetPhysicalDeviceSparseImageFormatProperties", get_physical_device_sparse_image_format_properties( + physical_device: PhysicalDevice, + format: Format, + typ: ImageType, + samples: SampleCountFlags, + usage: ImageUsageFlags, + tiling: ImageTiling, + p_property_count: *mut uint32_t, + p_properties: *mut SparseImageFormatProperties, + ) -> (); + } vk_functions!{ - DeviceFnV1_0, - "vkDestroyDevice", destroy_device( - device: Device, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetDeviceQueue", get_device_queue( - device: Device, - queue_family_index: uint32_t, - queue_index: uint32_t, - p_queue: *mut Queue, - ) -> (); - - "vkQueueSubmit", queue_submit( - queue: Queue, - submit_count: uint32_t, - p_submits: *const SubmitInfo, - fence: Fence, - ) -> Result; - - "vkQueueWaitIdle", queue_wait_idle( - queue: Queue, - ) -> Result; - - "vkDeviceWaitIdle", device_wait_idle( - device: Device, - ) -> Result; - - "vkAllocateMemory", allocate_memory( - device: Device, - p_allocate_info: *const MemoryAllocateInfo, - p_allocator: *const AllocationCallbacks, - p_memory: *mut DeviceMemory, - ) -> Result; - - "vkFreeMemory", free_memory( - device: Device, - memory: DeviceMemory, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkMapMemory", map_memory( - device: Device, - memory: DeviceMemory, - offset: DeviceSize, - size: DeviceSize, - flags: MemoryMapFlags, - pp_data: *mut *mut c_void, - ) -> Result; - - "vkUnmapMemory", unmap_memory( - device: Device, - memory: DeviceMemory, - ) -> (); - - "vkFlushMappedMemoryRanges", flush_mapped_memory_ranges( - device: Device, - memory_range_count: uint32_t, - p_memory_ranges: *const MappedMemoryRange, - ) -> Result; - - "vkInvalidateMappedMemoryRanges", invalidate_mapped_memory_ranges( - device: Device, - memory_range_count: uint32_t, - p_memory_ranges: *const MappedMemoryRange, - ) -> Result; - - "vkGetDeviceMemoryCommitment", get_device_memory_commitment( - device: Device, - memory: DeviceMemory, - p_committed_memory_in_bytes: *mut DeviceSize, - ) -> (); - - "vkBindBufferMemory", bind_buffer_memory( - device: Device, - buffer: Buffer, - memory: DeviceMemory, - memory_offset: DeviceSize, - ) -> Result; - - "vkBindImageMemory", bind_image_memory( - device: Device, - image: Image, - memory: DeviceMemory, - memory_offset: DeviceSize, - ) -> Result; - - "vkGetBufferMemoryRequirements", get_buffer_memory_requirements( - device: Device, - buffer: Buffer, - p_memory_requirements: *mut MemoryRequirements, - ) -> (); - - "vkGetImageMemoryRequirements", get_image_memory_requirements( - device: Device, - image: Image, - p_memory_requirements: *mut MemoryRequirements, - ) -> (); - - "vkGetImageSparseMemoryRequirements", get_image_sparse_memory_requirements( - device: Device, - image: Image, - p_sparse_memory_requirement_count: *mut uint32_t, - p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, - ) -> (); - - "vkQueueBindSparse", queue_bind_sparse( - queue: Queue, - bind_info_count: uint32_t, - p_bind_info: *const BindSparseInfo, - fence: Fence, - ) -> Result; - - "vkCreateFence", create_fence( - device: Device, - p_create_info: *const FenceCreateInfo, - p_allocator: *const AllocationCallbacks, - p_fence: *mut Fence, - ) -> Result; - - "vkDestroyFence", destroy_fence( - device: Device, - fence: Fence, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkResetFences", reset_fences( - device: Device, - fence_count: uint32_t, - p_fences: *const Fence, - ) -> Result; - - "vkGetFenceStatus", get_fence_status( - device: Device, - fence: Fence, - ) -> Result; - - "vkWaitForFences", wait_for_fences( - device: Device, - fence_count: uint32_t, - p_fences: *const Fence, - wait_all: Bool32, - timeout: uint64_t, - ) -> Result; - - "vkCreateSemaphore", create_semaphore( - device: Device, - p_create_info: *const SemaphoreCreateInfo, - p_allocator: *const AllocationCallbacks, - p_semaphore: *mut Semaphore, - ) -> Result; - - "vkDestroySemaphore", destroy_semaphore( - device: Device, - semaphore: Semaphore, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateEvent", create_event( - device: Device, - p_create_info: *const EventCreateInfo, - p_allocator: *const AllocationCallbacks, - p_event: *mut Event, - ) -> Result; - - "vkDestroyEvent", destroy_event( - device: Device, - event: Event, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetEventStatus", get_event_status( - device: Device, - event: Event, - ) -> Result; - - "vkSetEvent", set_event( - device: Device, - event: Event, - ) -> Result; - - "vkResetEvent", reset_event( - device: Device, - event: Event, - ) -> Result; - - "vkCreateQueryPool", create_query_pool( - device: Device, - p_create_info: *const QueryPoolCreateInfo, - p_allocator: *const AllocationCallbacks, - p_query_pool: *mut QueryPool, - ) -> Result; - - "vkDestroyQueryPool", destroy_query_pool( - device: Device, - query_pool: QueryPool, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetQueryPoolResults", get_query_pool_results( - device: Device, - query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - data_size: size_t, - p_data: *mut c_void, - stride: DeviceSize, - flags: QueryResultFlags, - ) -> Result; - - "vkCreateBuffer", create_buffer( - device: Device, - p_create_info: *const BufferCreateInfo, - p_allocator: *const AllocationCallbacks, - p_buffer: *mut Buffer, - ) -> Result; - - "vkDestroyBuffer", destroy_buffer( - device: Device, - buffer: Buffer, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateBufferView", create_buffer_view( - device: Device, - p_create_info: *const BufferViewCreateInfo, - p_allocator: *const AllocationCallbacks, - p_view: *mut BufferView, - ) -> Result; - - "vkDestroyBufferView", destroy_buffer_view( - device: Device, - buffer_view: BufferView, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateImage", create_image( - device: Device, - p_create_info: *const ImageCreateInfo, - p_allocator: *const AllocationCallbacks, - p_image: *mut Image, - ) -> Result; - - "vkDestroyImage", destroy_image( - device: Device, - image: Image, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetImageSubresourceLayout", get_image_subresource_layout( - device: Device, - image: Image, - p_subresource: *const ImageSubresource, - p_layout: *mut SubresourceLayout, - ) -> (); - - "vkCreateImageView", create_image_view( - device: Device, - p_create_info: *const ImageViewCreateInfo, - p_allocator: *const AllocationCallbacks, - p_view: *mut ImageView, - ) -> Result; - - "vkDestroyImageView", destroy_image_view( - device: Device, - image_view: ImageView, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateShaderModule", create_shader_module( - device: Device, - p_create_info: *const ShaderModuleCreateInfo, - p_allocator: *const AllocationCallbacks, - p_shader_module: *mut ShaderModule, - ) -> Result; - - "vkDestroyShaderModule", destroy_shader_module( - device: Device, - shader_module: ShaderModule, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreatePipelineCache", create_pipeline_cache( - device: Device, - p_create_info: *const PipelineCacheCreateInfo, - p_allocator: *const AllocationCallbacks, - p_pipeline_cache: *mut PipelineCache, - ) -> Result; - - "vkDestroyPipelineCache", destroy_pipeline_cache( - device: Device, - pipeline_cache: PipelineCache, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetPipelineCacheData", get_pipeline_cache_data( - device: Device, - pipeline_cache: PipelineCache, - p_data_size: *mut size_t, - p_data: *mut c_void, - ) -> Result; - - "vkMergePipelineCaches", merge_pipeline_caches( - device: Device, - dst_cache: PipelineCache, - src_cache_count: uint32_t, - p_src_caches: *const PipelineCache, - ) -> Result; - - "vkCreateGraphicsPipelines", create_graphics_pipelines( - device: Device, - pipeline_cache: PipelineCache, - create_info_count: uint32_t, - p_create_infos: *const GraphicsPipelineCreateInfo, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, - ) -> Result; - - "vkCreateComputePipelines", create_compute_pipelines( - device: Device, - pipeline_cache: PipelineCache, - create_info_count: uint32_t, - p_create_infos: *const ComputePipelineCreateInfo, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, - ) -> Result; - - "vkDestroyPipeline", destroy_pipeline( - device: Device, - pipeline: Pipeline, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreatePipelineLayout", create_pipeline_layout( - device: Device, - p_create_info: *const PipelineLayoutCreateInfo, - p_allocator: *const AllocationCallbacks, - p_pipeline_layout: *mut PipelineLayout, - ) -> Result; - - "vkDestroyPipelineLayout", destroy_pipeline_layout( - device: Device, - pipeline_layout: PipelineLayout, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateSampler", create_sampler( - device: Device, - p_create_info: *const SamplerCreateInfo, - p_allocator: *const AllocationCallbacks, - p_sampler: *mut Sampler, - ) -> Result; - - "vkDestroySampler", destroy_sampler( - device: Device, - sampler: Sampler, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateDescriptorSetLayout", create_descriptor_set_layout( - device: Device, - p_create_info: *const DescriptorSetLayoutCreateInfo, - p_allocator: *const AllocationCallbacks, - p_set_layout: *mut DescriptorSetLayout, - ) -> Result; - - "vkDestroyDescriptorSetLayout", destroy_descriptor_set_layout( - device: Device, - descriptor_set_layout: DescriptorSetLayout, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateDescriptorPool", create_descriptor_pool( - device: Device, - p_create_info: *const DescriptorPoolCreateInfo, - p_allocator: *const AllocationCallbacks, - p_descriptor_pool: *mut DescriptorPool, - ) -> Result; - - "vkDestroyDescriptorPool", destroy_descriptor_pool( - device: Device, - descriptor_pool: DescriptorPool, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkResetDescriptorPool", reset_descriptor_pool( - device: Device, - descriptor_pool: DescriptorPool, - flags: DescriptorPoolResetFlags, - ) -> Result; - - "vkAllocateDescriptorSets", allocate_descriptor_sets( - device: Device, - p_allocate_info: *const DescriptorSetAllocateInfo, - p_descriptor_sets: *mut DescriptorSet, - ) -> Result; - - "vkFreeDescriptorSets", free_descriptor_sets( - device: Device, - descriptor_pool: DescriptorPool, - descriptor_set_count: uint32_t, - p_descriptor_sets: *const DescriptorSet, - ) -> Result; - - "vkUpdateDescriptorSets", update_descriptor_sets( - device: Device, - descriptor_write_count: uint32_t, - p_descriptor_writes: *const WriteDescriptorSet, - descriptor_copy_count: uint32_t, - p_descriptor_copies: *const CopyDescriptorSet, - ) -> (); - - "vkCreateFramebuffer", create_framebuffer( - device: Device, - p_create_info: *const FramebufferCreateInfo, - p_allocator: *const AllocationCallbacks, - p_framebuffer: *mut Framebuffer, - ) -> Result; - - "vkDestroyFramebuffer", destroy_framebuffer( - device: Device, - framebuffer: Framebuffer, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateRenderPass", create_render_pass( - device: Device, - p_create_info: *const RenderPassCreateInfo, - p_allocator: *const AllocationCallbacks, - p_render_pass: *mut RenderPass, - ) -> Result; - - "vkDestroyRenderPass", destroy_render_pass( - device: Device, - render_pass: RenderPass, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetRenderAreaGranularity", get_render_area_granularity( - device: Device, - render_pass: RenderPass, - p_granularity: *mut Extent2D, - ) -> (); - - "vkCreateCommandPool", create_command_pool( - device: Device, - p_create_info: *const CommandPoolCreateInfo, - p_allocator: *const AllocationCallbacks, - p_command_pool: *mut CommandPool, - ) -> Result; - - "vkDestroyCommandPool", destroy_command_pool( - device: Device, - command_pool: CommandPool, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkResetCommandPool", reset_command_pool( - device: Device, - command_pool: CommandPool, - flags: CommandPoolResetFlags, - ) -> Result; - - "vkAllocateCommandBuffers", allocate_command_buffers( - device: Device, - p_allocate_info: *const CommandBufferAllocateInfo, - p_command_buffers: *mut CommandBuffer, - ) -> Result; - - "vkFreeCommandBuffers", free_command_buffers( - device: Device, - command_pool: CommandPool, - command_buffer_count: uint32_t, - p_command_buffers: *const CommandBuffer, - ) -> (); - - "vkBeginCommandBuffer", begin_command_buffer( - command_buffer: CommandBuffer, - p_begin_info: *const CommandBufferBeginInfo, - ) -> Result; - - "vkEndCommandBuffer", end_command_buffer( - command_buffer: CommandBuffer, - ) -> Result; - - "vkResetCommandBuffer", reset_command_buffer( - command_buffer: CommandBuffer, - flags: CommandBufferResetFlags, - ) -> Result; - - "vkCmdBindPipeline", cmd_bind_pipeline( - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - pipeline: Pipeline, - ) -> (); - - "vkCmdSetViewport", cmd_set_viewport( - command_buffer: CommandBuffer, - first_viewport: uint32_t, - viewport_count: uint32_t, - p_viewports: *const Viewport, - ) -> (); - - "vkCmdSetScissor", cmd_set_scissor( - command_buffer: CommandBuffer, - first_scissor: uint32_t, - scissor_count: uint32_t, - p_scissors: *const Rect2D, - ) -> (); - - "vkCmdSetLineWidth", cmd_set_line_width( - command_buffer: CommandBuffer, - line_width: c_float, - ) -> (); - - "vkCmdSetDepthBias", cmd_set_depth_bias( - command_buffer: CommandBuffer, - depth_bias_constant_factor: c_float, - depth_bias_clamp: c_float, - depth_bias_slope_factor: c_float, - ) -> (); - - "vkCmdSetBlendConstants", cmd_set_blend_constants( - command_buffer: CommandBuffer, - blend_constants: *const [c_float; 4], - ) -> (); - - "vkCmdSetDepthBounds", cmd_set_depth_bounds( - command_buffer: CommandBuffer, - min_depth_bounds: c_float, - max_depth_bounds: c_float, - ) -> (); - - "vkCmdSetStencilCompareMask", cmd_set_stencil_compare_mask( - command_buffer: CommandBuffer, - face_mask: StencilFaceFlags, - compare_mask: uint32_t, - ) -> (); - - "vkCmdSetStencilWriteMask", cmd_set_stencil_write_mask( - command_buffer: CommandBuffer, - face_mask: StencilFaceFlags, - write_mask: uint32_t, - ) -> (); - - "vkCmdSetStencilReference", cmd_set_stencil_reference( - command_buffer: CommandBuffer, - face_mask: StencilFaceFlags, - reference: uint32_t, - ) -> (); - - "vkCmdBindDescriptorSets", cmd_bind_descriptor_sets( - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - layout: PipelineLayout, - first_set: uint32_t, - descriptor_set_count: uint32_t, - p_descriptor_sets: *const DescriptorSet, - dynamic_offset_count: uint32_t, - p_dynamic_offsets: *const uint32_t, - ) -> (); - - "vkCmdBindIndexBuffer", cmd_bind_index_buffer( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - index_type: IndexType, - ) -> (); - - "vkCmdBindVertexBuffers", cmd_bind_vertex_buffers( - command_buffer: CommandBuffer, - first_binding: uint32_t, - binding_count: uint32_t, - p_buffers: *const Buffer, - p_offsets: *const DeviceSize, - ) -> (); - - "vkCmdDraw", cmd_draw( - command_buffer: CommandBuffer, - vertex_count: uint32_t, - instance_count: uint32_t, - first_vertex: uint32_t, - first_instance: uint32_t, - ) -> (); - - "vkCmdDrawIndexed", cmd_draw_indexed( - command_buffer: CommandBuffer, - index_count: uint32_t, - instance_count: uint32_t, - first_index: uint32_t, - vertex_offset: int32_t, - first_instance: uint32_t, - ) -> (); - - "vkCmdDrawIndirect", cmd_draw_indirect( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, - ) -> (); - - "vkCmdDrawIndexedIndirect", cmd_draw_indexed_indirect( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, - ) -> (); - - "vkCmdDispatch", cmd_dispatch( - command_buffer: CommandBuffer, - x: uint32_t, - y: uint32_t, - z: uint32_t, - ) -> (); - - "vkCmdDispatchIndirect", cmd_dispatch_indirect( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - ) -> (); - - "vkCmdCopyBuffer", cmd_copy_buffer( - command_buffer: CommandBuffer, - src_buffer: Buffer, - dst_buffer: Buffer, - region_count: uint32_t, - p_regions: *const BufferCopy, - ) -> (); - - "vkCmdCopyImage", cmd_copy_image( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const ImageCopy, - ) -> (); - - "vkCmdBlitImage", cmd_blit_image( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const ImageBlit, - filter: Filter, - ) -> (); - - "vkCmdCopyBufferToImage", cmd_copy_buffer_to_image( - command_buffer: CommandBuffer, - src_buffer: Buffer, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const BufferImageCopy, - ) -> (); - - "vkCmdCopyImageToBuffer", cmd_copy_image_to_buffer( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_buffer: Buffer, - region_count: uint32_t, - p_regions: *const BufferImageCopy, - ) -> (); - - "vkCmdUpdateBuffer", cmd_update_buffer( - command_buffer: CommandBuffer, - dst_buffer: Buffer, - dst_offset: DeviceSize, - data_size: DeviceSize, - p_data: *const c_void, - ) -> (); - - "vkCmdFillBuffer", cmd_fill_buffer( - command_buffer: CommandBuffer, - dst_buffer: Buffer, - dst_offset: DeviceSize, - size: DeviceSize, - data: uint32_t, - ) -> (); - - "vkCmdClearColorImage", cmd_clear_color_image( - command_buffer: CommandBuffer, - image: Image, - image_layout: ImageLayout, - p_color: *const ClearColorValue, - range_count: uint32_t, - p_ranges: *const ImageSubresourceRange, - ) -> (); - - "vkCmdClearDepthStencilImage", cmd_clear_depth_stencil_image( - command_buffer: CommandBuffer, - image: Image, - image_layout: ImageLayout, - p_depth_stencil: *const ClearDepthStencilValue, - range_count: uint32_t, - p_ranges: *const ImageSubresourceRange, - ) -> (); - - "vkCmdClearAttachments", cmd_clear_attachments( - command_buffer: CommandBuffer, - attachment_count: uint32_t, - p_attachments: *const ClearAttachment, - rect_count: uint32_t, - p_rects: *const ClearRect, - ) -> (); - - "vkCmdResolveImage", cmd_resolve_image( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const ImageResolve, - ) -> (); - - "vkCmdSetEvent", cmd_set_event( - command_buffer: CommandBuffer, - event: Event, - stage_mask: PipelineStageFlags, - ) -> (); - - "vkCmdResetEvent", cmd_reset_event( - command_buffer: CommandBuffer, - event: Event, - stage_mask: PipelineStageFlags, - ) -> (); - - "vkCmdWaitEvents", cmd_wait_events( - command_buffer: CommandBuffer, - event_count: uint32_t, - p_events: *const Event, - src_stage_mask: PipelineStageFlags, - dst_stage_mask: PipelineStageFlags, - memory_barrier_count: uint32_t, - p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, - p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, - p_image_memory_barriers: *const ImageMemoryBarrier, - ) -> (); - - "vkCmdPipelineBarrier", cmd_pipeline_barrier( - command_buffer: CommandBuffer, - src_stage_mask: PipelineStageFlags, - dst_stage_mask: PipelineStageFlags, - dependency_flags: DependencyFlags, - memory_barrier_count: uint32_t, - p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, - p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, - p_image_memory_barriers: *const ImageMemoryBarrier, - ) -> (); - - "vkCmdBeginQuery", cmd_begin_query( - command_buffer: CommandBuffer, - query_pool: QueryPool, - query: uint32_t, - flags: QueryControlFlags, - ) -> (); - - "vkCmdEndQuery", cmd_end_query( - command_buffer: CommandBuffer, - query_pool: QueryPool, - query: uint32_t, - ) -> (); - - "vkCmdResetQueryPool", cmd_reset_query_pool( - command_buffer: CommandBuffer, - query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - ) -> (); - - "vkCmdWriteTimestamp", cmd_write_timestamp( - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - query_pool: QueryPool, - query: uint32_t, - ) -> (); - - "vkCmdCopyQueryPoolResults", cmd_copy_query_pool_results( - command_buffer: CommandBuffer, - query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - dst_buffer: Buffer, - dst_offset: DeviceSize, - stride: DeviceSize, - flags: QueryResultFlags, - ) -> (); - - "vkCmdPushConstants", cmd_push_constants( - command_buffer: CommandBuffer, - layout: PipelineLayout, - stage_flags: ShaderStageFlags, - offset: uint32_t, - size: uint32_t, - p_values: *const c_void, - ) -> (); - - "vkCmdBeginRenderPass", cmd_begin_render_pass( - command_buffer: CommandBuffer, - p_render_pass_begin: *const RenderPassBeginInfo, - contents: SubpassContents, - ) -> (); - - "vkCmdNextSubpass", cmd_next_subpass( - command_buffer: CommandBuffer, - contents: SubpassContents, - ) -> (); - - "vkCmdEndRenderPass", cmd_end_render_pass( - command_buffer: CommandBuffer, - ) -> (); - - "vkCmdExecuteCommands", cmd_execute_commands( - command_buffer: CommandBuffer, - command_buffer_count: uint32_t, - p_command_buffers: *const CommandBuffer, - ) -> (); -} + DeviceFnV1_0, + "vkDestroyDevice", destroy_device( + device: Device, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkGetDeviceQueue", get_device_queue( + device: Device, + queue_family_index: uint32_t, + queue_index: uint32_t, + p_queue: *mut Queue, + ) -> (); + + "vkQueueSubmit", queue_submit( + queue: Queue, + submit_count: uint32_t, + p_submits: *const SubmitInfo, + fence: Fence, + ) -> Result; + + "vkQueueWaitIdle", queue_wait_idle( + queue: Queue, + ) -> Result; + + "vkDeviceWaitIdle", device_wait_idle( + device: Device, + ) -> Result; + + "vkAllocateMemory", allocate_memory( + device: Device, + p_allocate_info: *const MemoryAllocateInfo, + p_allocator: *const AllocationCallbacks, + p_memory: *mut DeviceMemory, + ) -> Result; + + "vkFreeMemory", free_memory( + device: Device, + memory: DeviceMemory, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkMapMemory", map_memory( + device: Device, + memory: DeviceMemory, + offset: DeviceSize, + size: DeviceSize, + flags: MemoryMapFlags, + pp_data: *mut *mut c_void, + ) -> Result; + + "vkUnmapMemory", unmap_memory( + device: Device, + memory: DeviceMemory, + ) -> (); + + "vkFlushMappedMemoryRanges", flush_mapped_memory_ranges( + device: Device, + memory_range_count: uint32_t, + p_memory_ranges: *const MappedMemoryRange, + ) -> Result; + + "vkInvalidateMappedMemoryRanges", invalidate_mapped_memory_ranges( + device: Device, + memory_range_count: uint32_t, + p_memory_ranges: *const MappedMemoryRange, + ) -> Result; + + "vkGetDeviceMemoryCommitment", get_device_memory_commitment( + device: Device, + memory: DeviceMemory, + p_committed_memory_in_bytes: *mut DeviceSize, + ) -> (); + + "vkBindBufferMemory", bind_buffer_memory( + device: Device, + buffer: Buffer, + memory: DeviceMemory, + memory_offset: DeviceSize, + ) -> Result; + + "vkBindImageMemory", bind_image_memory( + device: Device, + image: Image, + memory: DeviceMemory, + memory_offset: DeviceSize, + ) -> Result; + + "vkGetBufferMemoryRequirements", get_buffer_memory_requirements( + device: Device, + buffer: Buffer, + p_memory_requirements: *mut MemoryRequirements, + ) -> (); + + "vkGetImageMemoryRequirements", get_image_memory_requirements( + device: Device, + image: Image, + p_memory_requirements: *mut MemoryRequirements, + ) -> (); + + "vkGetImageSparseMemoryRequirements", get_image_sparse_memory_requirements( + device: Device, + image: Image, + p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, + ) -> (); + + "vkQueueBindSparse", queue_bind_sparse( + queue: Queue, + bind_info_count: uint32_t, + p_bind_info: *const BindSparseInfo, + fence: Fence, + ) -> Result; + + "vkCreateFence", create_fence( + device: Device, + p_create_info: *const FenceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, + ) -> Result; + + "vkDestroyFence", destroy_fence( + device: Device, + fence: Fence, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkResetFences", reset_fences( + device: Device, + fence_count: uint32_t, + p_fences: *const Fence, + ) -> Result; + + "vkGetFenceStatus", get_fence_status( + device: Device, + fence: Fence, + ) -> Result; + + "vkWaitForFences", wait_for_fences( + device: Device, + fence_count: uint32_t, + p_fences: *const Fence, + wait_all: Bool32, + timeout: uint64_t, + ) -> Result; + + "vkCreateSemaphore", create_semaphore( + device: Device, + p_create_info: *const SemaphoreCreateInfo, + p_allocator: *const AllocationCallbacks, + p_semaphore: *mut Semaphore, + ) -> Result; + + "vkDestroySemaphore", destroy_semaphore( + device: Device, + semaphore: Semaphore, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateEvent", create_event( + device: Device, + p_create_info: *const EventCreateInfo, + p_allocator: *const AllocationCallbacks, + p_event: *mut Event, + ) -> Result; + + "vkDestroyEvent", destroy_event( + device: Device, + event: Event, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkGetEventStatus", get_event_status( + device: Device, + event: Event, + ) -> Result; + + "vkSetEvent", set_event( + device: Device, + event: Event, + ) -> Result; + + "vkResetEvent", reset_event( + device: Device, + event: Event, + ) -> Result; + + "vkCreateQueryPool", create_query_pool( + device: Device, + p_create_info: *const QueryPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_query_pool: *mut QueryPool, + ) -> Result; + + "vkDestroyQueryPool", destroy_query_pool( + device: Device, + query_pool: QueryPool, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkGetQueryPoolResults", get_query_pool_results( + device: Device, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + data_size: size_t, + p_data: *mut c_void, + stride: DeviceSize, + flags: QueryResultFlags, + ) -> Result; + + "vkCreateBuffer", create_buffer( + device: Device, + p_create_info: *const BufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_buffer: *mut Buffer, + ) -> Result; + + "vkDestroyBuffer", destroy_buffer( + device: Device, + buffer: Buffer, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateBufferView", create_buffer_view( + device: Device, + p_create_info: *const BufferViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *mut BufferView, + ) -> Result; + + "vkDestroyBufferView", destroy_buffer_view( + device: Device, + buffer_view: BufferView, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateImage", create_image( + device: Device, + p_create_info: *const ImageCreateInfo, + p_allocator: *const AllocationCallbacks, + p_image: *mut Image, + ) -> Result; + + "vkDestroyImage", destroy_image( + device: Device, + image: Image, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkGetImageSubresourceLayout", get_image_subresource_layout( + device: Device, + image: Image, + p_subresource: *const ImageSubresource, + p_layout: *mut SubresourceLayout, + ) -> (); + + "vkCreateImageView", create_image_view( + device: Device, + p_create_info: *const ImageViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *mut ImageView, + ) -> Result; + + "vkDestroyImageView", destroy_image_view( + device: Device, + image_view: ImageView, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateShaderModule", create_shader_module( + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_allocator: *const AllocationCallbacks, + p_shader_module: *mut ShaderModule, + ) -> Result; + + "vkDestroyShaderModule", destroy_shader_module( + device: Device, + shader_module: ShaderModule, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreatePipelineCache", create_pipeline_cache( + device: Device, + p_create_info: *const PipelineCacheCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_cache: *mut PipelineCache, + ) -> Result; + + "vkDestroyPipelineCache", destroy_pipeline_cache( + device: Device, + pipeline_cache: PipelineCache, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkGetPipelineCacheData", get_pipeline_cache_data( + device: Device, + pipeline_cache: PipelineCache, + p_data_size: *mut size_t, + p_data: *mut c_void, + ) -> Result; + + "vkMergePipelineCaches", merge_pipeline_caches( + device: Device, + dst_cache: PipelineCache, + src_cache_count: uint32_t, + p_src_caches: *const PipelineCache, + ) -> Result; + + "vkCreateGraphicsPipelines", create_graphics_pipelines( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: uint32_t, + p_create_infos: *const GraphicsPipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, + ) -> Result; + + "vkCreateComputePipelines", create_compute_pipelines( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: uint32_t, + p_create_infos: *const ComputePipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, + ) -> Result; + + "vkDestroyPipeline", destroy_pipeline( + device: Device, + pipeline: Pipeline, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreatePipelineLayout", create_pipeline_layout( + device: Device, + p_create_info: *const PipelineLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_layout: *mut PipelineLayout, + ) -> Result; + + "vkDestroyPipelineLayout", destroy_pipeline_layout( + device: Device, + pipeline_layout: PipelineLayout, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateSampler", create_sampler( + device: Device, + p_create_info: *const SamplerCreateInfo, + p_allocator: *const AllocationCallbacks, + p_sampler: *mut Sampler, + ) -> Result; + + "vkDestroySampler", destroy_sampler( + device: Device, + sampler: Sampler, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateDescriptorSetLayout", create_descriptor_set_layout( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_set_layout: *mut DescriptorSetLayout, + ) -> Result; + + "vkDestroyDescriptorSetLayout", destroy_descriptor_set_layout( + device: Device, + descriptor_set_layout: DescriptorSetLayout, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateDescriptorPool", create_descriptor_pool( + device: Device, + p_create_info: *const DescriptorPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_pool: *mut DescriptorPool, + ) -> Result; + + "vkDestroyDescriptorPool", destroy_descriptor_pool( + device: Device, + descriptor_pool: DescriptorPool, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkResetDescriptorPool", reset_descriptor_pool( + device: Device, + descriptor_pool: DescriptorPool, + flags: DescriptorPoolResetFlags, + ) -> Result; + + "vkAllocateDescriptorSets", allocate_descriptor_sets( + device: Device, + p_allocate_info: *const DescriptorSetAllocateInfo, + p_descriptor_sets: *mut DescriptorSet, + ) -> Result; + + "vkFreeDescriptorSets", free_descriptor_sets( + device: Device, + descriptor_pool: DescriptorPool, + descriptor_set_count: uint32_t, + p_descriptor_sets: *const DescriptorSet, + ) -> Result; + + "vkUpdateDescriptorSets", update_descriptor_sets( + device: Device, + descriptor_write_count: uint32_t, + p_descriptor_writes: *const WriteDescriptorSet, + descriptor_copy_count: uint32_t, + p_descriptor_copies: *const CopyDescriptorSet, + ) -> (); + + "vkCreateFramebuffer", create_framebuffer( + device: Device, + p_create_info: *const FramebufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_framebuffer: *mut Framebuffer, + ) -> Result; + + "vkDestroyFramebuffer", destroy_framebuffer( + device: Device, + framebuffer: Framebuffer, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkCreateRenderPass", create_render_pass( + device: Device, + p_create_info: *const RenderPassCreateInfo, + p_allocator: *const AllocationCallbacks, + p_render_pass: *mut RenderPass, + ) -> Result; + + "vkDestroyRenderPass", destroy_render_pass( + device: Device, + render_pass: RenderPass, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkGetRenderAreaGranularity", get_render_area_granularity( + device: Device, + render_pass: RenderPass, + p_granularity: *mut Extent2D, + ) -> (); + + "vkCreateCommandPool", create_command_pool( + device: Device, + p_create_info: *const CommandPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_command_pool: *mut CommandPool, + ) -> Result; + + "vkDestroyCommandPool", destroy_command_pool( + device: Device, + command_pool: CommandPool, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkResetCommandPool", reset_command_pool( + device: Device, + command_pool: CommandPool, + flags: CommandPoolResetFlags, + ) -> Result; + + "vkAllocateCommandBuffers", allocate_command_buffers( + device: Device, + p_allocate_info: *const CommandBufferAllocateInfo, + p_command_buffers: *mut CommandBuffer, + ) -> Result; + + "vkFreeCommandBuffers", free_command_buffers( + device: Device, + command_pool: CommandPool, + command_buffer_count: uint32_t, + p_command_buffers: *const CommandBuffer, + ) -> (); + + "vkBeginCommandBuffer", begin_command_buffer( + command_buffer: CommandBuffer, + p_begin_info: *const CommandBufferBeginInfo, + ) -> Result; + + "vkEndCommandBuffer", end_command_buffer( + command_buffer: CommandBuffer, + ) -> Result; + + "vkResetCommandBuffer", reset_command_buffer( + command_buffer: CommandBuffer, + flags: CommandBufferResetFlags, + ) -> Result; + + "vkCmdBindPipeline", cmd_bind_pipeline( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + ) -> (); + + "vkCmdSetViewport", cmd_set_viewport( + command_buffer: CommandBuffer, + first_viewport: uint32_t, + viewport_count: uint32_t, + p_viewports: *const Viewport, + ) -> (); + + "vkCmdSetScissor", cmd_set_scissor( + command_buffer: CommandBuffer, + first_scissor: uint32_t, + scissor_count: uint32_t, + p_scissors: *const Rect2D, + ) -> (); + + "vkCmdSetLineWidth", cmd_set_line_width( + command_buffer: CommandBuffer, + line_width: c_float, + ) -> (); + + "vkCmdSetDepthBias", cmd_set_depth_bias( + command_buffer: CommandBuffer, + depth_bias_constant_factor: c_float, + depth_bias_clamp: c_float, + depth_bias_slope_factor: c_float, + ) -> (); + + "vkCmdSetBlendConstants", cmd_set_blend_constants( + command_buffer: CommandBuffer, + blend_constants: *const [c_float; 4], + ) -> (); + + "vkCmdSetDepthBounds", cmd_set_depth_bounds( + command_buffer: CommandBuffer, + min_depth_bounds: c_float, + max_depth_bounds: c_float, + ) -> (); + + "vkCmdSetStencilCompareMask", cmd_set_stencil_compare_mask( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + compare_mask: uint32_t, + ) -> (); + + "vkCmdSetStencilWriteMask", cmd_set_stencil_write_mask( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + write_mask: uint32_t, + ) -> (); + + "vkCmdSetStencilReference", cmd_set_stencil_reference( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + reference: uint32_t, + ) -> (); + + "vkCmdBindDescriptorSets", cmd_bind_descriptor_sets( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: uint32_t, + descriptor_set_count: uint32_t, + p_descriptor_sets: *const DescriptorSet, + dynamic_offset_count: uint32_t, + p_dynamic_offsets: *const uint32_t, + ) -> (); + + "vkCmdBindIndexBuffer", cmd_bind_index_buffer( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + index_type: IndexType, + ) -> (); + + "vkCmdBindVertexBuffers", cmd_bind_vertex_buffers( + command_buffer: CommandBuffer, + first_binding: uint32_t, + binding_count: uint32_t, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + ) -> (); + + "vkCmdDraw", cmd_draw( + command_buffer: CommandBuffer, + vertex_count: uint32_t, + instance_count: uint32_t, + first_vertex: uint32_t, + first_instance: uint32_t, + ) -> (); + + "vkCmdDrawIndexed", cmd_draw_indexed( + command_buffer: CommandBuffer, + index_count: uint32_t, + instance_count: uint32_t, + first_index: uint32_t, + vertex_offset: int32_t, + first_instance: uint32_t, + ) -> (); + + "vkCmdDrawIndirect", cmd_draw_indirect( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: uint32_t, + stride: uint32_t, + ) -> (); + + "vkCmdDrawIndexedIndirect", cmd_draw_indexed_indirect( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: uint32_t, + stride: uint32_t, + ) -> (); + + "vkCmdDispatch", cmd_dispatch( + command_buffer: CommandBuffer, + x: uint32_t, + y: uint32_t, + z: uint32_t, + ) -> (); + + "vkCmdDispatchIndirect", cmd_dispatch_indirect( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + ) -> (); + + "vkCmdCopyBuffer", cmd_copy_buffer( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_buffer: Buffer, + region_count: uint32_t, + p_regions: *const BufferCopy, + ) -> (); + + "vkCmdCopyImage", cmd_copy_image( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageCopy, + ) -> (); + + "vkCmdBlitImage", cmd_blit_image( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageBlit, + filter: Filter, + ) -> (); + + "vkCmdCopyBufferToImage", cmd_copy_buffer_to_image( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const BufferImageCopy, + ) -> (); + + "vkCmdCopyImageToBuffer", cmd_copy_image_to_buffer( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_buffer: Buffer, + region_count: uint32_t, + p_regions: *const BufferImageCopy, + ) -> (); + + "vkCmdUpdateBuffer", cmd_update_buffer( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + data_size: DeviceSize, + p_data: *const c_void, + ) -> (); + + "vkCmdFillBuffer", cmd_fill_buffer( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + size: DeviceSize, + data: uint32_t, + ) -> (); + + "vkCmdClearColorImage", cmd_clear_color_image( + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_color: *const ClearColorValue, + range_count: uint32_t, + p_ranges: *const ImageSubresourceRange, + ) -> (); + + "vkCmdClearDepthStencilImage", cmd_clear_depth_stencil_image( + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_depth_stencil: *const ClearDepthStencilValue, + range_count: uint32_t, + p_ranges: *const ImageSubresourceRange, + ) -> (); + + "vkCmdClearAttachments", cmd_clear_attachments( + command_buffer: CommandBuffer, + attachment_count: uint32_t, + p_attachments: *const ClearAttachment, + rect_count: uint32_t, + p_rects: *const ClearRect, + ) -> (); + + "vkCmdResolveImage", cmd_resolve_image( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageResolve, + ) -> (); + + "vkCmdSetEvent", cmd_set_event( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, + ) -> (); + + "vkCmdResetEvent", cmd_reset_event( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, + ) -> (); + + "vkCmdWaitEvents", cmd_wait_events( + command_buffer: CommandBuffer, + event_count: uint32_t, + p_events: *const Event, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + memory_barrier_count: uint32_t, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: uint32_t, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: uint32_t, + p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> (); + + "vkCmdPipelineBarrier", cmd_pipeline_barrier( + command_buffer: CommandBuffer, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + dependency_flags: DependencyFlags, + memory_barrier_count: uint32_t, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: uint32_t, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: uint32_t, + p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> (); + + "vkCmdBeginQuery", cmd_begin_query( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: uint32_t, + flags: QueryControlFlags, + ) -> (); + + "vkCmdEndQuery", cmd_end_query( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: uint32_t, + ) -> (); + + "vkCmdResetQueryPool", cmd_reset_query_pool( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + ) -> (); + + "vkCmdWriteTimestamp", cmd_write_timestamp( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + query_pool: QueryPool, + query: uint32_t, + ) -> (); + + "vkCmdCopyQueryPoolResults", cmd_copy_query_pool_results( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + dst_buffer: Buffer, + dst_offset: DeviceSize, + stride: DeviceSize, + flags: QueryResultFlags, + ) -> (); + + "vkCmdPushConstants", cmd_push_constants( + command_buffer: CommandBuffer, + layout: PipelineLayout, + stage_flags: ShaderStageFlags, + offset: uint32_t, + size: uint32_t, + p_values: *const c_void, + ) -> (); + + "vkCmdBeginRenderPass", cmd_begin_render_pass( + command_buffer: CommandBuffer, + p_render_pass_begin: *const RenderPassBeginInfo, + contents: SubpassContents, + ) -> (); + + "vkCmdNextSubpass", cmd_next_subpass( + command_buffer: CommandBuffer, + contents: SubpassContents, + ) -> (); + + "vkCmdEndRenderPass", cmd_end_render_pass( + command_buffer: CommandBuffer, + ) -> (); + + "vkCmdExecuteCommands", cmd_execute_commands( + command_buffer: CommandBuffer, + command_buffer_count: uint32_t, + p_command_buffers: *const CommandBuffer, + ) -> (); + } vk_functions!{ - DisplaySwapchainFn, - "vkCreateSharedSwapchainsKHR", create_shared_swapchains_khr( - device: Device, - swapchain_count: uint32_t, - p_create_infos: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchains: *mut SwapchainKHR, - ) -> Result; -} + DisplaySwapchainFn, + "vkCreateSharedSwapchainsKHR", create_shared_swapchains_khr( + device: Device, + swapchain_count: uint32_t, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *mut SwapchainKHR, + ) -> Result; + } vk_functions!{ - SwapchainFn, - "vkCreateSwapchainKHR", create_swapchain_khr( - device: Device, - p_create_info: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchain: *mut SwapchainKHR, - ) -> Result; + SwapchainFn, + "vkCreateSwapchainKHR", create_swapchain_khr( + device: Device, + p_create_info: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchain: *mut SwapchainKHR, + ) -> Result; - "vkDestroySwapchainKHR", destroy_swapchain_khr( - device: Device, - swapchain: SwapchainKHR, - p_allocator: *const AllocationCallbacks, - ) -> (); + "vkDestroySwapchainKHR", destroy_swapchain_khr( + device: Device, + swapchain: SwapchainKHR, + p_allocator: *const AllocationCallbacks, + ) -> (); - "vkGetSwapchainImagesKHR", get_swapchain_images_khr( - device: Device, - swapchain: SwapchainKHR, - p_swapchain_image_count: *mut uint32_t, - p_swapchain_images: *mut Image, - ) -> Result; + "vkGetSwapchainImagesKHR", get_swapchain_images_khr( + device: Device, + swapchain: SwapchainKHR, + p_swapchain_image_count: *mut uint32_t, + p_swapchain_images: *mut Image, + ) -> Result; - "vkAcquireNextImageKHR", acquire_next_image_khr( - device: Device, - swapchain: SwapchainKHR, - timeout: uint64_t, - semaphore: Semaphore, - fence: Fence, - p_image_index: *mut uint32_t, - ) -> Result; + "vkAcquireNextImageKHR", acquire_next_image_khr( + device: Device, + swapchain: SwapchainKHR, + timeout: uint64_t, + semaphore: Semaphore, + fence: Fence, + p_image_index: *mut uint32_t, + ) -> Result; - "vkQueuePresentKHR", queue_present_khr( - queue: Queue, - p_present_info: *const PresentInfoKHR, - ) -> Result; -} + "vkQueuePresentKHR", queue_present_khr( + queue: Queue, + p_present_info: *const PresentInfoKHR, + ) -> Result; + } vk_functions!{ - SurfaceFn, - "vkDestroySurfaceKHR", destroy_surface_khr( - instance: Instance, - surface: SurfaceKHR, - p_allocator: *const AllocationCallbacks, - ) -> (); + SurfaceFn, + "vkDestroySurfaceKHR", destroy_surface_khr( + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, + ) -> (); - "vkGetPhysicalDeviceSurfaceSupportKHR", get_physical_device_surface_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - surface: SurfaceKHR, - p_supported: *mut Bool32, - ) -> Result; + "vkGetPhysicalDeviceSurfaceSupportKHR", get_physical_device_surface_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + surface: SurfaceKHR, + p_supported: *mut Bool32, + ) -> Result; - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", get_physical_device_surface_capabilities_khr( - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_capabilities: *mut SurfaceCapabilitiesKHR, - ) -> Result; + "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", get_physical_device_surface_capabilities_khr( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *mut SurfaceCapabilitiesKHR, + ) -> Result; - "vkGetPhysicalDeviceSurfaceFormatsKHR", get_physical_device_surface_formats_khr( - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_format_count: *mut uint32_t, - p_surface_formats: *mut SurfaceFormatKHR, - ) -> Result; + "vkGetPhysicalDeviceSurfaceFormatsKHR", get_physical_device_surface_formats_khr( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_format_count: *mut uint32_t, + p_surface_formats: *mut SurfaceFormatKHR, + ) -> Result; - "vkGetPhysicalDeviceSurfacePresentModesKHR", get_physical_device_surface_present_modes_khr( - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_present_mode_count: *mut uint32_t, - p_present_modes: *mut PresentModeKHR, - ) -> Result; -} + "vkGetPhysicalDeviceSurfacePresentModesKHR", get_physical_device_surface_present_modes_khr( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_present_mode_count: *mut uint32_t, + p_present_modes: *mut PresentModeKHR, + ) -> Result; + } vk_functions!{ - XlibSurfaceFn, - "vkCreateXlibSurfaceKHR", create_xlib_surface_khr( - instance: Instance, - p_create_info: *const XlibSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; + XlibSurfaceFn, + "vkCreateXlibSurfaceKHR", create_xlib_surface_khr( + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; - "vkGetPhysicalDeviceXlibPresentationSupportKHR", get_physical_device_xlib_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - dpy: *mut Display, - visual_id: VisualID, - ) -> Bool32; -} + "vkGetPhysicalDeviceXlibPresentationSupportKHR", get_physical_device_xlib_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + dpy: *mut Display, + visual_id: VisualID, + ) -> Bool32; + } vk_functions!{ - DebugMarkerFn, - "vkDebugMarkerSetObjectNameEXT", debug_marker_set_object_name_ext( - device: Device, - p_name_info: *const DebugMarkerObjectNameInfoEXT, - ) -> Result; - "vkCmdDebugMarkerBeginEXT", cmd_debug_marker_begin_ext( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> (); - "vkCmdDebugMarkerEndEXT", cmd_debug_marker_end_ext( - command_buffer: CommandBuffer, - ) -> (); - "vkCmdDebugMarkerInsertEXT", cmd_debug_marker_insert_ext( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> (); -} + DebugMarkerFn, + "vkDebugMarkerSetObjectNameEXT", debug_marker_set_object_name_ext( + device: Device, + p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result; + "vkCmdDebugMarkerBeginEXT", cmd_debug_marker_begin_ext( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> (); + "vkCmdDebugMarkerEndEXT", cmd_debug_marker_end_ext( + command_buffer: CommandBuffer, + ) -> (); + "vkCmdDebugMarkerInsertEXT", cmd_debug_marker_insert_ext( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> (); + } vk_functions!{ - DebugReportFn, - "vkCreateDebugReportCallbackEXT", create_debug_report_callback_ext( - instance: Instance, - p_create_info: *const DebugReportCallbackCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_callback: *mut DebugReportCallbackEXT, - ) -> Result; + DebugReportFn, + "vkCreateDebugReportCallbackEXT", create_debug_report_callback_ext( + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *mut DebugReportCallbackEXT, + ) -> Result; - "vkDestroyDebugReportCallbackEXT", destroy_debug_report_callback_ext( - instance: Instance, - callback: DebugReportCallbackEXT, - p_allocator: *const AllocationCallbacks, - ) -> (); + "vkDestroyDebugReportCallbackEXT", destroy_debug_report_callback_ext( + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> (); - "vkDebugReportMessageEXT", debug_report_message_ext( - instance: Instance, - flags: DebugReportFlagsEXT, - object_type: DebugReportObjectTypeEXT, - object: uint64_t, - location: size_t, - message_code: int32_t, - p_layer_prefix: *const c_char, - p_message: *const c_char, - ) -> (); -} + "vkDebugReportMessageEXT", debug_report_message_ext( + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: uint64_t, + location: size_t, + message_code: int32_t, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> (); + } vk_functions!{ - Win32SurfaceFn, - "vkCreateWin32SurfaceKHR", create_win32_surface_khr( - instance: Instance, - p_create_info: *const Win32SurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; + Win32SurfaceFn, + "vkCreateWin32SurfaceKHR", create_win32_surface_khr( + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; - "vkGetPhysicalDeviceWin32PresentationSupportKHR", get_physical_device_win32_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - ) -> Bool32; -} + "vkGetPhysicalDeviceWin32PresentationSupportKHR", get_physical_device_win32_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + ) -> Bool32; + } vk_functions!{ - MirSurfaceFn, - "vkCreateMirSurfaceKHR", create_mir_surface_khr( - instance: Instance, - p_create_info: *const MirSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; + MirSurfaceFn, + "vkCreateMirSurfaceKHR", create_mir_surface_khr( + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; - "vkGetPhysicalDeviceMirPresentationSupportKHR", get_physical_device_mir_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - connection: *mut MirConnection, - ) -> Bool32; -} + "vkGetPhysicalDeviceMirPresentationSupportKHR", get_physical_device_mir_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *mut MirConnection, + ) -> Bool32; + } vk_functions!{ - XcbSurfaceFn, - "vkCreateXcbSurfaceKHR", create_xcb_surface_khr( - instance: Instance, - p_create_info: *const XcbSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; + XcbSurfaceFn, + "vkCreateXcbSurfaceKHR", create_xcb_surface_khr( + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; - "vkGetPhysicalDeviceXcbPresentationSupportKHR", get_physical_device_xcb_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - connection: *mut xcb_connection_t, - visual_id: xcb_visualid_t, - ) -> Bool32; -} + "vkGetPhysicalDeviceXcbPresentationSupportKHR", get_physical_device_xcb_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *mut xcb_connection_t, + visual_id: xcb_visualid_t, + ) -> Bool32; + } vk_functions!{ - AndroidSurfaceFn, - "vkCreateAndroidSurfaceKHR", create_android_surface_khr( - instance: Instance, - p_create_info: *const AndroidSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; -} + AndroidSurfaceFn, + "vkCreateAndroidSurfaceKHR", create_android_surface_khr( + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + } vk_functions!{ - WaylandSurfaceFn, - "vkCreateWaylandSurfaceKHR", create_wayland_surface_khr( - instance: Instance, - p_create_info: *const WaylandSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; + WaylandSurfaceFn, + "vkCreateWaylandSurfaceKHR", create_wayland_surface_khr( + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; - "vkGetPhysicalDeviceWaylandPresentationSupportKHR", get_physical_device_wayland_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - display: *mut wl_display, - ) -> Bool32; -} + "vkGetPhysicalDeviceWaylandPresentationSupportKHR", get_physical_device_wayland_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + display: *mut wl_display, + ) -> Bool32; + } vk_functions!{ - DisplayFn, - "vkGetPhysicalDeviceDisplayPropertiesKHR", get_physical_device_display_properties_khr( - physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, - p_properties: *mut DisplayPropertiesKHR, - ) -> Result; + DisplayFn, + "vkGetPhysicalDeviceDisplayPropertiesKHR", get_physical_device_display_properties_khr( + physical_device: PhysicalDevice, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPropertiesKHR, + ) -> Result; - "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", get_physical_device_display_plane_properties_khr( - physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, - p_properties: *mut DisplayPlanePropertiesKHR, - ) -> Result; + "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", get_physical_device_display_plane_properties_khr( + physical_device: PhysicalDevice, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPlanePropertiesKHR, + ) -> Result; - "vkGetDisplayPlaneSupportedDisplaysKHR", get_display_plane_supported_displays_khr( - physical_device: PhysicalDevice, - plane_index: uint32_t, - p_display_count: *mut uint32_t, - p_displays: *mut DisplayKHR, - ) -> Result; + "vkGetDisplayPlaneSupportedDisplaysKHR", get_display_plane_supported_displays_khr( + physical_device: PhysicalDevice, + plane_index: uint32_t, + p_display_count: *mut uint32_t, + p_displays: *mut DisplayKHR, + ) -> Result; - "vkGetDisplayModePropertiesKHR", get_display_mode_properties_khr( - physical_device: PhysicalDevice, - display: DisplayKHR, - p_property_count: *mut uint32_t, - p_properties: *mut DisplayModePropertiesKHR, - ) -> Result; + "vkGetDisplayModePropertiesKHR", get_display_mode_properties_khr( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayModePropertiesKHR, + ) -> Result; - "vkCreateDisplayModeKHR", create_display_mode_khr( - physical_device: PhysicalDevice, - display: DisplayKHR, - p_create_info: *const DisplayModeCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_mode: *mut DisplayModeKHR, - ) -> Result; + "vkCreateDisplayModeKHR", create_display_mode_khr( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *mut DisplayModeKHR, + ) -> Result; - "vkGetDisplayPlaneCapabilitiesKHR", get_display_plane_capabilities_khr( - physical_device: PhysicalDevice, - mode: DisplayModeKHR, - plane_index: uint32_t, - p_capabilities: *mut DisplayPlaneCapabilitiesKHR, - ) -> Result; + "vkGetDisplayPlaneCapabilitiesKHR", get_display_plane_capabilities_khr( + physical_device: PhysicalDevice, + mode: DisplayModeKHR, + plane_index: uint32_t, + p_capabilities: *mut DisplayPlaneCapabilitiesKHR, + ) -> Result; - "vkCreateDisplayPlaneSurfaceKHR", create_display_plane_surface_khr( - instance: Instance, - p_create_info: *const DisplaySurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; -} + "vkCreateDisplayPlaneSurfaceKHR", create_display_plane_surface_khr( + instance: Instance, + p_create_info: *const DisplaySurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + } vk_functions!{ - IOSSurfaceFn, - "vkCreateIOSSurfaceMVK", create_ios_surface_mvk( - instance: Instance, - p_create_info: *const IOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; -} + IOSSurfaceFn, + "vkCreateIOSSurfaceMVK", create_ios_surface_mvk( + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + } vk_functions!{ - MacOSSurfaceFn, - "vkCreateMacOSSurfaceMVK", create_macos_surface_mvk( - instance: Instance, - p_create_info: *const MacOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; -} + MacOSSurfaceFn, + "vkCreateMacOSSurfaceMVK", create_macos_surface_mvk( + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + } } diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index 8425272..4eec9c1 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -26,7 +26,7 @@ pub struct Vector3 { pub x: f32, pub y: f32, pub z: f32, - pub _pad: f32 + pub _pad: f32, } fn main() { @@ -70,8 +70,8 @@ fn main() { dst_subpass: Default::default(), src_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, src_access_mask: Default::default(), - dst_access_mask: vk::ACCESS_COLOR_ATTACHMENT_READ_BIT | - vk::ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + dst_access_mask: vk::ACCESS_COLOR_ATTACHMENT_READ_BIT + | vk::ACCESS_COLOR_ATTACHMENT_WRITE_BIT, dst_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, }; let subpass = vk::SubpassDescription { @@ -198,9 +198,8 @@ fn main() { let vertex_input_buffer = base.device .create_buffer(&vertex_input_buffer_info, None) .unwrap(); - let vertex_input_buffer_memory_req = base.device.get_buffer_memory_requirements( - vertex_input_buffer, - ); + let vertex_input_buffer_memory_req = base.device + .get_buffer_memory_requirements(vertex_input_buffer); let vertex_input_buffer_memory_index = find_memorytype_index( &vertex_input_buffer_memory_req, @@ -240,7 +239,7 @@ fn main() { x: 1.0, y: 1.0, z: 1.0, - _pad: 0.0 + _pad: 0.0, }; let uniform_color_buffer_info = vk::BufferCreateInfo { s_type: vk::StructureType::BufferCreateInfo, @@ -255,9 +254,8 @@ fn main() { let uniform_color_buffer = base.device .create_buffer(&uniform_color_buffer_info, None) .unwrap(); - let uniform_color_buffer_memory_req = base.device.get_buffer_memory_requirements( - uniform_color_buffer, - ); + let uniform_color_buffer_memory_req = base.device + .get_buffer_memory_requirements(uniform_color_buffer); let uniform_color_buffer_memory_index = find_memorytype_index( &uniform_color_buffer_memory_req, @@ -388,89 +386,97 @@ fn main() { .bind_image_memory(texture_image, texture_memory, 0) .expect("Unable to bind depth image memory"); - - - record_submit_commandbuffer(&base.device, - base.setup_command_buffer, - base.present_queue, - &[vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT], - &[], - &[], - |device, texture_command_buffer| { - let texture_barrier = vk::ImageMemoryBarrier { - s_type: vk::StructureType::ImageMemoryBarrier, - p_next: ptr::null(), - src_access_mask: Default::default(), - dst_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT, - old_layout: vk::ImageLayout::Undefined, - new_layout: vk::ImageLayout::TransferDstOptimal, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - image: texture_image, - subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, - base_mip_level: 0, - level_count: 1, - base_array_layer: 0, - layer_count: 1, - }, - }; - device.cmd_pipeline_barrier(texture_command_buffer, - vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - vk::PIPELINE_STAGE_TRANSFER_BIT, - vk::DependencyFlags::empty(), - &[], - &[], - &[texture_barrier]); - let buffer_copy_regions = [vk::BufferImageCopy { - image_subresource: vk::ImageSubresourceLayers { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, - mip_level: 0, - base_array_layer: 0, - layer_count: 1, - }, - image_extent: vk::Extent3D { - width: image_dimensions.0, - height: image_dimensions.1, - depth: 1, - }, - buffer_offset: 0, - // FIX ME - buffer_image_height: 0, - buffer_row_length: 0, - image_offset: vk::Offset3D { x: 0, y: 0, z: 0 }, - }]; - device.cmd_copy_buffer_to_image(texture_command_buffer, - image_buffer, - texture_image, - vk::ImageLayout::TransferDstOptimal, - &buffer_copy_regions); - let texture_barrier_end = vk::ImageMemoryBarrier { - s_type: vk::StructureType::ImageMemoryBarrier, - p_next: ptr::null(), - src_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT, - dst_access_mask: vk::ACCESS_SHADER_READ_BIT, - old_layout: vk::ImageLayout::TransferDstOptimal, - new_layout: vk::ImageLayout::ShaderReadOnlyOptimal, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - image: texture_image, - subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, - base_mip_level: 0, - level_count: 1, - base_array_layer: 0, - layer_count: 1, - }, - }; - device.cmd_pipeline_barrier(texture_command_buffer, - vk::PIPELINE_STAGE_TRANSFER_BIT, - vk::PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - vk::DependencyFlags::empty(), - &[], - &[], - &[texture_barrier_end]); - }); + record_submit_commandbuffer( + &base.device, + base.setup_command_buffer, + base.present_queue, + &[vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT], + &[], + &[], + |device, texture_command_buffer| { + let texture_barrier = vk::ImageMemoryBarrier { + s_type: vk::StructureType::ImageMemoryBarrier, + p_next: ptr::null(), + src_access_mask: Default::default(), + dst_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT, + old_layout: vk::ImageLayout::Undefined, + new_layout: vk::ImageLayout::TransferDstOptimal, + src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + image: texture_image, + subresource_range: vk::ImageSubresourceRange { + aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + base_mip_level: 0, + level_count: 1, + base_array_layer: 0, + layer_count: 1, + }, + }; + device.cmd_pipeline_barrier( + texture_command_buffer, + vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + vk::PIPELINE_STAGE_TRANSFER_BIT, + vk::DependencyFlags::empty(), + &[], + &[], + &[texture_barrier], + ); + let buffer_copy_regions = [ + vk::BufferImageCopy { + image_subresource: vk::ImageSubresourceLayers { + aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + mip_level: 0, + base_array_layer: 0, + layer_count: 1, + }, + image_extent: vk::Extent3D { + width: image_dimensions.0, + height: image_dimensions.1, + depth: 1, + }, + buffer_offset: 0, + // FIX ME + buffer_image_height: 0, + buffer_row_length: 0, + image_offset: vk::Offset3D { x: 0, y: 0, z: 0 }, + }, + ]; + device.cmd_copy_buffer_to_image( + texture_command_buffer, + image_buffer, + texture_image, + vk::ImageLayout::TransferDstOptimal, + &buffer_copy_regions, + ); + let texture_barrier_end = vk::ImageMemoryBarrier { + s_type: vk::StructureType::ImageMemoryBarrier, + p_next: ptr::null(), + src_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT, + dst_access_mask: vk::ACCESS_SHADER_READ_BIT, + old_layout: vk::ImageLayout::TransferDstOptimal, + new_layout: vk::ImageLayout::ShaderReadOnlyOptimal, + src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + image: texture_image, + subresource_range: vk::ImageSubresourceRange { + aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + base_mip_level: 0, + level_count: 1, + base_array_layer: 0, + layer_count: 1, + }, + }; + device.cmd_pipeline_barrier( + texture_command_buffer, + vk::PIPELINE_STAGE_TRANSFER_BIT, + vk::PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + vk::DependencyFlags::empty(), + &[], + &[], + &[texture_barrier_end], + ); + }, + ); let sampler_info = vk::SamplerCreateInfo { s_type: vk::StructureType::SamplerCreateInfo, @@ -564,7 +570,6 @@ fn main() { p_bindings: desc_layout_bindings.as_ptr(), }; - let desc_set_layouts = [ base.device .create_descriptor_set_layout(&descriptor_info, None) @@ -856,13 +861,14 @@ fn main() { let graphic_pipeline = graphics_pipelines[0]; - base.render_loop(|| { let present_index = base.swapchain_loader - .acquire_next_image_khr(base.swapchain, - std::u64::MAX, - base.present_complete_semaphore, - vk::Fence::null()) + .acquire_next_image_khr( + base.swapchain, + std::u64::MAX, + base.present_complete_semaphore, + vk::Fence::null(), + ) .unwrap(); let clear_values = [ vk::ClearValue { @@ -948,14 +954,10 @@ fn main() { base.device.destroy_pipeline(pipeline, None); } base.device.destroy_pipeline_layout(pipeline_layout, None); - base.device.destroy_shader_module( - vertex_shader_module, - None, - ); - base.device.destroy_shader_module( - fragment_shader_module, - None, - ); + base.device + .destroy_shader_module(vertex_shader_module, None); + base.device + .destroy_shader_module(fragment_shader_module, None); base.device.free_memory(image_buffer_memory, None); base.device.destroy_buffer(image_buffer, None); base.device.free_memory(texture_memory, None); @@ -968,10 +970,8 @@ fn main() { base.device.free_memory(vertex_input_buffer_memory, None); base.device.destroy_buffer(vertex_input_buffer, None); for &descriptor_set_layout in desc_set_layouts.iter() { - base.device.destroy_descriptor_set_layout( - descriptor_set_layout, - None, - ); + base.device + .destroy_descriptor_set_layout(descriptor_set_layout, None); } base.device.destroy_descriptor_pool(descriptor_pool, None); base.device.destroy_sampler(sampler, None); From 9d31e95f94ee85f31be5892758606d9eac08207a Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 10 Mar 2018 10:07:12 +0100 Subject: [PATCH 006/122] Add function pointer calls --- generator/src/bin/generator.rs | 7 +- generator/src/lib.rs | 154 ++++++++++++++++++++++++--------- 2 files changed, 119 insertions(+), 42 deletions(-) diff --git a/generator/src/bin/generator.rs b/generator/src/bin/generator.rs index 7c66db3..d2c310b 100644 --- a/generator/src/bin/generator.rs +++ b/generator/src/bin/generator.rs @@ -26,11 +26,12 @@ fn main() { .flat_map(|features| features.elements.iter().map(|feature| feature)) .collect(); - let source_code: Vec<_> = features.iter().map(|feature| gen_load(feature, &commands)).collect(); + let source_code: Vec<_> = features + .iter() + .map(|feature| generate_core_spec(feature, &commands)) + .collect(); let mut file = File::create("vk_test.rs").expect("vk"); for source_code in &source_code { write!(&mut file, "{}", source_code); } - - } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index ba33887..8e565d4 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1,3 +1,4 @@ +#![recursion_limit = "256"] // extern crate serde; // #[macro_use] // extern crate serde_derive; @@ -88,7 +89,119 @@ impl FieldExt for vkxml::Field { } use std::collections::HashMap; pub type CommandMap<'a> = HashMap; -pub fn gen_load(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Tokens { + +fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quote::Tokens { + let names: Vec<_> = commands.iter().map(|cmd| cmd.command_ident()).collect(); + let names_ref = &names; + let raw_names: Vec<_> = commands + .iter() + .map(|cmd| Ident::from(cmd.name.as_str())) + .collect(); + let raw_names_ref = &raw_names; + let names_left = &names; + let names_right = &names; + + let params: Vec> = commands + .iter() + .map(|cmd| { + let fn_name_raw = cmd.name.as_str(); + let fn_name_snake = cmd.command_ident(); + let params: Vec<_> = cmd.param + .iter() + .map(|field| { + let name = field.param_ident(); + let ty = field.type_ident(); + (name, ty) + }) + .collect(); + params + }) + .collect(); + + let params_names: Vec> = params + .iter() + .map(|inner_params| { + inner_params + .iter() + .map(|&(param_name, _)| param_name) + .collect() + }) + .collect(); + let param_names_ref = ¶ms_names; + let expanded_params: Vec<_> = params + .iter() + .map(|inner_params| { + let inner_params_iter = inner_params.iter().map(|&(param_name, param_ty)| { + quote!{#param_name: #param_ty} + }); + quote!{ + #(#inner_params_iter,)* + } + }) + .collect(); + let expanded_params_ref = &expanded_params; + + let params_ref = ¶ms; + let return_types: Vec<_> = commands + .iter() + .map(|cmd| cmd.return_type.type_ident()) + .collect(); + let return_types_ref = &return_types; + quote!{ + pub struct #ident { + #( + #names_ref: extern "system" fn(#expanded_params_ref) -> #return_types_ref, + )* + } + + unsafe impl Send for #ident {} + unsafe impl Sync for #ident {} + + impl ::std::clone::Clone for #ident { + pub fn clone(&self) -> Self { + #ident{ + #(#names_left: self.#names_right,)* + } + } + } + impl #ident { + pub fn load(mut f: F) -> ::std::result::Result> + where F: FnMut(&::std::ffi::CStr) -> *const c_void + { + use std::ffi::CString; + use std::mem; + let mut err_str = Vec::new(); + let s = #ident { + #( + #names_ref: unsafe { + let raw_name = stringify!(#raw_names_ref); + let cname = CString::new(raw_name).unwrap(); + let val = f(&cname); + if val.is_null(){ + err_str.push(raw_name); + } + mem::transmute(val) + }, + )* + }; + + if err_str.is_empty() { + Ok(s) + } + else{ + Err(err_str) + } + + } + #( + pub fn #names_ref(#expanded_params_ref) -> #return_types_ref { + (self.#names_left)(#(#param_names_ref,)*) + } + )* + } + } +} +pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Tokens { let (device_commands, instance_commands) = feature .elements .iter() @@ -120,42 +233,6 @@ pub fn gen_load(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Token acc }); let name = Ident::from("Test"); - fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quote::Tokens { - let function_pointers: Vec<_> = commands - .iter() - .map(|cmd| { - let fn_name_raw = cmd.name.as_str(); - let fn_name_snake = cmd.command_ident(); - let params: Vec<_> = cmd.param - .iter() - .map(|field| { - let name = field.param_ident(); - let ty = field.type_ident(); - quote!{#name: #ty} - }) - .collect(); - let return_ty = cmd.return_type.type_ident(); - quote!{ - #fn_name_snake: extern "system" fn(#(#params,)*) -> #return_ty - } - }) - .collect(); - let names: Vec<_> = commands.iter().map(|cmd| cmd.command_ident()).collect(); - let names_left = &names; - let names_right = &names; - quote!{ - pub struct #ident { - #(#function_pointers,)* - } - impl ::std::clone::Clone for #ident { - pub fn clone(&self) -> Self { - #ident{ - #(#names_left: self.#names_right,)* - } - } - } - } - } let version = feature.version_string(); let instance = generate_function_pointers( Ident::from(format!("InstanceFnV{}", version).as_str()), @@ -163,11 +240,10 @@ pub fn gen_load(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Token ); let device = generate_function_pointers( Ident::from(format!("DeviceFnV{}", version).as_str()), - &instance_commands, + &device_commands, ); quote! { #instance - #device } } From 86068db713dc99bf31d210e078495930c3aa115d Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 10 Mar 2018 10:47:02 +0100 Subject: [PATCH 007/122] Add ptr types --- generator/Cargo.toml | 10 ++++++++-- generator/src/lib.rs | 25 ++++++++++++++++++------- 2 files changed, 26 insertions(+), 9 deletions(-) diff --git a/generator/Cargo.toml b/generator/Cargo.toml index a4cca40..f2b6c51 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -5,6 +5,12 @@ authors = ["Maik Klein "] [dependencies] vkxml = {git = "https://github.com/maikklein/vkxml"} -quote = "0.4.2" -syn = "0.12.14" heck = "0.3.0" + +[dependencies.quote] +version = "0.4.2" + +[dependencies.syn] +vesion = "0.12.14" +features = ["full", "extra-traits"] + diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 8e565d4..cacfc1c 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -8,6 +8,7 @@ extern crate quote; extern crate syn; pub extern crate vkxml; +use quote::Tokens; use heck::SnakeCase; use syn::Ident; @@ -56,7 +57,7 @@ pub trait FieldExt { fn param_ident(&self) -> Ident; /// Returns the basetype ident and removes the 'Vk' prefix - fn type_ident(&self) -> Ident; + fn type_tokens(&self) -> Tokens; } impl FieldExt for vkxml::Field { @@ -69,7 +70,7 @@ impl FieldExt for vkxml::Field { Ident::from(name_corrected.to_snake_case().as_str()) } - fn type_ident(&self) -> Ident { + fn type_tokens(&self) -> Tokens { let new_name = match self.basetype.as_str() { "void" => "c_void", "char" => "c_char", @@ -84,7 +85,17 @@ impl FieldExt for vkxml::Field { } } }; - Ident::from(new_name) + let ptr_name = self.reference + .as_ref() + .map(|reference| match *reference { + vkxml::ReferenceType::Pointer => "*mut", + vkxml::ReferenceType::PointerToPointer => "*mut", + vkxml::ReferenceType::PointerToConstPointer => "*const", + }) + .unwrap_or(""); + let ty: syn::Type = + syn::parse_str(&format!("{} {}", ptr_name, new_name)).expect("parse field"); + quote!{#ty} } } use std::collections::HashMap; @@ -101,7 +112,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo let names_left = &names; let names_right = &names; - let params: Vec> = commands + let params: Vec> = commands .iter() .map(|cmd| { let fn_name_raw = cmd.name.as_str(); @@ -110,7 +121,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo .iter() .map(|field| { let name = field.param_ident(); - let ty = field.type_ident(); + let ty = field.type_tokens(); (name, ty) }) .collect(); @@ -131,7 +142,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo let expanded_params: Vec<_> = params .iter() .map(|inner_params| { - let inner_params_iter = inner_params.iter().map(|&(param_name, param_ty)| { + let inner_params_iter = inner_params.iter().map(|&(ref param_name, ref param_ty)| { quote!{#param_name: #param_ty} }); quote!{ @@ -144,7 +155,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo let params_ref = ¶ms; let return_types: Vec<_> = commands .iter() - .map(|cmd| cmd.return_type.type_ident()) + .map(|cmd| cmd.return_type.type_tokens()) .collect(); let return_types_ref = &return_types; quote!{ From b47b20023ea2cf852707256b8cbb493571df5d86 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 10 Mar 2018 16:21:35 +0100 Subject: [PATCH 008/122] Generate bitmasks --- generator/src/bin/generator.rs | 28 +---- generator/src/lib.rs | 196 ++++++++++++++++++++++++++++----- 2 files changed, 172 insertions(+), 52 deletions(-) diff --git a/generator/src/bin/generator.rs b/generator/src/bin/generator.rs index d2c310b..a1759c5 100644 --- a/generator/src/bin/generator.rs +++ b/generator/src/bin/generator.rs @@ -1,3 +1,4 @@ +#[macro_use] extern crate generator; use std::fs::File; use generator::*; @@ -7,31 +8,6 @@ use std::io::Write; fn main() { let file = File::open("New-Vulkan-XML-Format/vk_new.xml").expect("vknew"); let spec = vkxml::Registry::from_file(file).expect(""); + write_source_code(&spec); - let commands: HashMap = spec.elements - .iter() - .filter_map(|elem| match elem { - &vkxml::RegistryElement::Commands(ref cmds) => Some(cmds), - _ => None, - }) - .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) - .collect(); - - let features: Vec<&vkxml::Feature> = spec.elements - .iter() - .filter_map(|elem| match elem { - &vkxml::RegistryElement::Features(ref features) => Some(features), - _ => None, - }) - .flat_map(|features| features.elements.iter().map(|feature| feature)) - .collect(); - - let source_code: Vec<_> = features - .iter() - .map(|feature| generate_core_spec(feature, &commands)) - .collect(); - let mut file = File::create("vk_test.rs").expect("vk"); - for source_code in &source_code { - write!(&mut file, "{}", source_code); - } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index cacfc1c..5edd2fe 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -9,7 +9,7 @@ extern crate syn; pub extern crate vkxml; use quote::Tokens; -use heck::SnakeCase; +use heck::{CamelCase, SnakeCase}; use syn::Ident; @@ -60,6 +60,33 @@ pub trait FieldExt { fn type_tokens(&self) -> Tokens; } +fn to_type_tokens(type_name: &str, reference: Option<&vkxml::ReferenceType>) -> Tokens { + let new_name = match type_name { + "void" => "c_void", + "char" => "c_char", + "float" => "c_float", + "long" => "c_ulong", + _ => { + let prefix = &type_name[0..2]; + if prefix == "Vk" { + &type_name[2..] + } else { + type_name + } + } + }; + let ptr_name = reference + .as_ref() + .map(|reference| match *reference { + &vkxml::ReferenceType::Pointer => "*mut", + &vkxml::ReferenceType::PointerToPointer => "*mut", + &vkxml::ReferenceType::PointerToConstPointer => "*const", + }) + .unwrap_or(""); + let ty: syn::Type = syn::parse_str(&format!("{} {}", ptr_name, new_name)).expect("parse field"); + quote!{#ty} +} + impl FieldExt for vkxml::Field { fn param_ident(&self) -> Ident { let name = self.name.as_ref().map(|s| s.as_str()).unwrap_or("field"); @@ -71,31 +98,7 @@ impl FieldExt for vkxml::Field { } fn type_tokens(&self) -> Tokens { - let new_name = match self.basetype.as_str() { - "void" => "c_void", - "char" => "c_char", - "float" => "c_float", - "long" => "c_ulong", - _ => { - let prefix = &self.basetype[0..2]; - if prefix == "Vk" { - &self.basetype[2..] - } else { - self.basetype.as_str() - } - } - }; - let ptr_name = self.reference - .as_ref() - .map(|reference| match *reference { - vkxml::ReferenceType::Pointer => "*mut", - vkxml::ReferenceType::PointerToPointer => "*mut", - vkxml::ReferenceType::PointerToConstPointer => "*const", - }) - .unwrap_or(""); - let ty: syn::Type = - syn::parse_str(&format!("{} {}", ptr_name, new_name)).expect("parse field"); - quote!{#ty} + to_type_tokens(&self.basetype, self.reference.as_ref()) } } use std::collections::HashMap; @@ -212,6 +215,88 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo } } } +pub fn generate_extension(extension: &vkxml::Extension, commands: &CommandMap) -> quote::Tokens { + let extension_commands: Vec<&vkxml::Command> = extension + .elements + .iter() + .flat_map(|extension| { + if let &vkxml::ExtensionElement::Require(ref spec) = extension { + spec.elements + .iter() + .filter_map(|extension_spec| { + if let &vkxml::ExtensionSpecificationElement::CommandReference( + ref cmd_ref, + ) = extension_spec + { + Some(cmd_ref) + } else { + None + } + }) + .collect() + } else { + vec![] + } + }) + .filter_map(|cmd_ref| commands.get(&cmd_ref.name)) + .map(|&cmd| cmd) + .collect(); + if extension_commands.is_empty() { + return quote!{}; + } + let name = format!("{}Fn", extension.name.to_camel_case()); + let ident = Ident::from(&name[2..]); + generate_function_pointers(ident, &extension_commands) +} +pub fn generate_typedef(typedef: &vkxml::Typedef) -> Tokens { + let typedef_name = to_type_tokens(&typedef.name, None); + let typedef_ty = to_type_tokens(&typedef.basetype, None); + quote!{ + type #typedef_name = #typedef_ty; + } +} +pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Tokens { + println!("{:#?}", bitmask); + let ident = Ident::from(&bitmask.name[2..]); + let type_token = to_type_tokens(&bitmask.basetype, None); + quote!{ + vk_bitflags_wrapped!(#ident, 0b0, #type_token); + } +} +pub fn generate_enumeration(_enum: &vkxml::EnumerationDeclaration) -> Tokens { + quote!{} +} +pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { + let name = Ident::from(&_struct.name[2..]); + let params = _struct + .elements + .iter() + .filter_map(|elem| match *elem { + vkxml::StructElement::Member(ref field) => Some(field), + _ => None, + }) + .map(|field| { + let param_ident = field.param_ident(); + let param_ty_tokens = field.type_tokens(); + quote!{pub #param_ident: #param_ty_tokens} + }); + quote!{ + #[derive(Clone, Debug)] + #[repr(C)] + pub struct #name { + #(#params,)* + } + } +} +pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Tokens { + match *definition { + vkxml::DefinitionsElement::Typedef(ref typedef) => generate_typedef(typedef), + vkxml::DefinitionsElement::Struct(ref _struct) => generate_struct(_struct), + vkxml::DefinitionsElement::Enumeration(ref _enum) => generate_enumeration(_enum), + vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask), + _ => quote!{}, + } +} pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Tokens { let (device_commands, instance_commands) = feature .elements @@ -258,3 +343,62 @@ pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> qu #device } } + +pub fn write_source_code(spec: &vkxml::Registry) { + use std::io::Write; + use std::fs::File; + let commands: HashMap = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Commands(ref cmds) => Some(cmds), + _ => None, + }) + .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) + .collect(); + + let features: Vec<&vkxml::Feature> = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Features(ref features) => Some(features), + _ => None, + }) + .flat_map(|features| features.elements.iter().map(|feature| feature)) + .collect(); + + let extensions: Vec<&vkxml::Extension> = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Extensions(ref extensions) => Some(extensions), + _ => None, + }) + .flat_map(|extensions| extensions.elements.iter().map(|extension| extension)) + .collect(); + + let definitions: Vec<&vkxml::DefinitionsElement> = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Definitions(ref definitions) => Some(definitions), + _ => None, + }) + .flat_map(|definitions| definitions.elements.iter().map(|definition| definition)) + .collect(); + + let definition_code: Vec<_> = definitions.into_iter().map(generate_definition).collect(); + + let feature_code: Vec<_> = features + .iter() + .map(|feature| generate_core_spec(feature, &commands)) + .collect(); + + let extension_code: Vec<_> = extensions + .iter() + .map(|ext| generate_extension(ext, &commands)) + .collect(); + let mut file = File::create("vk_test.rs").expect("vk"); + let source_code = quote!{ + //#(#feature_code)* + //#(#extension_code)* + #(#definition_code)* + }; + write!(&mut file, "{}", source_code); +} From bfed51f8d38d18bfabb82c66ea483c06d8eafd32 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 1 Apr 2018 10:52:21 +0200 Subject: [PATCH 009/122] Save --- ash/Cargo.toml | 2 + ash/src/lib.rs | 4 + generator/Cargo.toml | 6 +- generator/src/lib.rs | 219 ++++++++++++++++++++++++++++++++++++++++--- 4 files changed, 218 insertions(+), 13 deletions(-) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 205661e..24bf22e 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -13,6 +13,8 @@ documentation = "https://docs.rs/ash" shared_library = "0.1.5" lazy_static = "0.2.1" libc = "0.2.26" +enumflags = "*" +enumflags_derive = "*" [features] default = [] diff --git a/ash/src/lib.rs b/ash/src/lib.rs index a4691bb..90df9b8 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -2,6 +2,9 @@ extern crate lazy_static; extern crate libc; extern crate shared_library; +extern crate enumflags; +#[macro_use] +extern crate enumflags_derive; pub use instance::{DeviceError, Instance}; pub use device::Device; pub use entry::{Entry, InstanceError, LoadingError}; @@ -15,6 +18,7 @@ pub mod vk; pub mod extensions; pub mod version; pub mod util; +mod vk_test; pub trait RawPtr { fn as_raw_ptr(&self) -> *const T; diff --git a/generator/Cargo.toml b/generator/Cargo.toml index f2b6c51..0142627 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -4,13 +4,15 @@ version = "0.1.0" authors = ["Maik Klein "] [dependencies] -vkxml = {git = "https://github.com/maikklein/vkxml"} +vkxml = {path = "/home/maik/projects/vkxml"} +#vkxml = {git = "https://github.com/maikklein/vkxml"} heck = "0.3.0" +proc-macro2 = "0.2.3" [dependencies.quote] version = "0.4.2" [dependencies.syn] -vesion = "0.12.14" +version = "0.12.14" features = ["full", "extra-traits"] diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 5edd2fe..152ab35 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -3,16 +3,84 @@ // #[macro_use] // extern crate serde_derive; extern crate heck; +extern crate proc_macro2; #[macro_use] extern crate quote; extern crate syn; pub extern crate vkxml; +use proc_macro2::Term; use quote::Tokens; -use heck::{CamelCase, SnakeCase}; - +use heck::{CamelCase, ShoutySnakeCase, SnakeCase}; use syn::Ident; +pub enum Constant { + Number(i32), + Hex(String), + BitPos(u32), + CExpr(vkxml::CExpression), + Text(String), +} +impl Constant { + pub fn value(&self) -> Option { + match *self { + Constant::Number(n) => Some(n as i64), + Constant::Hex(ref hex) => Some(hex.parse().expect("hex parse")), + Constant::BitPos(pos) => Some((1 << pos) as i64), + _ => None, + } + } + pub fn to_tokens(&self) -> Tokens { + match *self { + Constant::Number(n) => { + let term = Term::intern(&n.to_string()); + quote!{#term} + } + Constant::Hex(ref s) => { + let term = Term::intern(s); + quote!{#term} + } + Constant::Text(ref text) => { + quote!{#text} + } + Constant::CExpr(ref cexpr) => { + let rexpr = cexpr.replace("~", "!").replace("U", "u32"); + let term = Term::intern(&rexpr); + quote!{#term} + } + Constant::BitPos(pos) => { + let value = 1 << pos; + let term = Term::intern(&format!("0b{:b}", value)); + quote!{#term} + } + } + } + + pub fn from_constant(constant: &vkxml::Constant) -> Self { + let number = constant.number.map(|n| Constant::Number(n)); + let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); + let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); + let expr = constant + .c_expression + .as_ref() + .map(|e| Constant::CExpr(e.clone())); + number.or(hex).or(bitpos).or(expr).expect("") + } + pub fn from_extension(extension: &vkxml::ExtensionConstant) -> Self { + let number = extension.number.map(|n| Constant::Number(n)); + let hex = extension.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); + let bitpos = extension.bitpos.map(|bit| Constant::BitPos(bit)); + let expr = extension + .c_expression + .as_ref() + .map(|e| Constant::CExpr(e.clone())); + let text = extension.text.as_ref().map(|e| Constant::Text(e.clone())); + number.or(hex).or(bitpos).or(expr).or(text).expect("") + } +} + +pub trait ConstantExt {} +impl ConstantExt for vkxml::Constant {} pub trait FeatureExt { fn version_string(&self) -> String; } @@ -252,19 +320,109 @@ pub fn generate_typedef(typedef: &vkxml::Typedef) -> Tokens { let typedef_name = to_type_tokens(&typedef.name, None); let typedef_ty = to_type_tokens(&typedef.basetype, None); quote!{ - type #typedef_name = #typedef_ty; + pub type #typedef_name = #typedef_ty; } } pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Tokens { - println!("{:#?}", bitmask); - let ident = Ident::from(&bitmask.name[2..]); + let name = &bitmask.name[2..]; + let name_without_flags = name.replace("Flags", ""); + let ident = Ident::from(name); + let ident_without_flags = Ident::from(name_without_flags.as_str()); let type_token = to_type_tokens(&bitmask.basetype, None); quote!{ - vk_bitflags_wrapped!(#ident, 0b0, #type_token); + pub type #ident = BitFlags; } } -pub fn generate_enumeration(_enum: &vkxml::EnumerationDeclaration) -> Tokens { - quote!{} +pub fn to_variant_ident(enum_name: &str, variant_name: &str) -> Ident { + let tag = ["AMD", "NN", "KHR", "NV", "EXT", "NVX", "KHX"] + .iter() + .filter_map(|tag| { + if enum_name.ends_with(tag) { + Some(tag) + } else { + None + } + }) + .nth(0); + + let name_without_tag = tag.map(|t| enum_name.replace(t, "")) + .unwrap_or(enum_name.into()); + let variant_without_tag = tag.map(|t| variant_name.replace(t, "")) + .unwrap_or(variant_name.into()); + let camel_case_name_enum = &name_without_tag.to_camel_case(); + let name = variant_without_tag.to_camel_case()[2..].replace(camel_case_name_enum, ""); + let is_digit = name.chars().nth(0).map(|c| c.is_digit(10)).unwrap_or(false); + if is_digit { + Ident::from(format!("Type{}", name).as_str()) + } else { + Ident::from(name) + } +} + +pub enum EnumType { + Bitflags(Tokens), + Enum(Tokens), +} + +pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { + let name = &_enum.name[2..]; + let _name = name.replace("FlagBits", ""); + if name.contains("Bit") { + let variants = _enum.elements.iter().filter_map(|elem| { + let (variant_name, value) = match *elem { + vkxml::EnumerationElement::Enum(ref constant) => { + let c = Constant::from_constant(constant); + if c.value().map(|v| v == 0).unwrap_or(false) { + return None; + } + (constant.name.as_str(), c.to_tokens()) + } + _ => { + return None; + } + }; + + let variant_ident = to_variant_ident(&_name, variant_name); + Some(quote!{ + #variant_ident = #value + }) + }); + let ident = Ident::from(_name.as_str()); + let q = quote!{ + #[derive(Copy, Clone, Debug, EnumFlags)] + pub enum #ident { + #(#variants,)* + } + }; + EnumType::Bitflags(q) + } else { + let variants = _enum.elements.iter().filter_map(|elem| { + let (variant_name, value) = match *elem { + vkxml::EnumerationElement::Enum(ref constant) => { + let c = Constant::from_constant(constant); + println!("value {:?}", c.value()); + (constant.name.as_str(), c.to_tokens()) + } + _ => { + return None; + } + }; + + let variant_ident = to_variant_ident(&_name, variant_name); + Some(quote!{ + #variant_ident = #value + }) + }); + let ident = Ident::from(_name.as_str()); + let q = quote!{ + #[derive(Copy, Clone, Debug)] + #[repr(C)] + pub enum #ident { + #(#variants,)* + } + }; + EnumType::Enum(q) + } } pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { let name = Ident::from(&_struct.name[2..]); @@ -292,7 +450,6 @@ pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Tokens { match *definition { vkxml::DefinitionsElement::Typedef(ref typedef) => generate_typedef(typedef), vkxml::DefinitionsElement::Struct(ref _struct) => generate_struct(_struct), - vkxml::DefinitionsElement::Enumeration(ref _enum) => generate_enumeration(_enum), vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask), _ => quote!{}, } @@ -383,6 +540,42 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|definitions| definitions.elements.iter().map(|definition| definition)) .collect(); + let enums: Vec<&vkxml::Enumeration> = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Enums(ref enums) => Some(enums), + _ => None, + }) + .flat_map(|enums| { + enums.elements.iter().filter_map(|_enum| match *_enum { + vkxml::EnumsElement::Enumeration(ref e) => Some(e), + _ => None, + }) + }) + .collect(); + + let constants: Vec<&vkxml::Constant> = spec.elements + .iter() + .filter_map(|elem| match elem { + &vkxml::RegistryElement::Constants(ref constants) => Some(constants), + _ => None, + }) + .flat_map(|constants| constants.elements.iter()) + .collect(); + + //println!("{:#?}", constants); + + let (enum_code, bitflags_code) = enums.into_iter().map(generate_enum).fold( + (Vec::new(), Vec::new()), + |mut acc, elem| { + match elem { + EnumType::Enum(token) => acc.0.push(token), + EnumType::Bitflags(token) => acc.1.push(token), + }; + acc + }, + ); + let definition_code: Vec<_> = definitions.into_iter().map(generate_definition).collect(); let feature_code: Vec<_> = features @@ -394,11 +587,15 @@ pub fn write_source_code(spec: &vkxml::Registry) { .iter() .map(|ext| generate_extension(ext, &commands)) .collect(); - let mut file = File::create("vk_test.rs").expect("vk"); + let mut file = File::create("../ash/src/vk_test.rs").expect("vk"); let source_code = quote!{ //#(#feature_code)* //#(#extension_code)* - #(#definition_code)* + //#(#definition_code)* + //#(#enum_code)* + pub mod flags { + #(#bitflags_code)* + } }; write!(&mut file, "{}", source_code); } From dc378d7b9fed0004fae61aa5e3383f80b478dc90 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 4 Jun 2018 11:26:14 +0200 Subject: [PATCH 010/122] Move from vkxml to vk-parse --- Cargo.toml | 1 + ash/src/lib.rs | 6 +----- generator/Cargo.toml | 3 ++- generator/src/bin/generator.rs | 8 ++++---- generator/src/lib.rs | 31 ++++++++++++++++++------------- 5 files changed, 26 insertions(+), 23 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 39f44a5..4441300 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,4 +2,5 @@ members = [ "examples", "ash", + "generator", ] diff --git a/ash/src/lib.rs b/ash/src/lib.rs index 90df9b8..59b1a69 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -2,9 +2,6 @@ extern crate lazy_static; extern crate libc; extern crate shared_library; -extern crate enumflags; -#[macro_use] -extern crate enumflags_derive; pub use instance::{DeviceError, Instance}; pub use device::Device; pub use entry::{Entry, InstanceError, LoadingError}; @@ -14,11 +11,10 @@ mod device; mod entry; pub mod prelude; pub mod vk; -//mod allocator; pub mod extensions; pub mod version; pub mod util; -mod vk_test; +// mod vk_test; pub trait RawPtr { fn as_raw_ptr(&self) -> *const T; diff --git a/generator/Cargo.toml b/generator/Cargo.toml index 0142627..5b3356d 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -4,7 +4,8 @@ version = "0.1.0" authors = ["Maik Klein "] [dependencies] -vkxml = {path = "/home/maik/projects/vkxml"} +vk-parse = {git = "https://github.com/krolli/vk-parse"} +vkxml = {git = "https://github.com/terrybrashaw/vkxml"} #vkxml = {git = "https://github.com/maikklein/vkxml"} heck = "0.3.0" proc-macro2 = "0.2.3" diff --git a/generator/src/bin/generator.rs b/generator/src/bin/generator.rs index a1759c5..80a411f 100644 --- a/generator/src/bin/generator.rs +++ b/generator/src/bin/generator.rs @@ -1,13 +1,13 @@ #[macro_use] extern crate generator; -use std::fs::File; use generator::*; use std::collections::HashMap; +use std::fs::File; use std::io::Write; +use std::path::Path; fn main() { - let file = File::open("New-Vulkan-XML-Format/vk_new.xml").expect("vknew"); - let spec = vkxml::Registry::from_file(file).expect(""); + //let file = File::open("New-Vulkan-XML-Format/vk_new.xml").expect("vknew"); + let spec = vk_parse::parse_file_as_vkxml(Path::new("vk.xml")); write_source_code(&spec); - } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 152ab35..35da101 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -7,11 +7,12 @@ extern crate proc_macro2; #[macro_use] extern crate quote; extern crate syn; +pub extern crate vk_parse; pub extern crate vkxml; +use heck::{CamelCase, ShoutySnakeCase, SnakeCase}; use proc_macro2::Term; use quote::Tokens; -use heck::{CamelCase, ShoutySnakeCase, SnakeCase}; use syn::Ident; pub enum Constant { @@ -25,7 +26,7 @@ impl Constant { pub fn value(&self) -> Option { match *self { Constant::Number(n) => Some(n as i64), - Constant::Hex(ref hex) => Some(hex.parse().expect("hex parse")), + Constant::Hex(ref hex) => i64::from_str_radix(&hex, 16).ok(), Constant::BitPos(pos) => Some((1 << pos) as i64), _ => None, } @@ -37,7 +38,7 @@ impl Constant { quote!{#term} } Constant::Hex(ref s) => { - let term = Term::intern(s); + let term = Term::intern(&format!("0x{}", s)); quote!{#term} } Constant::Text(ref text) => { @@ -323,15 +324,19 @@ pub fn generate_typedef(typedef: &vkxml::Typedef) -> Tokens { pub type #typedef_name = #typedef_ty; } } -pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Tokens { +pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { + // Workaround for empty bitmask + if bitmask.name.len() == 0 { + return None; + } let name = &bitmask.name[2..]; let name_without_flags = name.replace("Flags", ""); let ident = Ident::from(name); let ident_without_flags = Ident::from(name_without_flags.as_str()); let type_token = to_type_tokens(&bitmask.basetype, None); - quote!{ + Some(quote!{ pub type #ident = BitFlags; - } + }) } pub fn to_variant_ident(enum_name: &str, variant_name: &str) -> Ident { let tag = ["AMD", "NN", "KHR", "NV", "EXT", "NVX", "KHX"] @@ -400,7 +405,7 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { let (variant_name, value) = match *elem { vkxml::EnumerationElement::Enum(ref constant) => { let c = Constant::from_constant(constant); - println!("value {:?}", c.value()); + //println!("value {:?}", c.value()); (constant.name.as_str(), c.to_tokens()) } _ => { @@ -446,12 +451,12 @@ pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { } } } -pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Tokens { +pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Option { match *definition { - vkxml::DefinitionsElement::Typedef(ref typedef) => generate_typedef(typedef), - vkxml::DefinitionsElement::Struct(ref _struct) => generate_struct(_struct), + vkxml::DefinitionsElement::Typedef(ref typedef) => Some(generate_typedef(typedef)), + vkxml::DefinitionsElement::Struct(ref _struct) => Some(generate_struct(_struct)), vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask), - _ => quote!{}, + _ => None, } } pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Tokens { @@ -502,8 +507,8 @@ pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> qu } pub fn write_source_code(spec: &vkxml::Registry) { - use std::io::Write; use std::fs::File; + use std::io::Write; let commands: HashMap = spec.elements .iter() .filter_map(|elem| match elem { @@ -576,7 +581,7 @@ pub fn write_source_code(spec: &vkxml::Registry) { }, ); - let definition_code: Vec<_> = definitions.into_iter().map(generate_definition).collect(); + let definition_code: Vec<_> = definitions.into_iter().filter_map(generate_definition).collect(); let feature_code: Vec<_> = features .iter() From 886d0f0c96266dea54ab7e9ada9155795568291e Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 5 Jun 2018 16:47:21 +0200 Subject: [PATCH 011/122] Use constants for bitflags --- ash/src/lib.rs | 1 + generator/Vulkan-Docs | 2 +- generator/src/lib.rs | 36 ++- generator/vk.xml | 731 +++++++++++++++++++++++++++++++----------- 4 files changed, 579 insertions(+), 191 deletions(-) diff --git a/ash/src/lib.rs b/ash/src/lib.rs index 59b1a69..79c3dcb 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -24,6 +24,7 @@ impl<'r, T> RawPtr for Option<&'r T> { fn as_raw_ptr(&self) -> *const T { match self { &Some(inner) => inner as *const T, + _ => ::std::ptr::null(), } } diff --git a/generator/Vulkan-Docs b/generator/Vulkan-Docs index ce60b9c..ee13fc3 160000 --- a/generator/Vulkan-Docs +++ b/generator/Vulkan-Docs @@ -1 +1 @@ -Subproject commit ce60b9c88745ecded74296dfbe69dae7c1fb2e62 +Subproject commit ee13fc355fae06ffcd36ee09a98f12132d95dfc0 diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 35da101..a738836 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -370,34 +370,47 @@ pub enum EnumType { } pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { + println!("{}", _enum.name); let name = &_enum.name[2..]; - let _name = name.replace("FlagBits", ""); + let _name = name.replace("FlagBits", "Flags"); if name.contains("Bit") { + let ident = Ident::from(_name.as_str()); + let all_bits = _enum + .elements + .iter() + .filter_map(|elem| match elem { + vkxml::EnumerationElement::Enum(ref constant) => { + let c = Constant::from_constant(constant); + c.value() + } + _ => None, + }) + .fold(0, |acc, next| acc | next); + let all_bits_term = Term::intern(&format!("0b{:b}", all_bits)); + let variants = _enum.elements.iter().filter_map(|elem| { let (variant_name, value) = match *elem { vkxml::EnumerationElement::Enum(ref constant) => { + let variant_name = &constant.name[3..]; let c = Constant::from_constant(constant); if c.value().map(|v| v == 0).unwrap_or(false) { return None; } - (constant.name.as_str(), c.to_tokens()) + (variant_name, c.to_tokens()) } _ => { return None; } }; - let variant_ident = to_variant_ident(&_name, variant_name); + let variant_ident = Ident::from(variant_name); Some(quote!{ - #variant_ident = #value + pub const #variant_ident: #ident = #ident { flags: #value }; }) }); - let ident = Ident::from(_name.as_str()); let q = quote!{ - #[derive(Copy, Clone, Debug, EnumFlags)] - pub enum #ident { - #(#variants,)* - } + #(#variants)* + vk_bitflags_wrapped!(#ident, #all_bits_term, Flags); }; EnumType::Bitflags(q) } else { @@ -581,7 +594,10 @@ pub fn write_source_code(spec: &vkxml::Registry) { }, ); - let definition_code: Vec<_> = definitions.into_iter().filter_map(generate_definition).collect(); + let definition_code: Vec<_> = definitions + .into_iter() + .filter_map(generate_definition) + .collect(); let feature_code: Vec<_> = features .iter() diff --git a/generator/vk.xml b/generator/vk.xml index 3d7a35b..7018bbe 100644 --- a/generator/vk.xml +++ b/generator/vk.xml @@ -15,8 +15,24 @@ 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. ------------------------------------------------------------------------- +---- Exceptions to the Apache 2.0 License: ---- +As an exception, if you use this Software to generate code and portions of +this Software are embedded into the generated code as a result, you may +redistribute such product without providing attribution as would otherwise +be required by Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link code generated by this Software with +software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1 +("`Combined Software`") and if a court of competent jurisdiction determines +that the patent provision (Section 3), the indemnity provision (Section 9) +or other Section of the License conflicts with the conditions of the +applicable GPL or LGPL license, you may retroactively and prospectively +choose to deem waived or otherwise exclude such Section(s) of the License, +but only in their entirety and only with respect to the Combined Software. + + + This file, vk.xml, is the Vulkan API Registry. It is a critically important and normative part of the Vulkan Specification, including a canonical machine-readable definition of the API, parameter and member validation @@ -24,7 +40,8 @@ language incorporated into the Specification and reference pages, and other material which is registered by Khronos, such as tags used by extension and layer authors. The authoritative public version of vk.xml is maintained in the master branch of the Khronos Vulkan GitHub project. The authoritative -private version is maintained in the 1.0 branch of the member gitlab server. +private version is maintained in the master branch of the member gitlab +server. @@ -49,30 +66,30 @@ private version is maintained in the 1.0 branch of the member gitlab server. - - - + + + - - + + - - - + + + - + - - + + - - + + @@ -136,7 +153,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. // Vulkan 1.1 version number #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 70 +#define VK_HEADER_VERSION 76 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -156,6 +173,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. struct ANativeWindow; + struct AHardwareBuffer; typedef uint32_t VkSampleMask; typedef uint32_t VkBool32; @@ -293,6 +311,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + typedef VkFlags VkDescriptorBindingFlagsEXT; Types which can be void pointers or class pointers, selected at compile time VK_DEFINE_HANDLE(VkInstance) @@ -424,6 +443,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. + Extensions @@ -543,6 +563,14 @@ private version is maintained in the 1.0 branch of the member gitlab server. void* pUserData); Struct types + + VkStructureType sType + struct VkBaseOutStructure* pNext + + + VkStructureType sType + const struct VkBaseInStructure* pNext + int32_t x int32_t y @@ -1406,7 +1434,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage fragment stage limits - uint32_t maxFragmentInputComponentsmax number of input compontents read in fragment stage + uint32_t maxFragmentInputComponentsmax number of input components read in fragment stage uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers @@ -1573,7 +1601,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display. VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in. VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. @@ -1686,7 +1714,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline @@ -1713,17 +1741,17 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation VkStructureType sType - const void* pNext + const void* pNext VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation VkStructureType sType - const void* pNext + const void* pNext VkImage imageImage that this allocation will be bound to VkBuffer bufferBuffer that this allocation will be bound to @@ -1757,7 +1785,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t acquireCount const VkDeviceMemory* pAcquireSyncs const uint64_t* pAcquireKeys @@ -1935,7 +1963,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount const VkPresentRegionKHR* pRegionsThe regions that have changed @@ -1963,7 +1991,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkExternalMemoryHandleTypeFlagBits handleType @@ -2059,7 +2087,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t acquireCount const VkDeviceMemory* pAcquireSyncs const uint64_t* pAcquireKeys @@ -2106,7 +2134,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t waitSemaphoreValuesCount const uint64_t* pWaitSemaphoreValues uint32_t signalSemaphoreValuesCount @@ -2259,7 +2287,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkMemoryAllocateFlags flags uint32_t deviceMask @@ -2298,7 +2326,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t deviceMask uint32_t deviceRenderAreaCount const VkRect2D* pDeviceRenderAreas @@ -2306,13 +2334,13 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t deviceMask VkStructureType sType - const void* pNext + const void* pNext uint32_t waitSemaphoreCount const uint32_t* pWaitSemaphoreDeviceIndices uint32_t commandBufferCount @@ -2323,7 +2351,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t resourceDeviceIndex uint32_t memoryDeviceIndex @@ -2336,12 +2364,12 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkSwapchainKHR swapchain VkStructureType sType - const void* pNext + const void* pNext VkSwapchainKHR swapchain uint32_t imageIndex @@ -2356,21 +2384,21 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t swapchainCount const uint32_t* pDeviceMasks VkDeviceGroupPresentModeFlagBitsKHR mode VkStructureType sType - const void* pNext + const void* pNext uint32_t physicalDeviceCount const VkPhysicalDevice* pPhysicalDevices VkStructureType sType - const void* pNext + const void* pNext VkDeviceGroupPresentModeFlagsKHR modes @@ -2426,7 +2454,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount const VkPresentTimeGOOGLE* pTimesThe earliest times to present images @@ -2452,7 +2480,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkBool32 viewportWScalingEnable uint32_t viewportCount const VkViewportWScalingNV* pViewportWScalings @@ -2516,6 +2544,32 @@ private version is maintained in the 1.0 branch of the member gitlab server. void* pNext VkSurfaceFormatKHR surfaceFormat + + VkStructureType sType + void* pNext + VkDisplayPropertiesKHR displayProperties + + + VkStructureType sType + void* pNext + VkDisplayPlanePropertiesKHR displayPlaneProperties + + + VkStructureType sType + void* pNext + VkDisplayModePropertiesKHR displayModeProperties + + + VkStructureType sType + const void* pNext + VkDisplayModeKHR mode + uint32_t planeIndex + + + VkStructureType sType + void* pNext + VkDisplayPlaneCapabilitiesKHR capabilities + VkStructureType sType void* pNext @@ -2602,7 +2656,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkSamplerYcbcrConversion conversion @@ -2621,13 +2675,13 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkImageAspectFlagBits planeAspect VkStructureType sType - const void* pNext + const void* pNext VkImageAspectFlagBits planeAspect @@ -2903,10 +2957,27 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkBool32 conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines VkBool32 degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized VkBool32 degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized - VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input - variable + VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable VkBool32 conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask + + VkStructureType sType + void* pNextPointer to next structure + uint32_t shaderEngineCountnumber of shader engines + uint32_t shaderArraysPerEngineCountnumber of shader arrays + uint32_t computeUnitsPerShaderArraynumber of CUs per shader array + uint32_t simdPerComputeUnitnumber of SIMDs per compute unit + uint32_t wavefrontsPerSimdnumber of wavefront slots in each SIMD + uint32_t wavefrontSizenumber of threads per wavefront + uint32_t sgprsPerSimdnumber of physical SGPRs per SIMD + uint32_t minSgprAllocationminimum number of SGPRs that can be allocated by a wave + uint32_t maxSgprAllocationnumber of available SGPRs + uint32_t sgprAllocationGranularitySGPRs are allocated in groups of this size + uint32_t vgprsPerSimdnumber of physical VGPRs per SIMD + uint32_t minVgprAllocationminimum number of VGPRs that can be allocated by a wave + uint32_t maxVgprAllocationnumber of available VGPRs + uint32_t vgprAllocationGranularityVGPRs are allocated in groups of this size + VkStructureType sType const void* pNext @@ -2914,13 +2985,81 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkConservativeRasterizationModeEXT conservativeRasterizationMode float extraPrimitiveOverestimationSize + + VkStructureType sType + void* pNext + VkBool32 shaderInputAttachmentArrayDynamicIndexing + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing + VkBool32 shaderUniformBufferArrayNonUniformIndexing + VkBool32 shaderSampledImageArrayNonUniformIndexing + VkBool32 shaderStorageBufferArrayNonUniformIndexing + VkBool32 shaderStorageImageArrayNonUniformIndexing + VkBool32 shaderInputAttachmentArrayNonUniformIndexing + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing + VkBool32 descriptorBindingUniformBufferUpdateAfterBind + VkBool32 descriptorBindingSampledImageUpdateAfterBind + VkBool32 descriptorBindingStorageImageUpdateAfterBind + VkBool32 descriptorBindingStorageBufferUpdateAfterBind + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind + VkBool32 descriptorBindingUpdateUnusedWhilePending + VkBool32 descriptorBindingPartiallyBound + VkBool32 descriptorBindingVariableDescriptorCount + VkBool32 runtimeDescriptorArray + + + VkStructureType sType + void* pNext + uint32_t maxUpdateAfterBindDescriptorsInAllPools + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative + VkBool32 shaderSampledImageArrayNonUniformIndexingNative + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative + VkBool32 shaderStorageImageArrayNonUniformIndexingNative + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative + VkBool32 robustBufferAccessUpdateAfterBind + VkBool32 quadDivergentImplicitLod + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments + uint32_t maxPerStageUpdateAfterBindResources + uint32_t maxDescriptorSetUpdateAfterBindSamplers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindSampledImages + uint32_t maxDescriptorSetUpdateAfterBindStorageImages + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments + + + VkStructureType sType + const void* pNext + uint32_t bindingCount + const VkDescriptorBindingFlagsEXT* pBindingFlags + + + VkStructureType sType + const void* pNext + uint32_t descriptorSetCount + const uint32_t* pDescriptorCounts + + + VkStructureType sType + void* pNext + uint32_t maxVariableDescriptorCount + uint32_t binding uint32_t divisor VkStructureType sType - const void* pNext + const void* pNext uint32_t vertexBindingDivisorCount const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors @@ -2929,6 +3068,44 @@ private version is maintained in the 1.0 branch of the member gitlab server. void* pNext uint32_t maxVertexAttribDivisormax value of vertex attribute divisor + + VkStructureType sType + const void* pNext + struct AHardwareBuffer* buffer + + + VkStructureType sType + void* pNext + uint64_t androidHardwareBufferUsage + + + VkStructureType sType + void* pNext + VkDeviceSize allocationSize + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + + + VkStructureType sType + void* pNext + VkFormat format + uint64_t externalFormat + VkFormatFeatureFlags formatFeatures + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + void* pNext + uint64_t externalFormat + Vulkan enumerant (token) definitions @@ -3996,6 +4173,12 @@ private version is maintained in the 1.0 branch of the member gitlab server. + + + + + + @@ -4482,7 +4665,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkDescriptorSetLayout descriptorSetLayout const VkAllocationCallbacks* pAllocator - + VkResult vkCreateDescriptorPool VkDevice device const VkDescriptorPoolCreateInfo* pCreateInfo @@ -5488,7 +5671,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. const VkAllocationCallbacks* pAllocator VkFence* pFence - + VkResult vkGetSwapchainCounterEXT VkDevice device VkSwapchainKHR swapchain @@ -5680,6 +5863,31 @@ private version is maintained in the 1.0 branch of the member gitlab server. uint32_t* pSurfaceFormatCount VkSurfaceFormat2KHR* pSurfaceFormats + + VkResult vkGetPhysicalDeviceDisplayProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayProperties2KHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlaneProperties2KHR* pProperties + + + VkResult vkGetDisplayModeProperties2KHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModeProperties2KHR* pProperties + + + VkResult vkGetDisplayPlaneCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo + VkDisplayPlaneCapabilities2KHR* pCapabilities + void vkGetBufferMemoryRequirements2 VkDevice device @@ -5862,6 +6070,38 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkDeviceSize dstOffset uint32_t marker + + VkResult vkGetAndroidHardwareBufferPropertiesANDROID + VkDevice device + const struct AHardwareBuffer* buffer + VkAndroidHardwareBufferPropertiesANDROID* pProperties + + + VkResult vkGetMemoryAndroidHardwareBufferANDROID + VkDevice device + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo + struct AHardwareBuffer** pBuffer + + + void vkCmdDrawIndirectCountKHR + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirectCountKHR + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + @@ -6086,6 +6326,8 @@ private version is maintained in the 1.0 branch of the member gitlab server. + + @@ -6417,7 +6659,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6432,7 +6674,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6508,7 +6750,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6519,7 +6761,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6530,7 +6772,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6541,7 +6783,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6552,7 +6794,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6563,7 +6805,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6574,7 +6816,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6586,7 +6828,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6607,27 +6849,27 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + @@ -6635,19 +6877,19 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + @@ -6656,25 +6898,25 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + @@ -6692,25 +6934,25 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + @@ -6722,43 +6964,43 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + - + - + - + @@ -6766,7 +7008,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6778,31 +7020,31 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + - + @@ -6816,7 +7058,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6826,25 +7068,25 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + @@ -6880,13 +7122,13 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + @@ -6899,7 +7141,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6946,7 +7188,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6954,7 +7196,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -6985,7 +7227,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7054,7 +7296,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7082,27 +7324,27 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + - + @@ -7112,7 +7354,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7202,7 +7444,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7273,7 +7515,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7287,21 +7529,19 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - - - + + - + - + @@ -7309,7 +7549,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7391,7 +7631,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7450,7 +7690,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7465,7 +7705,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7488,7 +7728,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7498,7 +7738,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7509,7 +7749,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7529,7 +7769,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7547,13 +7787,13 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + @@ -7573,7 +7813,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7625,7 +7865,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7648,7 +7888,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7659,7 +7899,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7673,7 +7913,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7736,7 +7976,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7744,10 +7984,24 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + + + + + + + + + + + + + @@ -7800,7 +8054,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7828,13 +8082,28 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + + + + + + + + + + + + + + - + @@ -7846,13 +8115,13 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + @@ -7882,7 +8151,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7900,7 +8169,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7918,7 +8187,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7941,7 +8210,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -7976,7 +8245,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -8036,7 +8305,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -8045,19 +8314,19 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + @@ -8067,14 +8336,14 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + @@ -8169,7 +8438,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -8188,7 +8457,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -8213,10 +8482,23 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + + + + + + + + + + + + @@ -8255,7 +8537,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -8266,31 +8548,33 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + - + - + - + - + @@ -8306,25 +8590,25 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + @@ -8341,68 +8625,70 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - + - + - + - + - + - + - - + + + + - + - + - + - + @@ -8449,11 +8735,96 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 9f14e404d7c208dec4d0fc4057eeaaf662dfdf17 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 24 Jun 2018 12:09:37 +0200 Subject: [PATCH 012/122] Impl cexpr --- ash/src/lib.rs | 3 +- generator/Cargo.toml | 5 +- generator/src/lib.rs | 495 +++++++++++++++++++++++++++++++++++++++---- 3 files changed, 456 insertions(+), 47 deletions(-) diff --git a/ash/src/lib.rs b/ash/src/lib.rs index 79c3dcb..863d6a5 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -14,8 +14,7 @@ pub mod vk; pub mod extensions; pub mod version; pub mod util; -// mod vk_test; - +mod vk_test; pub trait RawPtr { fn as_raw_ptr(&self) -> *const T; } diff --git a/generator/Cargo.toml b/generator/Cargo.toml index 5b3356d..dc33c66 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -7,8 +7,9 @@ authors = ["Maik Klein "] vk-parse = {git = "https://github.com/krolli/vk-parse"} vkxml = {git = "https://github.com/terrybrashaw/vkxml"} #vkxml = {git = "https://github.com/maikklein/vkxml"} -heck = "0.3.0" -proc-macro2 = "0.2.3" +nom = "4.0" +heck = "0.3" +proc-macro2 = "0.2" [dependencies.quote] version = "0.4.2" diff --git a/generator/src/lib.rs b/generator/src/lib.rs index a738836..16bba4f 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -2,6 +2,8 @@ // extern crate serde; // #[macro_use] // extern crate serde_derive; +#[macro_use] +extern crate nom; extern crate heck; extern crate proc_macro2; #[macro_use] @@ -11,10 +13,289 @@ pub extern crate vk_parse; pub extern crate vkxml; use heck::{CamelCase, ShoutySnakeCase, SnakeCase}; -use proc_macro2::Term; +use proc_macro2::{Term, TokenTree}; use quote::Tokens; +use std::collections::HashMap; use syn::Ident; +#[derive(Copy, Clone, Debug)] +pub enum CType { + USize, + U32, + U64, + Float, +} +impl CType { + fn to_tokens(&self) -> Tokens { + let term = match self { + CType::USize => Term::intern("usize"), + CType::U32 => Term::intern("u32"), + CType::U64 => Term::intern("u64"), + CType::Float => Term::intern("f32"), + }; + quote!{#term} + } +} + +named!(ctype<&str, CType>, + alt!( + tag!("ULL") => { |_| CType::U64 } | + tag!("U") => { |_| CType::U32 } + ) +); +named!(cexpr<&str, (CType, String)>, + alt!( + map!(cfloat, |f| (CType::Float, format!("{:.2}", f))) | + inverse_number + ) +); + +named!(inverse_number<&str, (CType, String)>, + do_parse!( + tag!("(")>> + tag!("~") >> + s: take_while1!(|c: char| c.is_digit(10)) >> + ctype: ctype >> + minus_num: opt!( + do_parse!( + tag!("-") >> + n: take_while1!(|c: char| c.is_digit(10)) >> + (n) + ) + ) >> + tag!(")") >> + ( + { + let expr = if let Some(minus) = minus_num { + format!("!{}-{}", s, minus) + } + else{ + format!("!{}", s) + }; + (ctype, expr) + } + ) + ) +); + +named!(cfloat<&str, f32>, + terminated!(nom::float_s, char!('f')) +); + +pub fn define_handle_macro() -> Tokens { + quote! { + macro_rules! define_handle{ + ($name: ident) => { + #[derive(Clone, Copy, Debug)] + #[repr(C)] + pub struct $name{ + ptr: *mut u8 + } + + unsafe impl Send for $name {} + unsafe impl Sync for $name {} + + impl $name{ + pub unsafe fn null() -> Self{ + $name{ + ptr: ::std::ptr::null_mut() + } + } + } + } + } + } +} + +pub fn handle_nondispatchable_macro() -> Tokens { + quote!{ + macro_rules! handle_nondispatchable { + ($name: ident) => { + #[repr(C)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] + pub struct $name (uint64_t); + + impl $name{ + pub fn null() -> $name{ + $name(0) + } + } + impl ::std::fmt::Pointer for $name { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + write!(f, "0x{:x}", self.0) + } + } + + impl ::std::fmt::Debug for $name { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + write!(f, "0x{:x}", self.0) + } + } + } + } + } +} +pub fn vk_bitflags_wrapped_macro() -> Tokens { + quote!{ + macro_rules! vk_bitflags_wrapped { + ($name: ident, $all: expr, $flag_type: ty) => { + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct $name {flags: $flag_type} + + impl Default for $name{ + fn default() -> $name { + $name {flags: 0} + } + } + impl ::std::fmt::Debug for $name { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + write!(f, "{}({:b})", stringify!($name), self.flags) + } + } + + impl $name { + #[inline] + pub fn empty() -> $name { + $name {flags: 0} + } + + #[inline] + pub fn all() -> $name { + $name {flags: $all} + } + + #[inline] + pub fn flags(self) -> $flag_type { + self.flags + } + + #[inline] + pub fn from_flags(flags: $flag_type) -> Option<$name> { + if flags & !$all == 0 { + Some($name {flags: flags}) + } else { + None + } + } + + #[inline] + pub fn from_flags_truncate(flags: $flag_type) -> $name { + $name {flags: flags & $all} + } + + #[inline] + pub fn is_empty(self) -> bool { + self == $name::empty() + } + + #[inline] + pub fn is_all(self) -> bool { + self & $name::all() == $name::all() + } + + #[inline] + pub fn intersects(self, other: $name) -> bool { + self & other != $name::empty() + } + + /// Returns true of `other` is a subset of `self` + #[inline] + pub fn subset(self, other: $name) -> bool { + self & other == other + } + } + + impl ::std::ops::BitOr for $name { + type Output = $name; + + #[inline] + fn bitor(self, rhs: $name) -> $name { + $name {flags: self.flags | rhs.flags } + } + } + + impl ::std::ops::BitOrAssign for $name { + #[inline] + fn bitor_assign(&mut self, rhs: $name) { + *self = *self | rhs + } + } + + impl ::std::ops::BitAnd for $name { + type Output = $name; + + #[inline] + fn bitand(self, rhs: $name) -> $name { + $name {flags: self.flags & rhs.flags} + } + } + + impl ::std::ops::BitAndAssign for $name { + #[inline] + fn bitand_assign(&mut self, rhs: $name) { + *self = *self & rhs + } + } + + impl ::std::ops::BitXor for $name { + type Output = $name; + + #[inline] + fn bitxor(self, rhs: $name) -> $name { + $name {flags: self.flags ^ rhs.flags} + } + } + + impl ::std::ops::BitXorAssign for $name { + #[inline] + fn bitxor_assign(&mut self, rhs: $name) { + *self = *self ^ rhs + } + } + + impl ::std::ops::Sub for $name { + type Output = $name; + + #[inline] + fn sub(self, rhs: $name) -> $name { + self & !rhs + } + } + + impl ::std::ops::SubAssign for $name { + #[inline] + fn sub_assign(&mut self, rhs: $name) { + *self = *self - rhs + } + } + + impl ::std::ops::Not for $name { + type Output = $name; + + #[inline] + fn not(self) -> $name { + self ^ $name::all() + } + } + } + } + } +} +#[derive(Debug, Copy, Clone)] +pub enum ConstVal { + U32(u32), + U64(u64), + Float(f32), +} +impl ConstVal { + pub fn bits(&self) -> u64 { + match self { + ConstVal::U64(n) => *n, + _ => panic!("Constval not supported"), + } + } +} pub enum Constant { Number(i32), Hex(String), @@ -22,15 +303,39 @@ pub enum Constant { CExpr(vkxml::CExpression), Text(String), } +impl quote::ToTokens for ConstVal { + fn to_tokens(&self, tokens: &mut Tokens) { + match self { + ConstVal::U32(n) => n.to_tokens(tokens), + ConstVal::U64(n) => n.to_tokens(tokens), + ConstVal::Float(f) => f.to_tokens(tokens), + } + } +} impl Constant { - pub fn value(&self) -> Option { + // pub fn type(&self) -> Type { + + // } + pub fn value(&self) -> Option { match *self { - Constant::Number(n) => Some(n as i64), - Constant::Hex(ref hex) => i64::from_str_radix(&hex, 16).ok(), - Constant::BitPos(pos) => Some((1 << pos) as i64), + Constant::Number(n) => Some(ConstVal::U64(n as u64)), + Constant::Hex(ref hex) => u64::from_str_radix(&hex, 16).ok().map(ConstVal::U64), + Constant::BitPos(pos) => Some(ConstVal::U64((1 << pos) as u64)), _ => None, } } + + pub fn ty(&self) -> CType { + match self { + Constant::Number(_) | Constant::Hex(_) => CType::USize, + Constant::CExpr(expr) => { + let (_, (ty, _)) = cexpr(expr).expect("Unable to parse cexpr"); + ty + } + _ => unimplemented!(), + } + } + pub fn to_tokens(&self) -> Tokens { match *self { Constant::Number(n) => { @@ -44,9 +349,9 @@ impl Constant { Constant::Text(ref text) => { quote!{#text} } - Constant::CExpr(ref cexpr) => { - let rexpr = cexpr.replace("~", "!").replace("U", "u32"); - let term = Term::intern(&rexpr); + Constant::CExpr(ref expr) => { + let (_, (_, rexpr)) = cexpr(expr).expect("Unable to parse cexpr"); + let term = Term::intern(rexpr.as_str()); quote!{#term} } Constant::BitPos(pos) => { @@ -127,36 +432,60 @@ pub trait FieldExt { /// Returns the basetype ident and removes the 'Vk' prefix fn type_tokens(&self) -> Tokens; + fn is_clone(&self) -> bool; } -fn to_type_tokens(type_name: &str, reference: Option<&vkxml::ReferenceType>) -> Tokens { +pub trait ToTokens { + fn to_tokens(&self) -> Tokens; +} +impl ToTokens for vkxml::ReferenceType { + fn to_tokens(&self) -> Tokens { + let ptr_name = match self { + vkxml::ReferenceType::Pointer => "*mut", + vkxml::ReferenceType::PointerToPointer => "*mut", + vkxml::ReferenceType::PointerToConstPointer => "*const", + }; + let ident = Term::intern(ptr_name); + quote!{ + #ident + } + } +} +fn name_to_tokens(type_name: &str) -> Tokens { let new_name = match type_name { + "HANDLE" => "*const c_void", + "LPCWSTR" => "*const wchar_t", + "DWORD" => "c_uint", + "int" => "c_int", "void" => "c_void", "char" => "c_char", "float" => "c_float", "long" => "c_ulong", _ => { - let prefix = &type_name[0..2]; - if prefix == "Vk" { + if type_name.starts_with("Vk") { &type_name[2..] } else { type_name } } }; - let ptr_name = reference - .as_ref() - .map(|reference| match *reference { - &vkxml::ReferenceType::Pointer => "*mut", - &vkxml::ReferenceType::PointerToPointer => "*mut", - &vkxml::ReferenceType::PointerToConstPointer => "*const", - }) - .unwrap_or(""); - let ty: syn::Type = syn::parse_str(&format!("{} {}", ptr_name, new_name)).expect("parse field"); - quote!{#ty} + let new_name = new_name.replace("FlagBits", "Flags"); + let name = Term::intern(new_name.as_str()); + quote! { + #name + } +} +fn to_type_tokens(type_name: &str, reference: Option<&vkxml::ReferenceType>) -> Tokens { + let new_name = name_to_tokens(type_name); + let ptr_name = reference.map(|r| r.to_tokens()).unwrap_or(quote!{}); + // let ty: syn::Type = syn::parse_str(&format!("{} {}", ptr_name, new_name)).expect("parse field"); + quote!{#ptr_name #new_name} } impl FieldExt for vkxml::Field { + fn is_clone(&self) -> bool { + true + } fn param_ident(&self) -> Ident { let name = self.name.as_ref().map(|s| s.as_str()).unwrap_or("field"); let name_corrected = match name { @@ -167,10 +496,31 @@ impl FieldExt for vkxml::Field { } fn type_tokens(&self) -> Tokens { - to_type_tokens(&self.basetype, self.reference.as_ref()) + let ty = name_to_tokens(&self.basetype); + let pointer = self.reference + .as_ref() + .map(|r| r.to_tokens()) + .unwrap_or(quote!{}); + let pointer_ty = quote!{ + #pointer #ty + }; + let array = self.array.as_ref().and_then(|arraytype| match arraytype { + vkxml::ArrayType::Static => { + let size = self.size + .as_ref() + .or(self.size_enumref.as_ref()) + .expect("Should have size"); + let size = Term::intern(size); + Some(quote!{ + [#ty; #size] + }) + } + _ => None, + }); + array.unwrap_or(pointer_ty) } } -use std::collections::HashMap; + pub type CommandMap<'a> = HashMap; fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quote::Tokens { @@ -241,7 +591,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo unsafe impl Sync for #ident {} impl ::std::clone::Clone for #ident { - pub fn clone(&self) -> Self { + fn clone(&self) -> Self { #ident{ #(#names_left: self.#names_right,)* } @@ -277,7 +627,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo } #( - pub fn #names_ref(#expanded_params_ref) -> #return_types_ref { + pub fn #names_ref(&self, #expanded_params_ref) -> #return_types_ref { (self.#names_left)(#(#param_names_ref,)*) } )* @@ -329,13 +679,15 @@ pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { if bitmask.name.len() == 0 { return None; } + // If this enum has constants, then it will generated later in generate_enums. + if bitmask.enumref.is_some() { + return None; + } + let name = &bitmask.name[2..]; - let name_without_flags = name.replace("Flags", ""); let ident = Ident::from(name); - let ident_without_flags = Ident::from(name_without_flags.as_str()); - let type_token = to_type_tokens(&bitmask.basetype, None); Some(quote!{ - pub type #ident = BitFlags; + vk_bitflags_wrapped!(#ident, 0b0, Flags); }) } pub fn to_variant_ident(enum_name: &str, variant_name: &str) -> Ident { @@ -370,7 +722,6 @@ pub enum EnumType { } pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { - println!("{}", _enum.name); let name = &_enum.name[2..]; let _name = name.replace("FlagBits", "Flags"); if name.contains("Bit") { @@ -385,7 +736,7 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { } _ => None, }) - .fold(0, |acc, next| acc | next); + .fold(0, |acc, next| acc | next.bits()); let all_bits_term = Term::intern(&format!("0b{:b}", all_bits)); let variants = _enum.elements.iter().filter_map(|elem| { @@ -393,7 +744,7 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { vkxml::EnumerationElement::Enum(ref constant) => { let variant_name = &constant.name[3..]; let c = Constant::from_constant(constant); - if c.value().map(|v| v == 0).unwrap_or(false) { + if c.value().map(|v| v.bits() == 0).unwrap_or(false) { return None; } (variant_name, c.to_tokens()) @@ -442,8 +793,9 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { EnumType::Enum(q) } } +pub trait StructExt {} pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { - let name = Ident::from(&_struct.name[2..]); + let name = to_type_tokens(&_struct.name, None); let params = _struct .elements .iter() @@ -457,18 +809,56 @@ pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { quote!{pub #param_ident: #param_ty_tokens} }); quote!{ - #[derive(Clone, Debug)] + //#[derive(Clone, Debug)] #[repr(C)] pub struct #name { #(#params,)* } } } + +pub fn generate_handle(handle: &vkxml::Handle) -> Option { + if handle.name == "" { + return None; + } + let tokens = match handle.ty { + vkxml::HandleType::Dispatch => { + let name = &handle.name[2..]; + let name = Ident::from(name); + quote! { + define_handle!(#name); + } + } + vkxml::HandleType::NoDispatch => { + let name = &handle.name[2..]; + let name = Ident::from(name); + quote! { + handle_nondispatchable!(#name); + } + } + }; + Some(tokens) +} +fn generate_funcptr(fnptr: &vkxml::FunctionPointer) -> Tokens { + println!("{:#?}", fnptr); + let name = Ident::from(fnptr.name.as_str()); + let ret_ty_tokens = fnptr.return_type.type_tokens(); + quote!{ + pub type #name = unsafe extern "system" fn() -> #ret_ty_tokens; + } +} +fn generate_union(union: &vkxml::Union) -> Tokens { + println!("{:#?}", union); + quote!{} +} pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Option { match *definition { vkxml::DefinitionsElement::Typedef(ref typedef) => Some(generate_typedef(typedef)), vkxml::DefinitionsElement::Struct(ref _struct) => Some(generate_struct(_struct)), vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask), + vkxml::DefinitionsElement::Handle(ref handle) => generate_handle(handle), + vkxml::DefinitionsElement::FuncPtr(ref fp) => Some(generate_funcptr(fp)), + vkxml::DefinitionsElement::Union(ref union) => Some(generate_union(union)), _ => None, } } @@ -518,10 +908,20 @@ pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> qu #device } } +pub fn generate_constant(constant: &vkxml::Constant) -> Tokens { + let c = Constant::from_constant(constant); + let ident = Ident::from(constant.name.as_str()); + let value = c.to_tokens(); + let ty = c.ty().to_tokens(); + quote!{ + pub const #ident: #ty = #value; + } +} pub fn write_source_code(spec: &vkxml::Registry) { use std::fs::File; use std::io::Write; + println!("{:#?}", spec); let commands: HashMap = spec.elements .iter() .filter_map(|elem| match elem { @@ -581,8 +981,6 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|constants| constants.elements.iter()) .collect(); - //println!("{:#?}", constants); - let (enum_code, bitflags_code) = enums.into_iter().map(generate_enum).fold( (Vec::new(), Vec::new()), |mut acc, elem| { @@ -608,15 +1006,26 @@ pub fn write_source_code(spec: &vkxml::Registry) { .iter() .map(|ext| generate_extension(ext, &commands)) .collect(); + let constants_code: Vec<_> = constants + .iter() + .map(|constant| generate_constant(constant)) + .collect(); let mut file = File::create("../ash/src/vk_test.rs").expect("vk"); + let bitflags_macro = vk_bitflags_wrapped_macro(); + let handle_nondispatchable_macro = handle_nondispatchable_macro(); + let define_handle_macro = define_handle_macro(); let source_code = quote!{ - //#(#feature_code)* - //#(#extension_code)* - //#(#definition_code)* - //#(#enum_code)* - pub mod flags { - #(#bitflags_code)* - } + use libc::*; + // #bitflags_macro + // #handle_nondispatchable_macro + // #define_handle_macro + // #(#feature_code)* + // #(#extension_code)* + // #(#definition_code)* + // #(#enum_code)* + // #(#bitflags_code)* + #(#constants_code)* }; + println!("{:?}", cexpr("(~0UL)")); write!(&mut file, "{}", source_code); } From 4584a8af2a72ddb93354d2599d59b32e62088151 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 7 Jul 2018 10:43:05 +0200 Subject: [PATCH 013/122] Add custom Result impl --- generator/src/lib.rs | 107 +++++++++++++++++++++++++++++++++---------- 1 file changed, 84 insertions(+), 23 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 16bba4f..de055a3 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -765,34 +765,95 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { }; EnumType::Bitflags(q) } else { - let variants = _enum.elements.iter().filter_map(|elem| { - let (variant_name, value) = match *elem { - vkxml::EnumerationElement::Enum(ref constant) => { - let c = Constant::from_constant(constant); - //println!("value {:?}", c.value()); - (constant.name.as_str(), c.to_tokens()) - } - _ => { - return None; - } - }; + let q = match _name.as_str() { + "Result" => generate_result(&_name, _enum), + _ => { + let ident = Ident::from(_name.as_str()); + let variants = _enum.elements.iter().filter_map(|elem| { + let (variant_name, value) = match *elem { + vkxml::EnumerationElement::Enum(ref constant) => { + let c = Constant::from_constant(constant); + //println!("value {:?}", c.value()); + (constant.name.as_str(), c.to_tokens()) + } + _ => { + return None; + } + }; - let variant_ident = to_variant_ident(&_name, variant_name); - Some(quote!{ - #variant_ident = #value - }) - }); - let ident = Ident::from(_name.as_str()); - let q = quote!{ - #[derive(Copy, Clone, Debug)] - #[repr(C)] - pub enum #ident { - #(#variants,)* + let variant_ident = to_variant_ident(&_name, variant_name); + Some(quote!{ + #variant_ident = #value + }) + }); + quote!{ + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + #[repr(C)] + pub enum #ident { + #(#variants,)* + } + } } }; EnumType::Enum(q) } } +pub fn generate_result(name: &str, _enum: &vkxml::Enumeration) -> Tokens { + let ident = Ident::from(name); + let variants = _enum.elements.iter().filter_map(|elem| { + let (variant_name, value) = match *elem { + vkxml::EnumerationElement::Enum(ref constant) => { + let c = Constant::from_constant(constant); + //println!("value {:?}", c.value()); + (constant.name.as_str(), c.to_tokens()) + } + _ => { + return None; + } + }; + let variant_ident = to_variant_ident(&name, variant_name); + Some(quote!{ + #variant_ident = #value + }) + }); + let notation = _enum.elements.iter().filter_map(|elem| { + let (variant_name, notation) = match *elem { + vkxml::EnumerationElement::Enum(ref constant) => ( + constant.name.as_str(), + constant.notation.as_ref().map(|s| s.as_str()).unwrap_or(""), + ), + _ => { + return None; + } + }; + + let variant_ident = to_variant_ident(&name, variant_name); + Some(quote!{ + #ident::#variant_ident => write!(fmt, #notation) + }) + }); + + quote!{ + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + #[repr(C)] + pub enum #ident { + #(#variants,)* + } + impl ::std::error::Error for #ident { + fn description(&self) -> &str { + "vk::Result" + } + } + impl ::std::fmt::Display for #ident { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + writeln!(fmt, "vk::Result::{:?}", self)?; + match self { + #(#notation),* + } + } + } + } +} pub trait StructExt {} pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { let name = to_type_tokens(&_struct.name, None); @@ -809,7 +870,7 @@ pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { quote!{pub #param_ident: #param_ty_tokens} }); quote!{ - //#[derive(Clone, Debug)] + #[derive(Copy, Clone)] #[repr(C)] pub struct #name { #(#params,)* From 21e934d5b1ff5d12ebd3f1d6246c38fb50810c02 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 7 Jul 2018 10:43:44 +0200 Subject: [PATCH 014/122] Add unions --- generator/src/lib.rs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index de055a3..37a9e31 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -908,9 +908,23 @@ fn generate_funcptr(fnptr: &vkxml::FunctionPointer) -> Tokens { pub type #name = unsafe extern "system" fn() -> #ret_ty_tokens; } } + fn generate_union(union: &vkxml::Union) -> Tokens { - println!("{:#?}", union); - quote!{} + let name = to_type_tokens(&union.name, None); + let fields = union.elements.iter().map(|field| { + let name = field.param_ident(); + let ty = field.type_tokens(); + quote!{ + pub #name: #ty + } + }); + quote!{ + #[repr(C)] + #[derive(Copy, Clone)] + pub union #name { + #(#fields),* + } + } } pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Option { match *definition { From ad24467c95dc28ba455f5ff9db54577a20752bc1 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 7 Jul 2018 12:13:23 +0200 Subject: [PATCH 015/122] Rename the extension functionm pointers --- ash/src/extensions/android_surface.rs | 10 +++---- ash/src/extensions/debug_marker.rs | 11 +++---- ash/src/extensions/debug_report.rs | 10 +++---- ash/src/extensions/display_swapchain.rs | 10 +++---- ash/src/extensions/ios_surface.rs | 10 +++---- ash/src/extensions/macos_surface.rs | 14 ++++----- ash/src/extensions/mir_surface.rs | 10 +++---- ash/src/extensions/mod.rs | 40 ++++++++++++------------- ash/src/extensions/surface.rs | 18 ++++++----- ash/src/extensions/swapchain.rs | 12 ++++---- ash/src/extensions/wayland_surface.rs | 10 +++---- ash/src/extensions/win32_surface.rs | 10 +++---- ash/src/extensions/xcb_surface.rs | 10 +++---- ash/src/extensions/xlib_surface.rs | 10 +++---- 14 files changed, 94 insertions(+), 91 deletions(-) diff --git a/ash/src/extensions/android_surface.rs b/ash/src/extensions/android_surface.rs index ec6869c..a56cf08 100644 --- a/ash/src/extensions/android_surface.rs +++ b/ash/src/extensions/android_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct AndroidSurface { handle: vk::Instance, - android_surface_fn: vk::AndroidSurfaceFn, + android_surface_fn: vk::KhrAndroidSurfaceFn, } impl AndroidSurface { @@ -17,7 +17,7 @@ impl AndroidSurface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::AndroidSurfaceFn::load(|name| unsafe { + let surface_fn = vk::KhrAndroidSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(AndroidSurface { diff --git a/ash/src/extensions/debug_marker.rs b/ash/src/extensions/debug_marker.rs index 874a238..13a9d33 100644 --- a/ash/src/extensions/debug_marker.rs +++ b/ash/src/extensions/debug_marker.rs @@ -1,13 +1,13 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; +use std::mem; use version::{DeviceV1_0, InstanceV1_0}; +use vk; #[derive(Clone)] pub struct DebugMarker { - debug_marker_fn: vk::DebugMarkerFn, + debug_marker_fn: vk::ExtDebugMarkerFn, } impl DebugMarker { @@ -15,7 +15,7 @@ impl DebugMarker { instance: &I, device: &D, ) -> Result> { - let debug_marker_fn = vk::DebugMarkerFn::load(|name| unsafe { + let debug_marker_fn = vk::ExtDebugMarkerFn::load(|name| unsafe { mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) })?; Ok(DebugMarker { @@ -32,7 +32,8 @@ impl DebugMarker { device: vk::Device, name_info: &vk::DebugMarkerObjectNameInfoEXT, ) -> VkResult<()> { - let err_code = self.debug_marker_fn + let err_code = self + .debug_marker_fn .debug_marker_set_object_name_ext(device, name_info); match err_code { vk::Result::Success => Ok(()), diff --git a/ash/src/extensions/debug_report.rs b/ash/src/extensions/debug_report.rs index 1fd3f8c..335e248 100644 --- a/ash/src/extensions/debug_report.rs +++ b/ash/src/extensions/debug_report.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct DebugReport { handle: vk::Instance, - debug_report_fn: vk::DebugReportFn, + debug_report_fn: vk::ExtDebugReportFn, } impl DebugReport { @@ -17,7 +17,7 @@ impl DebugReport { entry: &E, instance: &I, ) -> Result> { - let debug_report_fn = vk::DebugReportFn::load(|name| unsafe { + let debug_report_fn = vk::ExtDebugReportFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(DebugReport { diff --git a/ash/src/extensions/display_swapchain.rs b/ash/src/extensions/display_swapchain.rs index 3fb0a22..1798f8d 100644 --- a/ash/src/extensions/display_swapchain.rs +++ b/ash/src/extensions/display_swapchain.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{DeviceV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct DisplaySwapchain { handle: vk::Device, - swapchain_fn: vk::DisplaySwapchainFn, + swapchain_fn: vk::KhrDisplaySwapchainFn, } impl DisplaySwapchain { @@ -17,7 +17,7 @@ impl DisplaySwapchain { instance: &I, device: &D, ) -> Result> { - let swapchain_fn = vk::DisplaySwapchainFn::load(|name| unsafe { + let swapchain_fn = vk::KhrDisplaySwapchainFn::load(|name| unsafe { mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) })?; Ok(DisplaySwapchain { diff --git a/ash/src/extensions/ios_surface.rs b/ash/src/extensions/ios_surface.rs index 1c477b0..4a89c68 100644 --- a/ash/src/extensions/ios_surface.rs +++ b/ash/src/extensions/ios_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct IOSSurface { handle: vk::Instance, - ios_surface_fn: vk::IOSSurfaceFn, + ios_surface_fn: vk::MvkIosSurfaceFn, } impl IOSSurface { @@ -17,7 +17,7 @@ impl IOSSurface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::IOSSurfaceFn::load(|name| unsafe { + let surface_fn = vk::MvkIosSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(IOSSurface { diff --git a/ash/src/extensions/macos_surface.rs b/ash/src/extensions/macos_surface.rs index ed8abba..e9cb705 100644 --- a/ash/src/extensions/macos_surface.rs +++ b/ash/src/extensions/macos_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct MacOSSurface { handle: vk::Instance, - macos_surface_fn: vk::MacOSSurfaceFn, + macos_surface_fn: vk::MvkMacosSurfaceFn, } impl MacOSSurface { @@ -17,7 +17,7 @@ impl MacOSSurface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::MacOSSurfaceFn::load(|name| unsafe { + let surface_fn = vk::MvkMacosSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(MacOSSurface { @@ -30,13 +30,13 @@ impl MacOSSurface { CStr::from_bytes_with_nul(b"VK_MVK_macos_surface\0").expect("Wrong extension string") } - pub unsafe fn create_macos_surface_mvk( + pub unsafe fn create_mac_os_surface_mvk( &self, create_info: &vk::MacOSSurfaceCreateInfoMVK, allocation_callbacks: Option<&vk::AllocationCallbacks>, ) -> VkResult { let mut surface = mem::uninitialized(); - let err_code = self.macos_surface_fn.create_macos_surface_mvk( + let err_code = self.macos_surface_fn.create_mac_os_surface_mvk( self.handle, create_info, allocation_callbacks.as_raw_ptr(), diff --git a/ash/src/extensions/mir_surface.rs b/ash/src/extensions/mir_surface.rs index 679dd43..0281a5f 100644 --- a/ash/src/extensions/mir_surface.rs +++ b/ash/src/extensions/mir_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct MirSurface { handle: vk::Instance, - mir_surface_fn: vk::MirSurfaceFn, + mir_surface_fn: vk::KhrMirSurfaceFn, } impl MirSurface { @@ -17,7 +17,7 @@ impl MirSurface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::MirSurfaceFn::load(|name| unsafe { + let surface_fn = vk::KhrMirSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(MirSurface { diff --git a/ash/src/extensions/mod.rs b/ash/src/extensions/mod.rs index b5f2a14..cab1e06 100644 --- a/ash/src/extensions/mod.rs +++ b/ash/src/extensions/mod.rs @@ -1,27 +1,27 @@ -pub use self::swapchain::Swapchain; -pub use self::display_swapchain::DisplaySwapchain; -pub use self::surface::Surface; -pub use self::xlib_surface::XlibSurface; +pub use self::android_surface::AndroidSurface; pub use self::debug_marker::DebugMarker; pub use self::debug_report::DebugReport; -pub use self::win32_surface::Win32Surface; -pub use self::mir_surface::MirSurface; -pub use self::xcb_surface::XcbSurface; -pub use self::wayland_surface::WaylandSurface; -pub use self::android_surface::AndroidSurface; -pub use self::macos_surface::MacOSSurface; +pub use self::display_swapchain::DisplaySwapchain; pub use self::ios_surface::IOSSurface; +pub use self::macos_surface::MacOSSurface; +pub use self::mir_surface::MirSurface; +pub use self::surface::Surface; +pub use self::swapchain::Swapchain; +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 swapchain; -mod display_swapchain; -mod surface; -mod xlib_surface; -mod win32_surface; +mod android_surface; mod debug_marker; mod debug_report; -mod mir_surface; -mod android_surface; -mod wayland_surface; -mod xcb_surface; -mod macos_surface; +mod display_swapchain; mod ios_surface; +mod macos_surface; +mod mir_surface; +mod surface; +mod swapchain; +mod wayland_surface; +mod win32_surface; +mod xcb_surface; +mod xlib_surface; diff --git a/ash/src/extensions/surface.rs b/ash/src/extensions/surface.rs index 1c8f5c6..c8db6b6 100644 --- a/ash/src/extensions/surface.rs +++ b/ash/src/extensions/surface.rs @@ -1,16 +1,16 @@ #![allow(dead_code)] use prelude::*; -use std::ptr; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; +use std::ptr; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct Surface { handle: vk::Instance, - surface_fn: vk::SurfaceFn, + surface_fn: vk::KhrSurfaceFn, } impl Surface { @@ -18,7 +18,7 @@ impl Surface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::SurfaceFn::load(|name| unsafe { + let surface_fn = vk::KhrSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(Surface { @@ -63,7 +63,8 @@ impl Surface { ptr::null_mut(), ); let mut v = Vec::with_capacity(count as usize); - let err_code = self.surface_fn + let err_code = self + .surface_fn .get_physical_device_surface_present_modes_khr( physical_device, surface, @@ -85,7 +86,8 @@ impl Surface { ) -> VkResult { unsafe { let mut surface_capabilities = mem::uninitialized(); - let err_code = self.surface_fn + let err_code = self + .surface_fn .get_physical_device_surface_capabilities_khr( physical_device, surface, diff --git a/ash/src/extensions/swapchain.rs b/ash/src/extensions/swapchain.rs index 988c324..7d120bd 100644 --- a/ash/src/extensions/swapchain.rs +++ b/ash/src/extensions/swapchain.rs @@ -1,16 +1,16 @@ #![allow(dead_code)] use prelude::*; -use std::ptr; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; +use std::ptr; use version::{DeviceV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct Swapchain { handle: vk::Device, - swapchain_fn: vk::SwapchainFn, + swapchain_fn: vk::KhrSwapchainFn, } impl Swapchain { @@ -18,7 +18,7 @@ impl Swapchain { instance: &I, device: &D, ) -> Result> { - let swapchain_fn = vk::SwapchainFn::load(|name| unsafe { + let swapchain_fn = vk::KhrSwapchainFn::load(|name| unsafe { mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) })?; Ok(Swapchain { diff --git a/ash/src/extensions/wayland_surface.rs b/ash/src/extensions/wayland_surface.rs index 855b7df..6c96fcc 100644 --- a/ash/src/extensions/wayland_surface.rs +++ b/ash/src/extensions/wayland_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct WaylandSurface { handle: vk::Instance, - wayland_surface_fn: vk::WaylandSurfaceFn, + wayland_surface_fn: vk::KhrWaylandSurfaceFn, } impl WaylandSurface { @@ -17,7 +17,7 @@ impl WaylandSurface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::WaylandSurfaceFn::load(|name| unsafe { + let surface_fn = vk::KhrWaylandSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(WaylandSurface { diff --git a/ash/src/extensions/win32_surface.rs b/ash/src/extensions/win32_surface.rs index c2439f9..e24404f 100644 --- a/ash/src/extensions/win32_surface.rs +++ b/ash/src/extensions/win32_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct Win32Surface { handle: vk::Instance, - win32_surface_fn: vk::Win32SurfaceFn, + win32_surface_fn: vk::KhrWin32SurfaceFn, } impl Win32Surface { @@ -17,7 +17,7 @@ impl Win32Surface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::Win32SurfaceFn::load(|name| unsafe { + let surface_fn = vk::KhrWin32SurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(Win32Surface { diff --git a/ash/src/extensions/xcb_surface.rs b/ash/src/extensions/xcb_surface.rs index 04fb2a6..e3906e3 100644 --- a/ash/src/extensions/xcb_surface.rs +++ b/ash/src/extensions/xcb_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct XcbSurface { handle: vk::Instance, - xcb_surface_fn: vk::XcbSurfaceFn, + xcb_surface_fn: vk::KhrXcbSurfaceFn, } impl XcbSurface { @@ -17,7 +17,7 @@ impl XcbSurface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::XcbSurfaceFn::load(|name| unsafe { + let surface_fn = vk::KhrXcbSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(XcbSurface { diff --git a/ash/src/extensions/xlib_surface.rs b/ash/src/extensions/xlib_surface.rs index 76bcb9c..cc4c1da 100644 --- a/ash/src/extensions/xlib_surface.rs +++ b/ash/src/extensions/xlib_surface.rs @@ -1,15 +1,15 @@ #![allow(dead_code)] use prelude::*; -use std::mem; -use vk; use std::ffi::CStr; -use RawPtr; +use std::mem; use version::{EntryV1_0, InstanceV1_0}; +use vk; +use RawPtr; #[derive(Clone)] pub struct XlibSurface { handle: vk::Instance, - xlib_surface_fn: vk::XlibSurfaceFn, + xlib_surface_fn: vk::KhrXlibSurfaceFn, } impl XlibSurface { @@ -17,7 +17,7 @@ impl XlibSurface { entry: &E, instance: &I, ) -> Result> { - let surface_fn = vk::XlibSurfaceFn::load(|name| unsafe { + let surface_fn = vk::KhrXlibSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(XlibSurface { From e6e8bbd91b78efc116da6bd92f0a0a3ee1bdeb66 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 7 Jul 2018 12:54:31 +0200 Subject: [PATCH 016/122] Successfully replace the old vk.rs file --- ash/src/device.rs | 43 +- ash/src/entry.rs | 18 +- ash/src/instance.rs | 12 +- ash/src/lib.rs | 11 +- ash/src/version.rs | 4 +- ash/src/vk.rs | 18481 ++++++++++++++++++++++++++++++----------- generator/src/lib.rs | 248 +- 7 files changed, 13738 insertions(+), 5079 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index 3299f66..490a68f 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -1,9 +1,9 @@ #![allow(dead_code)] use prelude::*; use std::mem; +use version::{FunctionPointers, V1_0}; use vk; use RawPtr; -use version::{FunctionPointers, V1_0}; #[allow(non_camel_case_types)] pub trait DeviceV1_0 { @@ -463,7 +463,8 @@ pub trait DeviceV1_0 { pool: vk::DescriptorPool, flags: vk::DescriptorPoolResetFlags, ) -> VkResult<()> { - let err_code = self.fp_v1_0() + let err_code = self + .fp_v1_0() .reset_descriptor_pool(self.handle(), pool, flags); match err_code { vk::Result::Success => Ok(()), @@ -476,7 +477,8 @@ pub trait DeviceV1_0 { command_pool: vk::CommandPool, flags: vk::CommandPoolResetFlags, ) -> VkResult<()> { - let err_code = self.fp_v1_0() + let err_code = self + .fp_v1_0() .reset_command_pool(self.handle(), command_pool, flags); match err_code { vk::Result::Success => Ok(()), @@ -636,7 +638,7 @@ pub trait DeviceV1_0 { descriptor_sets.as_ptr(), dynamic_offsets.len() as vk::uint32_t, dynamic_offsets.as_ptr(), - ) + ); } unsafe fn cmd_push_constants( @@ -699,15 +701,9 @@ pub trait DeviceV1_0 { ); } - unsafe fn cmd_set_line_width( - &self, - command_buffer: vk::CommandBuffer, - line_width: f32, - ) { - self.fp_v1_0().cmd_set_line_width( - command_buffer, - line_width, - ); + unsafe fn cmd_set_line_width(&self, command_buffer: vk::CommandBuffer, line_width: f32) { + self.fp_v1_0() + .cmd_set_line_width(command_buffer, line_width); } unsafe fn cmd_bind_vertex_buffers( @@ -802,12 +798,8 @@ pub trait DeviceV1_0 { clamp: f32, slope_factor: f32, ) { - self.fp_v1_0().cmd_set_depth_bias( - command_buffer, - constant_factor, - clamp, - slope_factor, - ); + self.fp_v1_0() + .cmd_set_depth_bias(command_buffer, constant_factor, clamp, slope_factor); } unsafe fn cmd_set_blend_constants( @@ -816,7 +808,7 @@ pub trait DeviceV1_0 { blend_constants: [f32; 4], ) { self.fp_v1_0() - .cmd_set_blend_constants(command_buffer, &blend_constants); + .cmd_set_blend_constants(command_buffer, blend_constants); } unsafe fn cmd_set_depth_bounds( @@ -1178,7 +1170,8 @@ pub trait DeviceV1_0 { command_buffer: vk::CommandBuffer, create_info: &vk::CommandBufferBeginInfo, ) -> VkResult<()> { - let err_code = self.fp_v1_0() + let err_code = self + .fp_v1_0() .begin_command_buffer(command_buffer, create_info); match err_code { vk::Result::Success => Ok(()), @@ -1373,8 +1366,12 @@ pub trait DeviceV1_0 { ) -> vk::SubresourceLayout { unsafe { let mut layout = mem::uninitialized(); - self.fp_v1_0() - .get_image_subresource_layout(self.handle(), image, &subresource, &mut layout); + self.fp_v1_0().get_image_subresource_layout( + self.handle(), + image, + &subresource, + &mut layout, + ); layout } } diff --git a/ash/src/entry.rs b/ash/src/entry.rs index ead666b..586b74e 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -1,14 +1,14 @@ -use prelude::*; -use std::mem; -use std::ptr; -use vk; use instance::Instance; +use prelude::*; use shared_library::dynamic_library::DynamicLibrary; use std::error::Error; use std::fmt; +use std::mem; use std::path::Path; -use RawPtr; +use std::ptr; use version::{EntryLoader, FunctionPointers, InstanceLoader, V1_0}; +use vk; +use RawPtr; #[cfg(windows)] const LIB_PATH: &'static str = "vulkan-1.dll"; @@ -22,8 +22,9 @@ const LIB_PATH: &'static str = "libvulkan.so"; #[cfg(any(target_os = "macos", target_os = "ios"))] const LIB_PATH: &'static str = "libMoltenVK.dylib"; -lazy_static!{ - static ref VK_LIB: Result = DynamicLibrary::open(Some(&Path::new(LIB_PATH))); +lazy_static! { + static ref VK_LIB: Result = + DynamicLibrary::open(Some(&Path::new(LIB_PATH))); } #[derive(Clone)] @@ -97,7 +98,8 @@ pub trait EntryV1_0 { .enumerate_instance_layer_properties(&mut num, ptr::null_mut()); let mut v = Vec::with_capacity(num as usize); - let err_code = self.fp_v1_0() + let err_code = self + .fp_v1_0() .enumerate_instance_layer_properties(&mut num, v.as_mut_ptr()); v.set_len(num as usize); match err_code { diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 887e26d..53406b0 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -1,14 +1,14 @@ #![allow(dead_code)] -use prelude::*; -use std::ptr; -use std::mem; -use vk; use device::Device; +use prelude::*; use std::error::Error; use std::fmt; -use RawPtr; -use version::{FunctionPointers, V1_0}; +use std::mem; +use std::ptr; use version::DeviceLoader; +use version::{FunctionPointers, V1_0}; +use vk; +use RawPtr; #[derive(Debug)] pub enum DeviceError { diff --git a/ash/src/lib.rs b/ash/src/lib.rs index 863d6a5..7e75782 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -2,19 +2,18 @@ extern crate lazy_static; extern crate libc; extern crate shared_library; -pub use instance::{DeviceError, Instance}; pub use device::Device; pub use entry::{Entry, InstanceError, LoadingError}; +pub use instance::{DeviceError, Instance}; -mod instance; mod device; mod entry; -pub mod prelude; -pub mod vk; pub mod extensions; -pub mod version; +mod instance; +pub mod prelude; pub mod util; -mod vk_test; +pub mod version; +pub mod vk; pub trait RawPtr { fn as_raw_ptr(&self) -> *const T; } diff --git a/ash/src/version.rs b/ash/src/version.rs index 07af411..51f00f9 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -1,8 +1,8 @@ -use vk; -pub use instance::InstanceV1_0; pub use device::DeviceV1_0; pub use entry::EntryV1_0; +pub use instance::InstanceV1_0; use std::mem; +use vk; pub trait FunctionPointers { type InstanceFp: InstanceLoader + Clone; type DeviceFp: DeviceLoader + Clone; diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 5291504..f971367 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,5127 +1,13686 @@ -pub use std::os::raw::c_ulonglong; -pub use self::types::*; -pub use self::cmds::*; -use std::error::Error; -use std::default::Default; - -#[doc(hidden)] -#[allow(dead_code)] -pub fn unloaded_function_panic() -> ! { - panic!("Attempted to run unloaded vulkan function") -} - -macro_rules! handle_nondispatchable { - ($name: ident) => { - #[repr(C)] - #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] - pub struct $name (uint64_t); - - impl $name{ - pub fn null() -> $name{ - $name(0) - } - } - impl fmt::Pointer for $name { - fn fmt(&self, f: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - write!(f, "0x{:x}", self.0) - } - } - - impl fmt::Debug for $name { - fn fmt(&self, f: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - write!(f, "0x{:x}", self.0) - } - } - } -} - +pub use libc::*; +pub type RROutput = c_ulong; +pub type VisualID = c_uint; +pub type Display = *const c_void; +pub type Window = c_ulong; +#[allow(non_camel_case_types)] +pub type xcb_connection_t = *const c_void; +#[allow(non_camel_case_types)] +pub type xcb_window_t = u32; +#[allow(non_camel_case_types)] +pub type xcb_visualid_t = *const c_void; +pub type MirConnection = *const c_void; +pub type MirSurface = *const c_void; +pub type HINSTANCE = *const c_void; +pub type HWND = *const c_void; +#[allow(non_camel_case_types)] +pub type wl_display = *const c_void; +#[allow(non_camel_case_types)] +pub type wl_surface = *const c_void; +pub type HANDLE = *mut c_void; +pub type DWORD = c_ulong; +pub type WCHAR = wchar_t; +pub type LPCWSTR = *const WCHAR; +#[allow(non_camel_case_types)] +pub type SECURITY_ATTRIBUTES = (); +pub type ANativeWindow = c_void; +pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ($name: ident, $all: expr, $flag_type: ty) => { + ($name:ident, $all:expr, $flag_type:ty) => { #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct $name {flags: $flag_type} - - impl Default for $name{ + pub struct $name { + flags: $flag_type, + } + impl Default for $name { fn default() -> $name { - $name {flags: 0} + $name { flags: 0 } } } - impl fmt::Debug for $name { - fn fmt(&self, f: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { + impl ::std::fmt::Debug for $name { + fn fmt( + &self, + f: &mut ::std::fmt::Formatter, + ) -> ::std::result::Result<(), ::std::fmt::Error> { write!(f, "{}({:b})", stringify!($name), self.flags) } } - impl $name { #[inline] pub fn empty() -> $name { - $name {flags: 0} + $name { flags: 0 } } - #[inline] pub fn all() -> $name { - $name {flags: $all} + $name { flags: $all } } - #[inline] pub fn flags(self) -> $flag_type { self.flags } - #[inline] pub fn from_flags(flags: $flag_type) -> Option<$name> { if flags & !$all == 0 { - Some($name {flags: flags}) + Some($name { flags: flags }) } else { None } } - #[inline] pub fn from_flags_truncate(flags: $flag_type) -> $name { - $name {flags: flags & $all} + $name { + flags: flags & $all, + } } - #[inline] pub fn is_empty(self) -> bool { self == $name::empty() } - #[inline] pub fn is_all(self) -> bool { self & $name::all() == $name::all() } - #[inline] pub fn intersects(self, other: $name) -> bool { self & other != $name::empty() } - - /// Returns true of `other` is a subset of `self` + #[doc = r" Returns true of `other` is a subset of `self`"] #[inline] pub fn subset(self, other: $name) -> bool { self & other == other } } - - impl BitOr for $name { + impl ::std::ops::BitOr for $name { type Output = $name; - #[inline] fn bitor(self, rhs: $name) -> $name { - $name {flags: self.flags | rhs.flags } + $name { + flags: self.flags | rhs.flags, + } } } - - impl BitOrAssign for $name { + impl ::std::ops::BitOrAssign for $name { #[inline] fn bitor_assign(&mut self, rhs: $name) { *self = *self | rhs } } - - impl BitAnd for $name { + impl ::std::ops::BitAnd for $name { type Output = $name; - #[inline] fn bitand(self, rhs: $name) -> $name { - $name {flags: self.flags & rhs.flags} + $name { + flags: self.flags & rhs.flags, + } } } - - impl BitAndAssign for $name { + impl ::std::ops::BitAndAssign for $name { #[inline] fn bitand_assign(&mut self, rhs: $name) { *self = *self & rhs } } - - impl BitXor for $name { + impl ::std::ops::BitXor for $name { type Output = $name; - #[inline] fn bitxor(self, rhs: $name) -> $name { - $name {flags: self.flags ^ rhs.flags} + $name { + flags: self.flags ^ rhs.flags, + } } } - - impl BitXorAssign for $name { + impl ::std::ops::BitXorAssign for $name { #[inline] fn bitxor_assign(&mut self, rhs: $name) { *self = *self ^ rhs } } - - impl Sub for $name { + impl ::std::ops::Sub for $name { type Output = $name; - #[inline] fn sub(self, rhs: $name) -> $name { self & !rhs } } - - impl SubAssign for $name { + impl ::std::ops::SubAssign for $name { #[inline] fn sub_assign(&mut self, rhs: $name) { *self = *self - rhs } } - - impl Not for $name { + impl ::std::ops::Not for $name { type Output = $name; - #[inline] fn not(self) -> $name { self ^ $name::all() } } + }; +} +macro_rules! handle_nondispatchable { + ($name:ident) => { + #[repr(C)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] + pub struct $name(uint64_t); + impl $name { + pub fn null() -> $name { + $name(0) + } + } + impl ::std::fmt::Pointer for $name { + fn fmt( + &self, + f: &mut ::std::fmt::Formatter, + ) -> ::std::result::Result<(), ::std::fmt::Error> { + write!(f, "0x{:x}", self.0) + } + } + impl ::std::fmt::Debug for $name { + fn fmt( + &self, + f: &mut ::std::fmt::Formatter, + ) -> ::std::result::Result<(), ::std::fmt::Error> { + write!(f, "0x{:x}", self.0) + } + } + }; +} +macro_rules! define_handle { + ($name:ident) => { + #[derive(Clone, Copy, Debug)] + #[repr(C)] + pub struct $name { + ptr: *mut u8, + } + unsafe impl Send for $name {} + unsafe impl Sync for $name {} + impl $name { + pub unsafe fn null() -> Self { + $name { + ptr: ::std::ptr::null_mut(), + } + } + } + }; +} +pub struct StaticFn { + get_instance_proc_addr: + extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction, +} +unsafe impl Send for StaticFn {} +unsafe impl Sync for StaticFn {} +impl ::std::clone::Clone for StaticFn { + fn clone(&self) -> Self { + StaticFn { + get_instance_proc_addr: self.get_instance_proc_addr, + } } } - -#[macro_export] -macro_rules! vk_make_version { - ($major: expr, $minor: expr, $patch: expr) => ((($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32) -} - -#[macro_export] -macro_rules! vk_version_major { - ($major: expr) => (($major as uint32_t) >> 22) -} - -#[macro_export] -macro_rules! vk_version_minor { - ($minor: expr) => ((($minor as uint32_t) >> 12) & 0x3ff) -} - -#[macro_export] -macro_rules! vk_version_patch { - ($minor: expr) => (($minor as uint32_t) & 0xfff) -} - -pub mod types { - #![allow(non_camel_case_types, dead_code)] - use std::ops::*; - use std::fmt; - use std::ffi::CStr; - use super::*; - use libc; - pub type c_void = libc::c_void; - pub type c_char = libc::c_char; - pub type uint32_t = libc::uint32_t; - pub type size_t = libc::size_t; - pub type uint64_t = libc::uint64_t; - pub type uint8_t = libc::uint8_t; - pub type c_float = libc::c_float; - pub type int32_t = libc::int32_t; - pub type Display = *const c_void; - pub type Window = libc::c_ulong; - pub type VisualID = *const c_void; - pub type xcb_connection_t = *const c_void; - pub type xcb_window_t = u32; - pub type xcb_visualid_t = *const c_void; - 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 ANativeWindow = *const c_void; - pub type wl_display = *const c_void; - pub type wl_surface = *const c_void; - - pub type Flags = uint32_t; - pub type Bool32 = uint32_t; - pub type DeviceSize = uint64_t; - pub type SampleMask = uint32_t; - - vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags); - vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags); - vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); - vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); - vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(MirSurfaceCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags); - vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags); - vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags); - - pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: size_t = 256; - pub const VK_UUID_SIZE: size_t = 16; - pub const VK_MAX_EXTENSION_NAME_SIZE: size_t = 256; - pub const VK_MAX_DESCRIPTION_SIZE: size_t = 256; - pub const VK_MAX_MEMORY_TYPES: size_t = 32; - pub const VK_MAX_MEMORY_HEAPS: size_t = 16; - pub const VK_LOD_CLAMP_NONE: c_float = 1000.0; - pub const VK_REMAINING_MIP_LEVELS: uint32_t = !0; - pub const VK_REMAINING_ARRAY_LAYERS: uint32_t = !0; - pub const VK_WHOLE_SIZE: c_ulonglong = !0; - pub const VK_ATTACHMENT_UNUSED: uint32_t = !0; - pub const VK_TRUE: uint32_t = 1; - pub const VK_FALSE: uint32_t = 0; - pub const VK_QUEUE_FAMILY_IGNORED: uint32_t = !0; - pub const VK_SUBPASS_EXTERNAL: uint32_t = !0; - pub const VK_KHR_SURFACE_SPEC_VERSION: uint32_t = 25; - pub const VK_KHR_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_surface"; - pub const VK_KHR_XLIB_SURFACE_SPEC_VERSION: uint32_t = 6; - pub const VK_KHR_XLIB_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_xlib_surface"; - pub const VK_KHR_XCB_SURFACE_SPEC_VERSION: uint32_t = 6; - pub const VK_KHR_XCB_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_xcb_surface"; - pub const VK_KHR_MIR_SURFACE_SPEC_VERSION: uint32_t = 4; - pub const VK_KHR_MIR_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_mir_surface"; - pub const VK_KHR_WIN32_SURFACE_SPEC_VERSION: uint32_t = 5; - pub const VK_KHR_WIN32_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_win32_surface"; - pub const VK_KHR_ANDROID_SURFACE_SPEC_VERSION: uint32_t = 6; - pub const VK_KHR_ANDROID_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_android_surface"; - pub const VK_KHR_WAYLAND_SURFACE_SPEC_VERSION: uint32_t = 5; - pub const VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_wayland_surface"; - pub const VK_KHR_SWAPCHAIN_SPEC_VERSION: uint32_t = 68; - pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME: &'static str = "VK_KHR_swapchain"; - pub const VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION: uint32_t = 9; - pub const VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME: &'static str = "VK_KHR_display_swapchain"; - pub const VK_KHR_DISPLAY_SPEC_VERSION: uint32_t = 21; - pub const VK_KHR_DISPLAY_EXTENSION_NAME: &'static str = "VK_KHR_display"; - pub const VK_EXT_DEBUG_REPORT_SPEC_VERSION: uint32_t = 3; - pub const VK_EXT_DEBUG_REPORT_EXTENSION_NAME: &'static str = "VK_EXT_debug_report"; - pub const VK_MVK_IOS_SURFACE_SPEC_VERSION: uint32_t = 2; - pub const VK_MVK_IOS_SURFACE_EXTENSION_NAME: &'static str = "VK_MVK_ios_surface"; - pub const VK_MVK_MACOS_SURFACE_SPEC_VERSION: uint32_t = 2; - pub const VK_MVK_MACOS_SURFACE_EXTENSION_NAME: &'static str = "VK_MVK_macos_surface"; - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct InstanceCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: InstanceCreateFlags, - pub p_application_info: *const ApplicationInfo, - pub enabled_layer_count: uint32_t, - pub pp_enabled_layer_names: *const *const c_char, - pub enabled_extension_count: uint32_t, - pub pp_enabled_extension_names: *const *const c_char, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct ApplicationInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub p_application_name: *const c_char, - pub application_version: uint32_t, - pub p_engine_name: *const c_char, - pub engine_version: uint32_t, - pub api_version: uint32_t, - } - - #[repr(C)] - pub struct AllocationCallbacks { - pub p_user_data: *mut c_void, - pub pfn_allocation: PFN_vkAllocationFunction, - pub pfn_reallocation: PFN_vkReallocationFunction, - pub pfn_free: PFN_vkFreeFunction, - pub pfn_internal_allocation: PFN_vkInternalAllocationNotification, - pub pfn_internal_free: PFN_vkInternalFreeNotification, - } - - impl Clone for AllocationCallbacks { - fn clone(&self) -> AllocationCallbacks { - AllocationCallbacks { - p_user_data: self.p_user_data.clone(), - pfn_allocation: self.pfn_allocation, - pfn_reallocation: self.pfn_reallocation, - pfn_free: self.pfn_free, - pfn_internal_allocation: self.pfn_internal_allocation, - pfn_internal_free: self.pfn_internal_free, - } - } - } - - impl fmt::Debug for AllocationCallbacks { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("AllocationCallbacks") - .field("p_user_data", &self.p_user_data) - .field("pfn_allocation", &(self.pfn_allocation as *const ())) - .field("pfn_reallocation", &(self.pfn_reallocation as *const ())) - .field("pfn_free", &(self.pfn_free as *const ())) - .field( - "pfn_internal_allocation", - &(self.pfn_internal_allocation as *const ()), - ) - .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) - .finish() - } - } - - #[derive(Default, Debug, Clone)] - #[repr(C)] - pub struct PhysicalDeviceFeatures { - pub robust_buffer_access: Bool32, - pub full_draw_index_uint32: Bool32, - pub image_cube_array: Bool32, - pub independent_blend: Bool32, - pub geometry_shader: Bool32, - pub tessellation_shader: Bool32, - pub sample_rate_shading: Bool32, - pub dual_src_blend: Bool32, - pub logic_op: Bool32, - pub multi_draw_indirect: Bool32, - pub draw_indirect_first_instance: Bool32, - pub depth_clamp: Bool32, - pub depth_bias_clamp: Bool32, - pub fill_mode_non_solid: Bool32, - pub depth_bounds: Bool32, - pub wide_lines: Bool32, - pub large_points: Bool32, - pub alpha_to_one: Bool32, - pub multi_viewport: Bool32, - pub sampler_anisotropy: Bool32, - pub texture_compression_etc2: Bool32, - pub texture_compression_astc_ldr: Bool32, - pub texture_compression_bc: Bool32, - pub occlusion_query_precise: Bool32, - pub pipeline_statistics_query: Bool32, - pub vertex_pipeline_stores_and_atomics: Bool32, - pub fragment_stores_and_atomics: Bool32, - pub shader_tessellation_and_geometry_point_size: Bool32, - pub shader_image_gather_extended: Bool32, - pub shader_storage_image_extended_formats: Bool32, - pub shader_storage_image_multisample: Bool32, - pub shader_storage_image_read_without_format: Bool32, - pub shader_storage_image_write_without_format: Bool32, - pub shader_uniform_buffer_array_dynamic_indexing: Bool32, - pub shader_sampled_image_array_dynamic_indexing: Bool32, - pub shader_storage_buffer_array_dynamic_indexing: Bool32, - pub shader_storage_image_array_dynamic_indexing: Bool32, - pub shader_clip_distance: Bool32, - pub shader_cull_distance: Bool32, - pub shader_float64: Bool32, - pub shader_int64: Bool32, - pub shader_int16: Bool32, - pub shader_resource_residency: Bool32, - pub shader_resource_min_lod: Bool32, - pub sparse_binding: Bool32, - pub sparse_residency_buffer: Bool32, - pub sparse_residency_image2d: Bool32, - pub sparse_residency_image3d: Bool32, - pub sparse_residency2samples: Bool32, - pub sparse_residency4samples: Bool32, - pub sparse_residency8samples: Bool32, - pub sparse_residency16samples: Bool32, - pub sparse_residency_aliased: Bool32, - pub variable_multisample_rate: Bool32, - pub inherited_queries: Bool32, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct FormatProperties { - pub linear_tiling_features: FormatFeatureFlags, - pub optimal_tiling_features: FormatFeatureFlags, - pub buffer_features: FormatFeatureFlags, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct ImageFormatProperties { - pub max_extent: Extent3D, - pub max_mip_levels: uint32_t, - pub max_array_layers: uint32_t, - pub sample_counts: SampleCountFlags, - pub max_resource_size: DeviceSize, - } - - #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] - #[repr(C)] - pub struct Extent3D { - pub width: uint32_t, - pub height: uint32_t, - pub depth: uint32_t, - } - - #[repr(C)] - pub struct PhysicalDeviceProperties { - pub api_version: uint32_t, - pub driver_version: uint32_t, - pub vendor_id: uint32_t, - pub device_id: uint32_t, - pub device_type: PhysicalDeviceType, - pub device_name: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE], - pub pipeline_cache_uuid: [uint8_t; VK_UUID_SIZE], - pub limits: PhysicalDeviceLimits, - pub sparse_properties: PhysicalDeviceSparseProperties, - } - - impl Clone for PhysicalDeviceProperties { - fn clone(&self) -> PhysicalDeviceProperties { - PhysicalDeviceProperties { - api_version: self.api_version.clone(), - driver_version: self.driver_version.clone(), - vendor_id: self.vendor_id.clone(), - device_id: self.device_id.clone(), - device_type: self.device_type.clone(), - device_name: { - use std::mem; - let mut array: [_; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] = - unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.device_name[i].clone(); - } - array - }, - pipeline_cache_uuid: { - use std::mem; - let mut array: [_; VK_UUID_SIZE] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.pipeline_cache_uuid[i].clone(); - } - array - }, - limits: self.limits.clone(), - sparse_properties: self.sparse_properties.clone(), - } - } - } - - impl fmt::Debug for PhysicalDeviceProperties { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("PhysicalDeviceProperties") - .field("api_version", &self.api_version) - .field("driver_version", &self.driver_version) - .field("vendor_id", &self.vendor_id) - .field("device_id", &self.device_id) - .field("device_type", &self.device_type) - .field("device_name", &unsafe { - CStr::from_ptr(&self.device_name[0]) - }) - .field("pipeline_cache_uuid", &&self.pipeline_cache_uuid[..]) - .field("limits", &self.limits) - .field("sparse_properties", &self.sparse_properties) - .finish() - } - } - - #[repr(C)] - pub struct PhysicalDeviceLimits { - pub max_image_dimension1d: uint32_t, - pub max_image_dimension2d: uint32_t, - pub max_image_dimension3d: uint32_t, - pub max_image_dimension_cube: uint32_t, - pub max_image_array_layers: uint32_t, - pub max_texel_buffer_elements: uint32_t, - pub max_uniform_buffer_range: uint32_t, - pub max_storage_buffer_range: uint32_t, - pub max_push_constants_size: uint32_t, - pub max_memory_allocation_count: uint32_t, - pub max_sampler_allocation_count: uint32_t, - pub buffer_image_granularity: DeviceSize, - pub sparse_address_space_size: DeviceSize, - pub max_bound_descriptor_sets: uint32_t, - pub max_per_stage_descriptor_samplers: uint32_t, - pub max_per_stage_descriptor_uniform_buffers: uint32_t, - pub max_per_stage_descriptor_storage_buffers: uint32_t, - pub max_per_stage_descriptor_sampled_images: uint32_t, - pub max_per_stage_descriptor_storage_images: uint32_t, - pub max_per_stage_descriptor_input_attachments: uint32_t, - pub max_per_stage_resources: uint32_t, - pub max_descriptor_set_samplers: uint32_t, - pub max_descriptor_set_uniform_buffers: uint32_t, - pub max_descriptor_set_uniform_buffers_dynamic: uint32_t, - pub max_descriptor_set_storage_buffers: uint32_t, - pub max_descriptor_set_storage_buffers_dynamic: uint32_t, - pub max_descriptor_set_sampled_images: uint32_t, - pub max_descriptor_set_storage_images: uint32_t, - pub max_descriptor_set_input_attachments: uint32_t, - pub max_vertex_input_attributes: uint32_t, - pub max_vertex_input_bindings: uint32_t, - pub max_vertex_input_attribute_offset: uint32_t, - pub max_vertex_input_binding_stride: uint32_t, - pub max_vertex_output_components: uint32_t, - pub max_tessellation_generation_level: uint32_t, - pub max_tessellation_patch_size: uint32_t, - pub max_tessellation_control_per_vertex_input_components: uint32_t, - pub max_tessellation_control_per_vertex_output_components: uint32_t, - pub max_tessellation_control_per_patch_output_components: uint32_t, - pub max_tessellation_control_total_output_components: uint32_t, - pub max_tessellation_evaluation_input_components: uint32_t, - pub max_tessellation_evaluation_output_components: uint32_t, - pub max_geometry_shader_invocations: uint32_t, - pub max_geometry_input_components: uint32_t, - pub max_geometry_output_components: uint32_t, - pub max_geometry_output_vertices: uint32_t, - pub max_geometry_total_output_components: uint32_t, - pub max_fragment_input_components: uint32_t, - pub max_fragment_output_attachments: uint32_t, - pub max_fragment_dual_src_attachments: uint32_t, - pub max_fragment_combined_output_resources: uint32_t, - pub max_compute_shared_memory_size: uint32_t, - pub max_compute_work_group_count: [uint32_t; 3], - pub max_compute_work_group_invocations: uint32_t, - pub max_compute_work_group_size: [uint32_t; 3], - pub sub_pixel_precision_bits: uint32_t, - pub sub_texel_precision_bits: uint32_t, - pub mipmap_precision_bits: uint32_t, - pub max_draw_indexed_index_value: uint32_t, - pub max_draw_indirect_count: uint32_t, - pub max_sampler_lod_bias: c_float, - pub max_sampler_anisotropy: c_float, - pub max_viewports: uint32_t, - pub max_viewport_dimensions: [uint32_t; 2], - pub viewport_bounds_range: [c_float; 2], - pub viewport_sub_pixel_bits: uint32_t, - pub min_memory_map_alignment: size_t, - pub min_texel_buffer_offset_alignment: DeviceSize, - pub min_uniform_buffer_offset_alignment: DeviceSize, - pub min_storage_buffer_offset_alignment: DeviceSize, - pub min_texel_offset: int32_t, - pub max_texel_offset: uint32_t, - pub min_texel_gather_offset: int32_t, - pub max_texel_gather_offset: uint32_t, - pub min_interpolation_offset: c_float, - pub max_interpolation_offset: c_float, - pub sub_pixel_interpolation_offset_bits: uint32_t, - pub max_framebuffer_width: uint32_t, - pub max_framebuffer_height: uint32_t, - pub max_framebuffer_layers: uint32_t, - pub framebuffer_color_sample_counts: SampleCountFlags, - pub framebuffer_depth_sample_counts: SampleCountFlags, - pub framebuffer_stencil_sample_counts: SampleCountFlags, - pub framebuffer_no_attachments_sample_counts: SampleCountFlags, - pub max_color_attachments: uint32_t, - pub sampled_image_color_sample_counts: SampleCountFlags, - pub sampled_image_integer_sample_counts: SampleCountFlags, - pub sampled_image_depth_sample_counts: SampleCountFlags, - pub sampled_image_stencil_sample_counts: SampleCountFlags, - pub storage_image_sample_counts: SampleCountFlags, - pub max_sample_mask_words: uint32_t, - pub timestamp_compute_and_graphics: Bool32, - pub timestamp_period: c_float, - pub max_clip_distances: uint32_t, - pub max_cull_distances: uint32_t, - pub max_combined_clip_and_cull_distances: uint32_t, - pub discrete_queue_priorities: uint32_t, - pub point_size_range: [c_float; 2], - pub line_width_range: [c_float; 2], - pub point_size_granularity: c_float, - pub line_width_granularity: c_float, - pub strict_lines: Bool32, - pub standard_sample_locations: Bool32, - pub optimal_buffer_copy_offset_alignment: DeviceSize, - pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, - pub non_coherent_atom_size: DeviceSize, - } - - impl Clone for PhysicalDeviceLimits { - fn clone(&self) -> PhysicalDeviceLimits { - PhysicalDeviceLimits { - max_image_dimension1d: self.max_image_dimension1d.clone(), - max_image_dimension2d: self.max_image_dimension2d.clone(), - max_image_dimension3d: self.max_image_dimension3d.clone(), - max_image_dimension_cube: self.max_image_dimension_cube.clone(), - max_image_array_layers: self.max_image_array_layers.clone(), - max_texel_buffer_elements: self.max_texel_buffer_elements.clone(), - max_uniform_buffer_range: self.max_uniform_buffer_range.clone(), - max_storage_buffer_range: self.max_storage_buffer_range.clone(), - max_push_constants_size: self.max_push_constants_size.clone(), - max_memory_allocation_count: self.max_memory_allocation_count.clone(), - max_sampler_allocation_count: self.max_sampler_allocation_count.clone(), - buffer_image_granularity: self.buffer_image_granularity.clone(), - sparse_address_space_size: self.sparse_address_space_size.clone(), - max_bound_descriptor_sets: self.max_bound_descriptor_sets.clone(), - max_per_stage_descriptor_samplers: self.max_per_stage_descriptor_samplers.clone(), - max_per_stage_descriptor_uniform_buffers: - self.max_per_stage_descriptor_uniform_buffers.clone(), - max_per_stage_descriptor_storage_buffers: - self.max_per_stage_descriptor_storage_buffers.clone(), - max_per_stage_descriptor_sampled_images: - self.max_per_stage_descriptor_sampled_images.clone(), - max_per_stage_descriptor_storage_images: - self.max_per_stage_descriptor_storage_images.clone(), - max_per_stage_descriptor_input_attachments: - self.max_per_stage_descriptor_input_attachments.clone(), - max_per_stage_resources: self.max_per_stage_resources.clone(), - max_descriptor_set_samplers: self.max_descriptor_set_samplers.clone(), - max_descriptor_set_uniform_buffers: self.max_descriptor_set_uniform_buffers.clone(), - max_descriptor_set_uniform_buffers_dynamic: - self.max_descriptor_set_uniform_buffers_dynamic.clone(), - max_descriptor_set_storage_buffers: self.max_descriptor_set_storage_buffers.clone(), - max_descriptor_set_storage_buffers_dynamic: - self.max_descriptor_set_storage_buffers_dynamic.clone(), - max_descriptor_set_sampled_images: self.max_descriptor_set_sampled_images.clone(), - max_descriptor_set_storage_images: self.max_descriptor_set_storage_images.clone(), - max_descriptor_set_input_attachments: self.max_descriptor_set_input_attachments - .clone(), - max_vertex_input_attributes: self.max_vertex_input_attributes.clone(), - max_vertex_input_bindings: self.max_vertex_input_bindings.clone(), - max_vertex_input_attribute_offset: self.max_vertex_input_attribute_offset.clone(), - max_vertex_input_binding_stride: self.max_vertex_input_binding_stride.clone(), - max_vertex_output_components: self.max_vertex_output_components.clone(), - max_tessellation_generation_level: self.max_tessellation_generation_level.clone(), - max_tessellation_patch_size: self.max_tessellation_patch_size.clone(), - max_tessellation_control_per_vertex_input_components: - self.max_tessellation_control_per_vertex_input_components - .clone(), - max_tessellation_control_per_vertex_output_components: - self.max_tessellation_control_per_vertex_output_components - .clone(), - max_tessellation_control_per_patch_output_components: - self.max_tessellation_control_per_patch_output_components - .clone(), - max_tessellation_control_total_output_components: - self.max_tessellation_control_total_output_components - .clone(), - max_tessellation_evaluation_input_components: - self.max_tessellation_evaluation_input_components.clone(), - max_tessellation_evaluation_output_components: - self.max_tessellation_evaluation_output_components.clone(), - max_geometry_shader_invocations: self.max_geometry_shader_invocations.clone(), - max_geometry_input_components: self.max_geometry_input_components.clone(), - max_geometry_output_components: self.max_geometry_output_components.clone(), - max_geometry_output_vertices: self.max_geometry_output_vertices.clone(), - max_geometry_total_output_components: self.max_geometry_total_output_components - .clone(), - max_fragment_input_components: self.max_fragment_input_components.clone(), - max_fragment_output_attachments: self.max_fragment_output_attachments.clone(), - max_fragment_dual_src_attachments: self.max_fragment_dual_src_attachments.clone(), - max_fragment_combined_output_resources: self.max_fragment_combined_output_resources - .clone(), - max_compute_shared_memory_size: self.max_compute_shared_memory_size.clone(), - max_compute_work_group_count: { - use std::mem; - let mut array: [_; 3] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.max_compute_work_group_count[i].clone(); - } - array - }, - max_compute_work_group_invocations: self.max_compute_work_group_invocations.clone(), - max_compute_work_group_size: { - use std::mem; - let mut array: [_; 3] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.max_compute_work_group_size[i].clone(); - } - array - }, - sub_pixel_precision_bits: self.sub_pixel_precision_bits.clone(), - sub_texel_precision_bits: self.sub_texel_precision_bits.clone(), - mipmap_precision_bits: self.mipmap_precision_bits.clone(), - max_draw_indexed_index_value: self.max_draw_indexed_index_value.clone(), - max_draw_indirect_count: self.max_draw_indirect_count.clone(), - max_sampler_lod_bias: self.max_sampler_lod_bias.clone(), - max_sampler_anisotropy: self.max_sampler_anisotropy.clone(), - max_viewports: self.max_viewports.clone(), - max_viewport_dimensions: { - use std::mem; - let mut array: [_; 2] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.max_viewport_dimensions[i].clone(); - } - array - }, - viewport_bounds_range: { - use std::mem; - let mut array: [_; 2] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.viewport_bounds_range[i].clone(); - } - array - }, - viewport_sub_pixel_bits: self.viewport_sub_pixel_bits.clone(), - min_memory_map_alignment: self.min_memory_map_alignment.clone(), - min_texel_buffer_offset_alignment: self.min_texel_buffer_offset_alignment.clone(), - min_uniform_buffer_offset_alignment: self.min_uniform_buffer_offset_alignment - .clone(), - min_storage_buffer_offset_alignment: self.min_storage_buffer_offset_alignment - .clone(), - min_texel_offset: self.min_texel_offset.clone(), - max_texel_offset: self.max_texel_offset.clone(), - min_texel_gather_offset: self.min_texel_gather_offset.clone(), - max_texel_gather_offset: self.max_texel_gather_offset.clone(), - min_interpolation_offset: self.min_interpolation_offset.clone(), - max_interpolation_offset: self.max_interpolation_offset.clone(), - sub_pixel_interpolation_offset_bits: self.sub_pixel_interpolation_offset_bits - .clone(), - max_framebuffer_width: self.max_framebuffer_width.clone(), - max_framebuffer_height: self.max_framebuffer_height.clone(), - max_framebuffer_layers: self.max_framebuffer_layers.clone(), - framebuffer_color_sample_counts: self.framebuffer_color_sample_counts.clone(), - framebuffer_depth_sample_counts: self.framebuffer_depth_sample_counts.clone(), - framebuffer_stencil_sample_counts: self.framebuffer_stencil_sample_counts.clone(), - framebuffer_no_attachments_sample_counts: - self.framebuffer_no_attachments_sample_counts.clone(), - max_color_attachments: self.max_color_attachments.clone(), - sampled_image_color_sample_counts: self.sampled_image_color_sample_counts.clone(), - sampled_image_integer_sample_counts: self.sampled_image_integer_sample_counts - .clone(), - sampled_image_depth_sample_counts: self.sampled_image_depth_sample_counts.clone(), - sampled_image_stencil_sample_counts: self.sampled_image_stencil_sample_counts - .clone(), - storage_image_sample_counts: self.storage_image_sample_counts.clone(), - max_sample_mask_words: self.max_sample_mask_words.clone(), - timestamp_compute_and_graphics: self.timestamp_compute_and_graphics.clone(), - timestamp_period: self.timestamp_period.clone(), - max_clip_distances: self.max_clip_distances.clone(), - max_cull_distances: self.max_cull_distances.clone(), - max_combined_clip_and_cull_distances: self.max_combined_clip_and_cull_distances - .clone(), - discrete_queue_priorities: self.discrete_queue_priorities.clone(), - point_size_range: { - use std::mem; - let mut array: [_; 2] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.point_size_range[i].clone(); - } - array - }, - line_width_range: { - use std::mem; - let mut array: [_; 2] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.line_width_range[i].clone(); - } - array - }, - point_size_granularity: self.point_size_granularity.clone(), - line_width_granularity: self.line_width_granularity.clone(), - strict_lines: self.strict_lines.clone(), - standard_sample_locations: self.standard_sample_locations.clone(), - optimal_buffer_copy_offset_alignment: self.optimal_buffer_copy_offset_alignment - .clone(), - optimal_buffer_copy_row_pitch_alignment: - self.optimal_buffer_copy_row_pitch_alignment.clone(), - non_coherent_atom_size: self.non_coherent_atom_size.clone(), - } - } - } - - impl fmt::Debug for PhysicalDeviceLimits { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("PhysicalDeviceLimits") - .field("max_image_dimension1d", &self.max_image_dimension1d) - .field("max_image_dimension2d", &self.max_image_dimension2d) - .field("max_image_dimension3d", &self.max_image_dimension3d) - .field("max_image_dimension_cube", &self.max_image_dimension_cube) - .field("max_image_array_layers", &self.max_image_array_layers) - .field("max_texel_buffer_elements", &self.max_texel_buffer_elements) - .field("max_uniform_buffer_range", &self.max_uniform_buffer_range) - .field("max_storage_buffer_range", &self.max_storage_buffer_range) - .field("max_push_constants_size", &self.max_push_constants_size) - .field( - "max_memory_allocation_count", - &self.max_memory_allocation_count, - ) - .field( - "max_sampler_allocation_count", - &self.max_sampler_allocation_count, - ) - .field("buffer_image_granularity", &self.buffer_image_granularity) - .field("sparse_address_space_size", &self.sparse_address_space_size) - .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) - .field( - "max_per_stage_descriptor_samplers", - &self.max_per_stage_descriptor_samplers, - ) - .field( - "max_per_stage_descriptor_uniform_buffers", - &self.max_per_stage_descriptor_uniform_buffers, - ) - .field( - "max_per_stage_descriptor_storage_buffers", - &self.max_per_stage_descriptor_storage_buffers, - ) - .field( - "max_per_stage_descriptor_sampled_images", - &self.max_per_stage_descriptor_sampled_images, - ) - .field( - "max_per_stage_descriptor_storage_images", - &self.max_per_stage_descriptor_storage_images, - ) - .field( - "max_per_stage_descriptor_input_attachments", - &self.max_per_stage_descriptor_input_attachments, - ) - .field("max_per_stage_resources", &self.max_per_stage_resources) - .field( - "max_descriptor_set_samplers", - &self.max_descriptor_set_samplers, - ) - .field( - "max_descriptor_set_uniform_buffers", - &self.max_descriptor_set_uniform_buffers, - ) - .field( - "max_descriptor_set_uniform_buffers_dynamic", - &self.max_descriptor_set_uniform_buffers_dynamic, - ) - .field( - "max_descriptor_set_storage_buffers", - &self.max_descriptor_set_storage_buffers, - ) - .field( - "max_descriptor_set_storage_buffers_dynamic", - &self.max_descriptor_set_storage_buffers_dynamic, - ) - .field( - "max_descriptor_set_sampled_images", - &self.max_descriptor_set_sampled_images, - ) - .field( - "max_descriptor_set_storage_images", - &self.max_descriptor_set_storage_images, - ) - .field( - "max_descriptor_set_input_attachments", - &self.max_descriptor_set_input_attachments, - ) - .field( - "max_vertex_input_attributes", - &self.max_vertex_input_attributes, - ) - .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) - .field( - "max_vertex_input_attribute_offset", - &self.max_vertex_input_attribute_offset, - ) - .field( - "max_vertex_input_binding_stride", - &self.max_vertex_input_binding_stride, - ) - .field( - "max_vertex_output_components", - &self.max_vertex_output_components, - ) - .field( - "max_tessellation_generation_level", - &self.max_tessellation_generation_level, - ) - .field( - "max_tessellation_patch_size", - &self.max_tessellation_patch_size, - ) - .field( - "max_tessellation_control_per_vertex_input_components", - &self.max_tessellation_control_per_vertex_input_components, - ) - .field( - "max_tessellation_control_per_vertex_output_components", - &self.max_tessellation_control_per_vertex_output_components, - ) - .field( - "max_tessellation_control_per_patch_output_components", - &self.max_tessellation_control_per_patch_output_components, - ) - .field( - "max_tessellation_control_total_output_components", - &self.max_tessellation_control_total_output_components, - ) - .field( - "max_tessellation_evaluation_input_components", - &self.max_tessellation_evaluation_input_components, - ) - .field( - "max_tessellation_evaluation_output_components", - &self.max_tessellation_evaluation_output_components, - ) - .field( - "max_geometry_shader_invocations", - &self.max_geometry_shader_invocations, - ) - .field( - "max_geometry_input_components", - &self.max_geometry_input_components, - ) - .field( - "max_geometry_output_components", - &self.max_geometry_output_components, - ) - .field( - "max_geometry_output_vertices", - &self.max_geometry_output_vertices, - ) - .field( - "max_geometry_total_output_components", - &self.max_geometry_total_output_components, - ) - .field( - "max_fragment_input_components", - &self.max_fragment_input_components, - ) - .field( - "max_fragment_output_attachments", - &self.max_fragment_output_attachments, - ) - .field( - "max_fragment_dual_src_attachments", - &self.max_fragment_dual_src_attachments, - ) - .field( - "max_fragment_combined_output_resources", - &self.max_fragment_combined_output_resources, - ) - .field( - "max_compute_shared_memory_size", - &self.max_compute_shared_memory_size, - ) - .field( - "max_compute_work_group_count", - &&self.max_compute_work_group_count[..], - ) - .field( - "max_compute_work_group_invocations", - &self.max_compute_work_group_invocations, - ) - .field( - "max_compute_work_group_size", - &&self.max_compute_work_group_size[..], - ) - .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) - .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) - .field("mipmap_precision_bits", &self.mipmap_precision_bits) - .field( - "max_draw_indexed_index_value", - &self.max_draw_indexed_index_value, - ) - .field("max_draw_indirect_count", &self.max_draw_indirect_count) - .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) - .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) - .field("max_viewports", &self.max_viewports) - .field( - "max_viewport_dimensions", - &&self.max_viewport_dimensions[..], - ) - .field("viewport_bounds_range", &&self.viewport_bounds_range[..]) - .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) - .field("min_memory_map_alignment", &self.min_memory_map_alignment) - .field( - "min_texel_buffer_offset_alignment", - &self.min_texel_buffer_offset_alignment, - ) - .field( - "min_uniform_buffer_offset_alignment", - &self.min_uniform_buffer_offset_alignment, - ) - .field( - "min_storage_buffer_offset_alignment", - &self.min_storage_buffer_offset_alignment, - ) - .field("min_texel_offset", &self.min_texel_offset) - .field("max_texel_offset", &self.max_texel_offset) - .field("min_texel_gather_offset", &self.min_texel_gather_offset) - .field("max_texel_gather_offset", &self.max_texel_gather_offset) - .field("min_interpolation_offset", &self.min_interpolation_offset) - .field("max_interpolation_offset", &self.max_interpolation_offset) - .field( - "sub_pixel_interpolation_offset_bits", - &self.sub_pixel_interpolation_offset_bits, - ) - .field("max_framebuffer_width", &self.max_framebuffer_width) - .field("max_framebuffer_height", &self.max_framebuffer_height) - .field("max_framebuffer_layers", &self.max_framebuffer_layers) - .field( - "framebuffer_color_sample_counts", - &self.framebuffer_color_sample_counts, - ) - .field( - "framebuffer_depth_sample_counts", - &self.framebuffer_depth_sample_counts, - ) - .field( - "framebuffer_stencil_sample_counts", - &self.framebuffer_stencil_sample_counts, - ) - .field( - "framebuffer_no_attachments_sample_counts", - &self.framebuffer_no_attachments_sample_counts, - ) - .field("max_color_attachments", &self.max_color_attachments) - .field( - "sampled_image_color_sample_counts", - &self.sampled_image_color_sample_counts, - ) - .field( - "sampled_image_integer_sample_counts", - &self.sampled_image_integer_sample_counts, - ) - .field( - "sampled_image_depth_sample_counts", - &self.sampled_image_depth_sample_counts, - ) - .field( - "sampled_image_stencil_sample_counts", - &self.sampled_image_stencil_sample_counts, - ) - .field( - "storage_image_sample_counts", - &self.storage_image_sample_counts, - ) - .field("max_sample_mask_words", &self.max_sample_mask_words) - .field( - "timestamp_compute_and_graphics", - &self.timestamp_compute_and_graphics, - ) - .field("timestamp_period", &self.timestamp_period) - .field("max_clip_distances", &self.max_clip_distances) - .field("max_cull_distances", &self.max_cull_distances) - .field( - "max_combined_clip_and_cull_distances", - &self.max_combined_clip_and_cull_distances, - ) - .field("discrete_queue_priorities", &self.discrete_queue_priorities) - .field("point_size_range", &&self.point_size_range[..]) - .field("line_width_range", &&self.line_width_range[..]) - .field("point_size_granularity", &self.point_size_granularity) - .field("line_width_granularity", &self.line_width_granularity) - .field("strict_lines", &self.strict_lines) - .field("standard_sample_locations", &self.standard_sample_locations) - .field( - "optimal_buffer_copy_offset_alignment", - &self.optimal_buffer_copy_offset_alignment, - ) - .field( - "optimal_buffer_copy_row_pitch_alignment", - &self.optimal_buffer_copy_row_pitch_alignment, - ) - .field("non_coherent_atom_size", &self.non_coherent_atom_size) - .finish() - } - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct PhysicalDeviceSparseProperties { - pub residency_standard2dblock_shape: Bool32, - pub residency_standard2dmultisample_block_shape: Bool32, - pub residency_standard3dblock_shape: Bool32, - pub residency_aligned_mip_size: Bool32, - pub residency_non_resident_strict: Bool32, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct QueueFamilyProperties { - pub queue_flags: QueueFlags, - pub queue_count: uint32_t, - pub timestamp_valid_bits: uint32_t, - pub min_image_transfer_granularity: Extent3D, - } - - #[repr(C)] - pub struct PhysicalDeviceMemoryProperties { - pub memory_type_count: uint32_t, - pub memory_types: [MemoryType; VK_MAX_MEMORY_TYPES], - pub memory_heap_count: uint32_t, - pub memory_heaps: [MemoryHeap; VK_MAX_MEMORY_HEAPS], - } - - impl Clone for PhysicalDeviceMemoryProperties { - fn clone(&self) -> PhysicalDeviceMemoryProperties { - PhysicalDeviceMemoryProperties { - memory_type_count: self.memory_type_count.clone(), - memory_types: { - use std::mem; - let mut array: [_; VK_MAX_MEMORY_TYPES] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.memory_types[i].clone(); - } - array - }, - memory_heap_count: self.memory_heap_count.clone(), - memory_heaps: { - use std::mem; - let mut array: [_; VK_MAX_MEMORY_HEAPS] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.memory_heaps[i].clone(); - } - array - }, - } - } - } - - impl fmt::Debug for PhysicalDeviceMemoryProperties { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("PhysicalDeviceMemoryProperties") - .field("memory_type_count", &self.memory_type_count) - .field("memory_types", &&self.memory_types[..]) - .field("memory_heap_count", &self.memory_heap_count) - .field("memory_heaps", &&self.memory_heaps[..]) - .finish() - } - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct MemoryType { - pub property_flags: MemoryPropertyFlags, - pub heap_index: uint32_t, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct MemoryHeap { - pub size: DeviceSize, - pub flags: MemoryHeapFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DeviceCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: DeviceCreateFlags, - pub queue_create_info_count: uint32_t, - pub p_queue_create_infos: *const DeviceQueueCreateInfo, - pub enabled_layer_count: uint32_t, - pub pp_enabled_layer_names: *const *const c_char, - pub enabled_extension_count: uint32_t, - pub pp_enabled_extension_names: *const *const c_char, - pub p_enabled_features: *const PhysicalDeviceFeatures, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DeviceQueueCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: DeviceQueueCreateFlags, - pub queue_family_index: uint32_t, - pub queue_count: uint32_t, - pub p_queue_priorities: *const c_float, - } - - #[repr(C)] - pub struct ExtensionProperties { - pub extension_name: [c_char; VK_MAX_EXTENSION_NAME_SIZE], - pub spec_version: uint32_t, - } - - impl Clone for ExtensionProperties { - fn clone(&self) -> ExtensionProperties { - ExtensionProperties { - extension_name: { - use std::mem; - let mut array: [_; VK_MAX_EXTENSION_NAME_SIZE] = - unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.extension_name[i].clone(); - } - array - }, - spec_version: self.spec_version.clone(), - } - } - } - - impl fmt::Debug for ExtensionProperties { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("ExtensionProperties") - .field("extension_name", &unsafe { - CStr::from_ptr(&self.extension_name[0]) - }) - .field("spec_version", &self.spec_version) - .finish() - } - } - - #[repr(C)] - pub struct LayerProperties { - pub layer_name: [c_char; VK_MAX_EXTENSION_NAME_SIZE], - pub spec_version: uint32_t, - pub implementation_version: uint32_t, - pub description: [c_char; VK_MAX_DESCRIPTION_SIZE], - } - - impl Clone for LayerProperties { - fn clone(&self) -> LayerProperties { - LayerProperties { - layer_name: { - use std::mem; - let mut array: [_; VK_MAX_EXTENSION_NAME_SIZE] = - unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.layer_name[i].clone(); - } - array - }, - spec_version: self.spec_version.clone(), - implementation_version: self.implementation_version.clone(), - description: { - use std::mem; - let mut array: [_; VK_MAX_DESCRIPTION_SIZE] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.description[i].clone(); - } - array - }, - } - } - } - - impl fmt::Debug for LayerProperties { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("LayerProperties") - .field("layer_name", &unsafe { - CStr::from_ptr(&self.layer_name[0]) - }) - .field("spec_version", &self.spec_version) - .field("implementation_version", &self.implementation_version) - .field("description", &unsafe { - CStr::from_ptr(&self.description[0]) - }) - .finish() - } - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SubmitInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub wait_semaphore_count: uint32_t, - pub p_wait_semaphores: *const Semaphore, - pub p_wait_dst_stage_mask: *const PipelineStageFlags, - pub command_buffer_count: uint32_t, - pub p_command_buffers: *const CommandBuffer, - pub signal_semaphore_count: uint32_t, - pub p_signal_semaphores: *const Semaphore, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct MemoryAllocateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub allocation_size: DeviceSize, - pub memory_type_index: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct MappedMemoryRange { - pub s_type: StructureType, - pub p_next: *const c_void, - pub memory: DeviceMemory, - pub offset: DeviceSize, - pub size: DeviceSize, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct MemoryRequirements { - pub size: DeviceSize, - pub alignment: DeviceSize, - pub memory_type_bits: uint32_t, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct SparseImageMemoryRequirements { - pub format_properties: SparseImageFormatProperties, - pub image_mip_tail_first_lod: uint32_t, - pub image_mip_tail_size: DeviceSize, - pub image_mip_tail_offset: DeviceSize, - pub image_mip_tail_stride: DeviceSize, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct SparseImageFormatProperties { - pub aspect_mask: ImageAspectFlags, - pub image_granularity: Extent3D, - pub flags: SparseImageFormatFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct BindSparseInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub wait_semaphore_count: uint32_t, - pub p_wait_semaphores: *const Semaphore, - pub buffer_bind_count: uint32_t, - pub p_buffer_binds: *const SparseBufferMemoryBindInfo, - pub image_opaque_bind_count: uint32_t, - pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo, - pub image_bind_count: uint32_t, - pub p_image_binds: *const SparseImageMemoryBindInfo, - pub signal_semaphore_count: uint32_t, - pub p_signal_semaphores: *const Semaphore, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SparseBufferMemoryBindInfo { - pub buffer: Buffer, - pub bind_count: uint32_t, - pub p_binds: *const SparseMemoryBind, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct SparseMemoryBind { - pub resource_offset: DeviceSize, - pub size: DeviceSize, - pub memory: DeviceMemory, - pub memory_offset: DeviceSize, - pub flags: SparseMemoryBindFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SparseImageOpaqueMemoryBindInfo { - pub image: Image, - pub bind_count: uint32_t, - pub p_binds: *const SparseMemoryBind, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SparseImageMemoryBindInfo { - pub image: Image, - pub bind_count: uint32_t, - pub p_binds: *const SparseImageMemoryBind, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SparseImageMemoryBind { - pub subresource: ImageSubresource, - pub offset: Offset3D, - pub extent: Extent3D, - pub memory: DeviceMemory, - pub memory_offset: DeviceSize, - pub flags: SparseMemoryBindFlags, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct ImageSubresource { - pub aspect_mask: ImageAspectFlags, - pub mip_level: uint32_t, - pub array_layer: uint32_t, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct Offset3D { - pub x: int32_t, - pub y: int32_t, - pub z: int32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct FenceCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: FenceCreateFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SemaphoreCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: SemaphoreCreateFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct EventCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: EventCreateFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct QueryPoolCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: QueryPoolCreateFlags, - pub query_type: QueryType, - pub query_count: uint32_t, - pub pipeline_statistics: QueryPipelineStatisticFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct BufferCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: BufferCreateFlags, - pub size: DeviceSize, - pub usage: BufferUsageFlags, - pub sharing_mode: SharingMode, - pub queue_family_index_count: uint32_t, - pub p_queue_family_indices: *const uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct BufferViewCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: BufferViewCreateFlags, - pub buffer: Buffer, - pub format: Format, - pub offset: DeviceSize, - pub range: DeviceSize, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct ImageCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: ImageCreateFlags, - pub image_type: ImageType, - pub format: Format, - pub extent: Extent3D, - pub mip_levels: uint32_t, - pub array_layers: uint32_t, - pub samples: SampleCountFlags, - pub tiling: ImageTiling, - pub usage: ImageUsageFlags, - pub sharing_mode: SharingMode, - pub queue_family_index_count: uint32_t, - pub p_queue_family_indices: *const uint32_t, - pub initial_layout: ImageLayout, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct SubresourceLayout { - pub offset: DeviceSize, - pub size: DeviceSize, - pub row_pitch: DeviceSize, - pub array_pitch: DeviceSize, - pub depth_pitch: DeviceSize, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct ImageViewCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: ImageViewCreateFlags, - pub image: Image, - pub view_type: ImageViewType, - pub format: Format, - pub components: ComponentMapping, - pub subresource_range: ImageSubresourceRange, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct ComponentMapping { - pub r: ComponentSwizzle, - pub g: ComponentSwizzle, - pub b: ComponentSwizzle, - pub a: ComponentSwizzle, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct ImageSubresourceRange { - pub aspect_mask: ImageAspectFlags, - pub base_mip_level: uint32_t, - pub level_count: uint32_t, - pub base_array_layer: uint32_t, - pub layer_count: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct ShaderModuleCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: ShaderModuleCreateFlags, - pub code_size: size_t, - pub p_code: *const uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineCacheCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineCacheCreateFlags, - pub initial_data_size: size_t, - pub p_initial_data: *const c_void, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct GraphicsPipelineCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineCreateFlags, - pub stage_count: uint32_t, - pub p_stages: *const PipelineShaderStageCreateInfo, - pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, - pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo, - pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, - pub p_viewport_state: *const PipelineViewportStateCreateInfo, - pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo, - pub p_multisample_state: *const PipelineMultisampleStateCreateInfo, - pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo, - pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo, - pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, - pub layout: PipelineLayout, - pub render_pass: RenderPass, - pub subpass: uint32_t, - pub base_pipeline_handle: Pipeline, - pub base_pipeline_index: int32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineShaderStageCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineShaderStageCreateFlags, - pub stage: ShaderStageFlags, - pub module: ShaderModule, - pub p_name: *const c_char, - pub p_specialization_info: *const SpecializationInfo, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SpecializationInfo { - pub map_entry_count: uint32_t, - pub p_map_entries: *const SpecializationMapEntry, - pub data_size: size_t, - pub p_data: *const c_void, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct SpecializationMapEntry { - pub constant_id: uint32_t, - pub offset: uint32_t, - pub size: size_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineVertexInputStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineVertexInputStateCreateFlags, - pub vertex_binding_description_count: uint32_t, - pub p_vertex_binding_descriptions: *const VertexInputBindingDescription, - pub vertex_attribute_description_count: uint32_t, - pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct VertexInputBindingDescription { - pub binding: uint32_t, - pub stride: uint32_t, - pub input_rate: VertexInputRate, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct VertexInputAttributeDescription { - pub location: uint32_t, - pub binding: uint32_t, - pub format: Format, - pub offset: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineInputAssemblyStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineInputAssemblyStateCreateFlags, - pub topology: PrimitiveTopology, - pub primitive_restart_enable: Bool32, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineTessellationStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineTessellationStateCreateFlags, - pub patch_control_points: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineViewportStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineViewportStateCreateFlags, - pub viewport_count: uint32_t, - pub p_viewports: *const Viewport, - pub scissor_count: uint32_t, - pub p_scissors: *const Rect2D, - } - - #[derive(Debug, Clone, Copy)] - #[repr(C)] - pub struct Viewport { - pub x: c_float, - pub y: c_float, - pub width: c_float, - pub height: c_float, - pub min_depth: c_float, - pub max_depth: c_float, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct Rect2D { - pub offset: Offset2D, - pub extent: Extent2D, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct Offset2D { - pub x: int32_t, - pub y: int32_t, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct Extent2D { - pub width: uint32_t, - pub height: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineRasterizationStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineRasterizationStateCreateFlags, - pub depth_clamp_enable: Bool32, - pub rasterizer_discard_enable: Bool32, - pub polygon_mode: PolygonMode, - pub cull_mode: CullModeFlags, - pub front_face: FrontFace, - pub depth_bias_enable: Bool32, - pub depth_bias_constant_factor: c_float, - pub depth_bias_clamp: c_float, - pub depth_bias_slope_factor: c_float, - pub line_width: c_float, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineMultisampleStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineMultisampleStateCreateFlags, - pub rasterization_samples: SampleCountFlags, - pub sample_shading_enable: Bool32, - pub min_sample_shading: c_float, - pub p_sample_mask: *const SampleMask, - pub alpha_to_coverage_enable: Bool32, - pub alpha_to_one_enable: Bool32, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineDepthStencilStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineDepthStencilStateCreateFlags, - pub depth_test_enable: Bool32, - pub depth_write_enable: Bool32, - pub depth_compare_op: CompareOp, - pub depth_bounds_test_enable: Bool32, - pub stencil_test_enable: Bool32, - pub front: StencilOpState, - pub back: StencilOpState, - pub min_depth_bounds: c_float, - pub max_depth_bounds: c_float, - } - - #[derive(Debug, Clone, Copy)] - #[repr(C)] - pub struct StencilOpState { - pub fail_op: StencilOp, - pub pass_op: StencilOp, - pub depth_fail_op: StencilOp, - pub compare_op: CompareOp, - pub compare_mask: uint32_t, - pub write_mask: uint32_t, - pub reference: uint32_t, - } - - #[repr(C)] - pub struct PipelineColorBlendStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineColorBlendStateCreateFlags, - pub logic_op_enable: Bool32, - pub logic_op: LogicOp, - pub attachment_count: uint32_t, - pub p_attachments: *const PipelineColorBlendAttachmentState, - pub blend_constants: [c_float; 4], - } - - impl Clone for PipelineColorBlendStateCreateInfo { - fn clone(&self) -> PipelineColorBlendStateCreateInfo { - PipelineColorBlendStateCreateInfo { - s_type: self.s_type.clone(), - p_next: self.p_next.clone(), - flags: self.flags.clone(), - logic_op_enable: self.logic_op_enable.clone(), - logic_op: self.logic_op.clone(), - attachment_count: self.attachment_count.clone(), - p_attachments: self.p_attachments.clone(), - blend_constants: { - use std::mem; - let mut array: [_; 4] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.blend_constants[i].clone(); - } - array - }, - } - } - } - - impl fmt::Debug for PipelineColorBlendStateCreateInfo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("PipelineColorBlendStateCreateInfo") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("flags", &self.flags) - .field("logic_op_enable", &self.logic_op_enable) - .field("logic_op", &self.logic_op) - .field("attachment_count", &self.attachment_count) - .field("p_attachments", &self.p_attachments) - .field("blend_constants", &&self.blend_constants[..]) - .finish() - } - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct PipelineColorBlendAttachmentState { - pub blend_enable: Bool32, - pub src_color_blend_factor: BlendFactor, - pub dst_color_blend_factor: BlendFactor, - pub color_blend_op: BlendOp, - pub src_alpha_blend_factor: BlendFactor, - pub dst_alpha_blend_factor: BlendFactor, - pub alpha_blend_op: BlendOp, - pub color_write_mask: ColorComponentFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineDynamicStateCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineDynamicStateCreateFlags, - pub dynamic_state_count: uint32_t, - pub p_dynamic_states: *const DynamicState, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct ComputePipelineCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineCreateFlags, - pub stage: PipelineShaderStageCreateInfo, - pub layout: PipelineLayout, - pub base_pipeline_handle: Pipeline, - pub base_pipeline_index: int32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PipelineLayoutCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: PipelineLayoutCreateFlags, - pub set_layout_count: uint32_t, - pub p_set_layouts: *const DescriptorSetLayout, - pub push_constant_range_count: uint32_t, - pub p_push_constant_ranges: *const PushConstantRange, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct PushConstantRange { - pub stage_flags: ShaderStageFlags, - pub offset: uint32_t, - pub size: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SamplerCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: SamplerCreateFlags, - pub mag_filter: Filter, - pub min_filter: Filter, - pub mipmap_mode: SamplerMipmapMode, - pub address_mode_u: SamplerAddressMode, - pub address_mode_v: SamplerAddressMode, - pub address_mode_w: SamplerAddressMode, - pub mip_lod_bias: c_float, - pub anisotropy_enable: Bool32, - pub max_anisotropy: c_float, - pub compare_enable: Bool32, - pub compare_op: CompareOp, - pub min_lod: c_float, - pub max_lod: c_float, - pub border_color: BorderColor, - pub unnormalized_coordinates: Bool32, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DescriptorSetLayoutCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: DescriptorSetLayoutCreateFlags, - pub binding_count: uint32_t, - pub p_bindings: *const DescriptorSetLayoutBinding, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DescriptorSetLayoutBinding { - pub binding: uint32_t, - pub descriptor_type: DescriptorType, - pub descriptor_count: uint32_t, - pub stage_flags: ShaderStageFlags, - pub p_immutable_samplers: *const Sampler, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DescriptorPoolCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: DescriptorPoolCreateFlags, - pub max_sets: uint32_t, - pub pool_size_count: uint32_t, - pub p_pool_sizes: *const DescriptorPoolSize, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct DescriptorPoolSize { - pub typ: DescriptorType, - pub descriptor_count: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DescriptorSetAllocateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub descriptor_pool: DescriptorPool, - pub descriptor_set_count: uint32_t, - pub p_set_layouts: *const DescriptorSetLayout, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct WriteDescriptorSet { - pub s_type: StructureType, - pub p_next: *const c_void, - pub dst_set: DescriptorSet, - pub dst_binding: uint32_t, - pub dst_array_element: uint32_t, - pub descriptor_count: uint32_t, - pub descriptor_type: DescriptorType, - pub p_image_info: *const DescriptorImageInfo, - pub p_buffer_info: *const DescriptorBufferInfo, - pub p_texel_buffer_view: *const BufferView, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct DescriptorImageInfo { - pub sampler: Sampler, - pub image_view: ImageView, - pub image_layout: ImageLayout, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DescriptorBufferInfo { - pub buffer: Buffer, - pub offset: DeviceSize, - pub range: DeviceSize, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct CopyDescriptorSet { - pub s_type: StructureType, - pub p_next: *const c_void, - pub src_set: DescriptorSet, - pub src_binding: uint32_t, - pub src_array_element: uint32_t, - pub dst_set: DescriptorSet, - pub dst_binding: uint32_t, - pub dst_array_element: uint32_t, - pub descriptor_count: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct FramebufferCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: FramebufferCreateFlags, - pub render_pass: RenderPass, - pub attachment_count: uint32_t, - pub p_attachments: *const ImageView, - pub width: uint32_t, - pub height: uint32_t, - pub layers: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct RenderPassCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: RenderPassCreateFlags, - pub attachment_count: uint32_t, - pub p_attachments: *const AttachmentDescription, - pub subpass_count: uint32_t, - pub p_subpasses: *const SubpassDescription, - pub dependency_count: uint32_t, - pub p_dependencies: *const SubpassDependency, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct AttachmentDescription { - pub flags: AttachmentDescriptionFlags, - pub format: Format, - pub samples: SampleCountFlags, - pub load_op: AttachmentLoadOp, - pub store_op: AttachmentStoreOp, - pub stencil_load_op: AttachmentLoadOp, - pub stencil_store_op: AttachmentStoreOp, - pub initial_layout: ImageLayout, - pub final_layout: ImageLayout, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SubpassDescription { - pub flags: SubpassDescriptionFlags, - pub pipeline_bind_point: PipelineBindPoint, - pub input_attachment_count: uint32_t, - pub p_input_attachments: *const AttachmentReference, - pub color_attachment_count: uint32_t, - pub p_color_attachments: *const AttachmentReference, - pub p_resolve_attachments: *const AttachmentReference, - pub p_depth_stencil_attachment: *const AttachmentReference, - pub preserve_attachment_count: uint32_t, - pub p_preserve_attachments: *const uint32_t, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct AttachmentReference { - pub attachment: uint32_t, - pub layout: ImageLayout, - } - - #[derive(Debug, Clone, Hash)] - #[repr(C)] - pub struct SubpassDependency { - pub src_subpass: uint32_t, - pub dst_subpass: uint32_t, - pub src_stage_mask: PipelineStageFlags, - pub dst_stage_mask: PipelineStageFlags, - pub src_access_mask: AccessFlags, - pub dst_access_mask: AccessFlags, - pub dependency_flags: DependencyFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct CommandPoolCreateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: CommandPoolCreateFlags, - pub queue_family_index: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct CommandBufferAllocateInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub command_pool: CommandPool, - pub level: CommandBufferLevel, - pub command_buffer_count: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct CommandBufferBeginInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: CommandBufferUsageFlags, - pub p_inheritance_info: *const CommandBufferInheritanceInfo, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct CommandBufferInheritanceInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub render_pass: RenderPass, - pub subpass: uint32_t, - pub framebuffer: Framebuffer, - pub occlusion_query_enable: Bool32, - pub query_flags: QueryControlFlags, - pub pipeline_statistics: QueryPipelineStatisticFlags, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct BufferCopy { - pub src_offset: DeviceSize, - pub dst_offset: DeviceSize, - pub size: DeviceSize, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct ImageCopy { - pub src_subresource: ImageSubresourceLayers, - pub src_offset: Offset3D, - pub dst_subresource: ImageSubresourceLayers, - pub dst_offset: Offset3D, - pub extent: Extent3D, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct ImageSubresourceLayers { - pub aspect_mask: ImageAspectFlags, - pub mip_level: uint32_t, - pub base_array_layer: uint32_t, - pub layer_count: uint32_t, - } - - #[repr(C)] - pub struct ImageBlit { - pub src_subresource: ImageSubresourceLayers, - pub src_offsets: [Offset3D; 2], - pub dst_subresource: ImageSubresourceLayers, - pub dst_offsets: [Offset3D; 2], - } - - impl Clone for ImageBlit { - fn clone(&self) -> ImageBlit { - ImageBlit { - src_subresource: self.src_subresource.clone(), - src_offsets: { - use std::mem; - let mut array: [_; 2] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.src_offsets[i].clone(); - } - array - }, - dst_subresource: self.dst_subresource.clone(), - dst_offsets: { - use std::mem; - let mut array: [_; 2] = unsafe { mem::uninitialized() }; - - for (i, e) in array[..].iter_mut().enumerate() { - *e = self.dst_offsets[i].clone(); - } - array - }, - } - } - } - - impl fmt::Debug for ImageBlit { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("ImageBlit") - .field("src_subresource", &self.src_subresource) - .field("src_offsets", &&self.src_offsets[..]) - .field("dst_subresource", &self.dst_subresource) - .field("dst_offsets", &&self.dst_offsets[..]) - .finish() - } - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct BufferImageCopy { - pub buffer_offset: DeviceSize, - pub buffer_row_length: uint32_t, - pub buffer_image_height: uint32_t, - pub image_subresource: ImageSubresourceLayers, - pub image_offset: Offset3D, - pub image_extent: Extent3D, - } - - #[derive(Debug, Clone, Copy)] - #[repr(C)] - pub struct ClearDepthStencilValue { - pub depth: c_float, - pub stencil: uint32_t, - } - - #[repr(C)] - pub struct ClearAttachment { - pub aspect_mask: ImageAspectFlags, - pub color_attachment: uint32_t, - pub clear_value: ClearValue, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct ClearRect { - pub rect: Rect2D, - pub base_array_layer: uint32_t, - pub layer_count: uint32_t, - } - - #[derive(Debug, Clone, Copy, Hash)] - #[repr(C)] - pub struct ImageResolve { - pub src_subresource: ImageSubresourceLayers, - pub src_offset: Offset3D, - pub dst_subresource: ImageSubresourceLayers, - pub dst_offset: Offset3D, - pub extent: Extent3D, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct MemoryBarrier { - pub s_type: StructureType, - pub p_next: *const c_void, - pub src_access_mask: AccessFlags, - pub dst_access_mask: AccessFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct BufferMemoryBarrier { - pub s_type: StructureType, - pub p_next: *const c_void, - pub src_access_mask: AccessFlags, - pub dst_access_mask: AccessFlags, - pub src_queue_family_index: uint32_t, - pub dst_queue_family_index: uint32_t, - pub buffer: Buffer, - pub offset: DeviceSize, - pub size: DeviceSize, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct ImageMemoryBarrier { - pub s_type: StructureType, - pub p_next: *const c_void, - pub src_access_mask: AccessFlags, - pub dst_access_mask: AccessFlags, - pub old_layout: ImageLayout, - pub new_layout: ImageLayout, - pub src_queue_family_index: uint32_t, - pub dst_queue_family_index: uint32_t, - pub image: Image, - pub subresource_range: ImageSubresourceRange, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct RenderPassBeginInfo { - pub s_type: StructureType, - pub p_next: *const c_void, - pub render_pass: RenderPass, - pub framebuffer: Framebuffer, - pub render_area: Rect2D, - pub clear_value_count: uint32_t, - pub p_clear_values: *const ClearValue, - } - - #[derive(Debug, Clone, Copy)] - #[repr(C)] - pub struct DispatchIndirectCommand { - pub x: uint32_t, - pub y: uint32_t, - pub z: uint32_t, - } - - #[derive(Debug, Clone, Copy)] - #[repr(C)] - pub struct DrawIndexedIndirectCommand { - pub index_count: uint32_t, - pub instance_count: uint32_t, - pub first_index: uint32_t, - pub vertex_offset: int32_t, - pub first_instance: uint32_t, - } - - #[derive(Debug, Clone, Copy)] - #[repr(C)] - pub struct DrawIndirectCommand { - pub vertex_count: uint32_t, - pub instance_count: uint32_t, - pub first_vertex: uint32_t, - pub first_instance: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SurfaceCapabilitiesKHR { - pub min_image_count: uint32_t, - pub max_image_count: uint32_t, - pub current_extent: Extent2D, - pub min_image_extent: Extent2D, - pub max_image_extent: Extent2D, - pub max_image_array_layers: uint32_t, - pub supported_transforms: SurfaceTransformFlagsKHR, - pub current_transform: SurfaceTransformFlagsKHR, - pub supported_composite_alpha: CompositeAlphaFlagsKHR, - pub supported_usage_flags: ImageUsageFlags, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SurfaceFormatKHR { - pub format: Format, - pub color_space: ColorSpaceKHR, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct XlibSurfaceCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: XlibSurfaceCreateFlagsKHR, - pub dpy: *mut Display, - pub window: Window, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct XcbSurfaceCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: XcbSurfaceCreateFlagsKHR, - pub connection: *mut xcb_connection_t, - pub window: xcb_window_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct MirSurfaceCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: MirSurfaceCreateFlagsKHR, - pub connection: *mut MirConnection, - pub mir_surface: *mut MirSurface, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct Win32SurfaceCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: Win32SurfaceCreateFlagsKHR, - pub hinstance: HINSTANCE, - pub hwnd: HWND, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct AndroidSurfaceCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: AndroidSurfaceCreateFlagsKHR, - pub window: *mut ANativeWindow, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct WaylandSurfaceCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: WaylandSurfaceCreateFlagsKHR, - pub display: *mut wl_display, - pub surface: *mut wl_surface, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct SwapchainCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: SwapchainCreateFlagsKHR, - pub surface: SurfaceKHR, - pub min_image_count: uint32_t, - pub image_format: Format, - pub image_color_space: ColorSpaceKHR, - pub image_extent: Extent2D, - pub image_array_layers: uint32_t, - pub image_usage: ImageUsageFlags, - pub image_sharing_mode: SharingMode, - pub queue_family_index_count: uint32_t, - pub p_queue_family_indices: *const uint32_t, - pub pre_transform: SurfaceTransformFlagsKHR, - pub composite_alpha: CompositeAlphaFlagsKHR, - pub present_mode: PresentModeKHR, - pub clipped: Bool32, - pub old_swapchain: SwapchainKHR, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct PresentInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub wait_semaphore_count: uint32_t, - pub p_wait_semaphores: *const Semaphore, - pub swapchain_count: uint32_t, - pub p_swapchains: *const SwapchainKHR, - pub p_image_indices: *const uint32_t, - pub p_results: *mut Result, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplayPresentInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub src_rect: Rect2D, - pub dst_rect: Rect2D, - pub persistent: Bool32, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplayPropertiesKHR { - pub display: DisplayKHR, - pub display_name: *const c_char, - pub physical_dimensions: Extent2D, - pub physical_resolution: Extent2D, - pub supported_transforms: SurfaceTransformFlagsKHR, - pub plane_reorder_possible: Bool32, - pub persistent_content: Bool32, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplayModeParametersKHR { - pub visible_region: Extent2D, - pub refresh_rate: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplayModePropertiesKHR { - pub display_mode: DisplayModeKHR, - pub parameters: DisplayModeParametersKHR, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplayModeCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: DisplayModeCreateFlagsKHR, - pub parameters: DisplayModeParametersKHR, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplayPlaneCapabilitiesKHR { - pub supported_alpha: DisplayPlaneAlphaFlagsKHR, - pub min_src_position: Offset2D, - pub max_src_position: Offset2D, - pub min_src_extent: Extent2D, - pub max_src_extent: Extent2D, - pub min_dst_position: Offset2D, - pub max_dst_position: Offset2D, - pub min_dst_extent: Extent2D, - pub max_dst_extent: Extent2D, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplayPlanePropertiesKHR { - pub current_display: DisplayKHR, - pub current_stack_index: uint32_t, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct DisplaySurfaceCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: DisplaySurfaceCreateFlagsKHR, - pub display_mode: DisplayModeKHR, - pub plane_index: uint32_t, - pub plane_stack_index: uint32_t, - pub transform: SurfaceTransformFlagsKHR, - pub global_alpha: c_float, - pub alpha_mode: DisplayPlaneAlphaFlagsKHR, - pub image_extent: Extent2D, - } - - #[repr(C)] - pub struct DebugMarkerObjectNameInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub object_type: DebugReportObjectTypeEXT, - pub object: uint64_t, - pub p_object_name: *const c_char, - } - - #[repr(C)] - pub struct DebugMarkerMarkerInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub p_marker_name: *const c_char, - pub color: [f32; 4], - } - - #[repr(C)] - pub struct DebugReportCallbackCreateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: DebugReportFlagsEXT, - pub pfn_callback: PFN_vkDebugReportCallbackEXT, - pub p_user_data: *mut c_void, - } - - impl Clone for DebugReportCallbackCreateInfoEXT { - fn clone(&self) -> DebugReportCallbackCreateInfoEXT { - DebugReportCallbackCreateInfoEXT { - s_type: self.s_type.clone(), - p_next: self.p_next.clone(), - flags: self.flags.clone(), - pfn_callback: self.pfn_callback, - p_user_data: self.p_user_data.clone(), - } - } - } - - impl fmt::Debug for DebugReportCallbackCreateInfoEXT { - fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { - fmt.debug_struct("DebugReportCallbackCreateInfoEXT") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("flags", &self.flags) - .field("pfn_callback", &(self.pfn_callback as *const ())) - .field("p_user_data", &self.p_user_data) - .finish() - } - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct IOSSurfaceCreateInfoMVK { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: IOSSurfaceCreateFlagsMVK, - pub p_view: *const c_void, - } - - #[derive(Debug, Clone)] - #[repr(C)] - pub struct MacOSSurfaceCreateInfoMVK { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: MacOSSurfaceCreateFlagsMVK, - pub p_view: *const c_void, - } - - #[repr(C)] - #[derive(Copy, Clone)] - pub union ClearValue { - pub depth: ClearDepthStencilValue, - pub color: ClearColorValue, - } - - #[repr(C)] - #[derive(Copy, Clone)] - pub union ClearColorValue { - pub float32: [f32; 4], - pub int32: [i32; 4], - pub uint32: [u32; 4], - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum PipelineCacheHeaderVersion { - One = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum StructureType { - ApplicationInfo = 0, - InstanceCreateInfo = 1, - DeviceQueueCreateInfo = 2, - DeviceCreateInfo = 3, - SubmitInfo = 4, - MemoryAllocateInfo = 5, - MappedMemoryRange = 6, - BindSparseInfo = 7, - FenceCreateInfo = 8, - SemaphoreCreateInfo = 9, - EventCreateInfo = 10, - QueryPoolCreateInfo = 11, - BufferCreateInfo = 12, - BufferViewCreateInfo = 13, - ImageCreateInfo = 14, - ImageViewCreateInfo = 15, - ShaderModuleCreateInfo = 16, - PipelineCacheCreateInfo = 17, - PipelineShaderStageCreateInfo = 18, - PipelineVertexInputStateCreateInfo = 19, - PipelineInputAssemblyStateCreateInfo = 20, - PipelineTessellationStateCreateInfo = 21, - PipelineViewportStateCreateInfo = 22, - PipelineRasterizationStateCreateInfo = 23, - PipelineMultisampleStateCreateInfo = 24, - PipelineDepthStencilStateCreateInfo = 25, - PipelineColorBlendStateCreateInfo = 26, - PipelineDynamicStateCreateInfo = 27, - GraphicsPipelineCreateInfo = 28, - ComputePipelineCreateInfo = 29, - PipelineLayoutCreateInfo = 30, - SamplerCreateInfo = 31, - DescriptorSetLayoutCreateInfo = 32, - DescriptorPoolCreateInfo = 33, - DescriptorSetAllocateInfo = 34, - WriteDescriptorSet = 35, - CopyDescriptorSet = 36, - FramebufferCreateInfo = 37, - RenderPassCreateInfo = 38, - CommandPoolCreateInfo = 39, - CommandBufferAllocateInfo = 40, - CommandBufferInheritanceInfo = 41, - CommandBufferBeginInfo = 42, - RenderPassBeginInfo = 43, - BufferMemoryBarrier = 44, - ImageMemoryBarrier = 45, - MemoryBarrier = 46, - LoaderInstanceCreateInfo = 47, - LoaderDeviceCreateInfo = 48, - XlibSurfaceCreateInfoKhr = 1000004000, - XcbSurfaceCreateInfoKhr = 1000005000, - MirSurfaceCreateInfoKhr = 1000007000, - Win32SurfaceCreateInfoKhr = 1000009000, - AndroidSurfaceCreateInfoKhr = 1000008000, - WaylandSurfaceCreateInfoKhr = 1000006000, - SwapchainCreateInfoKhr = 1000001000, - PresentInfoKhr = 1000001001, - DisplayPresentInfoKhr = 1000003000, - DisplayModeCreateInfoKhr = 1000002000, - DisplaySurfaceCreateInfoKhr = 1000002001, - DebugMarkerObjectNameInfoEXT = 1000022000, - DebugMarkerMarkerInfoEXT = 1000022002, - DebugReportCallbackCreateInfoExt = 1000011000, - IOSSurfaceCreateInfoMvk = 1000122000, - MacOSSurfaceCreateInfoMvk = 1000123000, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum SystemAllocationScope { - Command = 0, - Object = 1, - Cache = 2, - Device = 3, - Instance = 4, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum InternalAllocationType { - Executable = 0, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum Result { - Success = 0, - NotReady = 1, - Timeout = 2, - EventSet = 3, - EventReset = 4, - Incomplete = 5, - ErrorOutOfHostMemory = -1, - ErrorOutOfDeviceMemory = -2, - ErrorInitializationFailed = -3, - ErrorDeviceLost = -4, - ErrorMemoryMapFailed = -5, - ErrorLayerNotPresent = -6, - ErrorExtensionNotPresent = -7, - ErrorFeatureNotPresent = -8, - ErrorIncompatibleDriver = -9, - ErrorTooManyObjects = -10, - ErrorFormatNotSupported = -11, - ErrorFragmentedPool = -12, - ErrorSurfaceLostKhr = -1000000000, - ErrorNativeWindowInUseKhr = -1000000001, - SuboptimalKhr = 1000001003, - ErrorOutOfDateKhr = -1000001004, - ErrorIncompatibleDisplayKhr = -1000003001, - ErrorValidationFailedExt = -1000011001, - } - - impl fmt::Display for Result { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - writeln!(fmt, "vk::Result::{:?}", self)?; - match *self { - Result::Success => write!(fmt, "Command successfully completed"), - Result::NotReady => write!(fmt, "A fence or query has not yet completed"), - Result::Timeout => { - write!( - fmt, - "A wait operation has not completed in the specified time" - ) +impl StaticFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = StaticFn { + get_instance_proc_addr: unsafe { + let raw_name = stringify!(vkGetInstanceProcAddr); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); } - Result::EventSet => write!(fmt, "An event is signaled"), - Result::EventReset => write!(fmt, "An event is unsignaled"), - Result::Incomplete => write!(fmt, "A return array was too small for the result"), - Result::ErrorOutOfHostMemory => write!(fmt, "A host memory allocation has failed."), - Result::ErrorOutOfDeviceMemory => { - write!(fmt, "A device memory allocation has failed.") - } - Result::ErrorInitializationFailed => { - write!( - fmt, - "Initialization of an object could not be completed for implementation-specific reasons." - ) - } - Result::ErrorDeviceLost => { - write!( - fmt, - "The logical or physical device has been lost. See Lost Device" - ) - } - Result::ErrorMemoryMapFailed => { - write!(fmt, "Mapping of a memory object has failed.") - } - Result::ErrorLayerNotPresent => { - write!( - fmt, - "A requested layer is not present or could not be loaded." - ) - } - Result::ErrorExtensionNotPresent => { - write!(fmt, "A requested extension is not supported.") - } - Result::ErrorFeatureNotPresent => { - write!(fmt, "A requested feature is not supported.") - } - Result::ErrorIncompatibleDriver => { - write!( - fmt, - "The requested version of Vulkan is not supported by the driver or is otherwise incompatible for implementation-specific reasons." - ) - } - Result::ErrorTooManyObjects => { - write!( - fmt, - "Too many objects of the type have already been created." - ) - } - - Result::ErrorFormatNotSupported => { - write!(fmt, "A requested format is not supported on this device.") - } - Result::ErrorFragmentedPool => { - write!( - fmt, - "A pool allocation has failed due to fragmentation of the pool’s memory. This must only be returned if no attempt to allocate host or device memory was made to accomodate the new allocation." - ) - } - _ => write!(fmt, ""), - } - } - } - - impl Error for Result { - fn description(&self) -> &str { - "vk::Result" - } - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum Format { - Undefined = 0, - R4g4UnormPack8 = 1, - R4g4b4a4UnormPack16 = 2, - B4g4r4a4UnormPack16 = 3, - R5g6b5UnormPack16 = 4, - B5g6r5UnormPack16 = 5, - R5g5b5a1UnormPack16 = 6, - B5g5r5a1UnormPack16 = 7, - A1r5g5b5UnormPack16 = 8, - R8Unorm = 9, - R8Snorm = 10, - R8Uscaled = 11, - R8Sscaled = 12, - R8Uint = 13, - R8Sint = 14, - R8Srgb = 15, - R8g8Unorm = 16, - R8g8Snorm = 17, - R8g8Uscaled = 18, - R8g8Sscaled = 19, - R8g8Uint = 20, - R8g8Sint = 21, - R8g8Srgb = 22, - R8g8b8Unorm = 23, - R8g8b8Snorm = 24, - R8g8b8Uscaled = 25, - R8g8b8Sscaled = 26, - R8g8b8Uint = 27, - R8g8b8Sint = 28, - R8g8b8Srgb = 29, - B8g8r8Unorm = 30, - B8g8r8Snorm = 31, - B8g8r8Uscaled = 32, - B8g8r8Sscaled = 33, - B8g8r8Uint = 34, - B8g8r8Sint = 35, - B8g8r8Srgb = 36, - R8g8b8a8Unorm = 37, - R8g8b8a8Snorm = 38, - R8g8b8a8Uscaled = 39, - R8g8b8a8Sscaled = 40, - R8g8b8a8Uint = 41, - R8g8b8a8Sint = 42, - R8g8b8a8Srgb = 43, - B8g8r8a8Unorm = 44, - B8g8r8a8Snorm = 45, - B8g8r8a8Uscaled = 46, - B8g8r8a8Sscaled = 47, - B8g8r8a8Uint = 48, - B8g8r8a8Sint = 49, - B8g8r8a8Srgb = 50, - A8b8g8r8UnormPack32 = 51, - A8b8g8r8SnormPack32 = 52, - A8b8g8r8UscaledPack32 = 53, - A8b8g8r8SscaledPack32 = 54, - A8b8g8r8UintPack32 = 55, - A8b8g8r8SintPack32 = 56, - A8b8g8r8SrgbPack32 = 57, - A2r10g10b10UnormPack32 = 58, - A2r10g10b10SnormPack32 = 59, - A2r10g10b10UscaledPack32 = 60, - A2r10g10b10SscaledPack32 = 61, - A2r10g10b10UintPack32 = 62, - A2r10g10b10SintPack32 = 63, - A2b10g10r10UnormPack32 = 64, - A2b10g10r10SnormPack32 = 65, - A2b10g10r10UscaledPack32 = 66, - A2b10g10r10SscaledPack32 = 67, - A2b10g10r10UintPack32 = 68, - A2b10g10r10SintPack32 = 69, - R16Unorm = 70, - R16Snorm = 71, - R16Uscaled = 72, - R16Sscaled = 73, - R16Uint = 74, - R16Sint = 75, - R16Sfloat = 76, - R16g16Unorm = 77, - R16g16Snorm = 78, - R16g16Uscaled = 79, - R16g16Sscaled = 80, - R16g16Uint = 81, - R16g16Sint = 82, - R16g16Sfloat = 83, - R16g16b16Unorm = 84, - R16g16b16Snorm = 85, - R16g16b16Uscaled = 86, - R16g16b16Sscaled = 87, - R16g16b16Uint = 88, - R16g16b16Sint = 89, - R16g16b16Sfloat = 90, - R16g16b16a16Unorm = 91, - R16g16b16a16Snorm = 92, - R16g16b16a16Uscaled = 93, - R16g16b16a16Sscaled = 94, - R16g16b16a16Uint = 95, - R16g16b16a16Sint = 96, - R16g16b16a16Sfloat = 97, - R32Uint = 98, - R32Sint = 99, - R32Sfloat = 100, - R32g32Uint = 101, - R32g32Sint = 102, - R32g32Sfloat = 103, - R32g32b32Uint = 104, - R32g32b32Sint = 105, - R32g32b32Sfloat = 106, - R32g32b32a32Uint = 107, - R32g32b32a32Sint = 108, - R32g32b32a32Sfloat = 109, - R64Uint = 110, - R64Sint = 111, - R64Sfloat = 112, - R64g64Uint = 113, - R64g64Sint = 114, - R64g64Sfloat = 115, - R64g64b64Uint = 116, - R64g64b64Sint = 117, - R64g64b64Sfloat = 118, - R64g64b64a64Uint = 119, - R64g64b64a64Sint = 120, - R64g64b64a64Sfloat = 121, - B10g11r11UfloatPack32 = 122, - E5b9g9r9UfloatPack32 = 123, - D16Unorm = 124, - X8D24UnormPack32 = 125, - D32Sfloat = 126, - S8Uint = 127, - D16UnormS8Uint = 128, - D24UnormS8Uint = 129, - D32SfloatS8Uint = 130, - Bc1RgbUnormBlock = 131, - Bc1RgbSrgbBlock = 132, - Bc1RgbaUnormBlock = 133, - Bc1RgbaSrgbBlock = 134, - Bc2UnormBlock = 135, - Bc2SrgbBlock = 136, - Bc3UnormBlock = 137, - Bc3SrgbBlock = 138, - Bc4UnormBlock = 139, - Bc4SnormBlock = 140, - Bc5UnormBlock = 141, - Bc5SnormBlock = 142, - Bc6hUfloatBlock = 143, - Bc6hSfloatBlock = 144, - Bc7UnormBlock = 145, - Bc7SrgbBlock = 146, - Etc2R8g8b8UnormBlock = 147, - Etc2R8g8b8SrgbBlock = 148, - Etc2R8g8b8a1UnormBlock = 149, - Etc2R8g8b8a1SrgbBlock = 150, - Etc2R8g8b8a8UnormBlock = 151, - Etc2R8g8b8a8SrgbBlock = 152, - EacR11UnormBlock = 153, - EacR11SnormBlock = 154, - EacR11g11UnormBlock = 155, - EacR11g11SnormBlock = 156, - Astc4x4UnormBlock = 157, - Astc4x4SrgbBlock = 158, - Astc5x4UnormBlock = 159, - Astc5x4SrgbBlock = 160, - Astc5x5UnormBlock = 161, - Astc5x5SrgbBlock = 162, - Astc6x5UnormBlock = 163, - Astc6x5SrgbBlock = 164, - Astc6x6UnormBlock = 165, - Astc6x6SrgbBlock = 166, - Astc8x5UnormBlock = 167, - Astc8x5SrgbBlock = 168, - Astc8x6UnormBlock = 169, - Astc8x6SrgbBlock = 170, - Astc8x8UnormBlock = 171, - Astc8x8SrgbBlock = 172, - Astc10x5UnormBlock = 173, - Astc10x5SrgbBlock = 174, - Astc10x6UnormBlock = 175, - Astc10x6SrgbBlock = 176, - Astc10x8UnormBlock = 177, - Astc10x8SrgbBlock = 178, - Astc10x10UnormBlock = 179, - Astc10x10SrgbBlock = 180, - Astc12x10UnormBlock = 181, - Astc12x10SrgbBlock = 182, - Astc12x12UnormBlock = 183, - Astc12x12SrgbBlock = 184, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum ImageType { - Type1d = 0, - Type2d = 1, - Type3d = 2, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum ImageTiling { - Optimal = 0, - Linear = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum PhysicalDeviceType { - Other = 0, - IntegratedGpu = 1, - DiscreteGpu = 2, - VirtualGpu = 3, - Cpu = 4, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum QueryType { - Occlusion = 0, - PipelineStatistics = 1, - Timestamp = 2, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum SharingMode { - Exclusive = 0, - Concurrent = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum ImageLayout { - Undefined = 0, - General = 1, - ColorAttachmentOptimal = 2, - DepthStencilAttachmentOptimal = 3, - DepthStencilReadOnlyOptimal = 4, - ShaderReadOnlyOptimal = 5, - TransferSrcOptimal = 6, - TransferDstOptimal = 7, - Preinitialized = 8, - PresentSrcKhr = 1000001002, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum ImageViewType { - Type1d = 0, - Type2d = 1, - Type3d = 2, - Cube = 3, - Type1dArray = 4, - Type2dArray = 5, - CubeArray = 6, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum ComponentSwizzle { - Identity = 0, - Zero = 1, - One = 2, - R = 3, - G = 4, - B = 5, - A = 6, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum VertexInputRate { - Vertex = 0, - Instance = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum PrimitiveTopology { - PointList = 0, - LineList = 1, - LineStrip = 2, - TriangleList = 3, - TriangleStrip = 4, - TriangleFan = 5, - LineListWithAdjacency = 6, - LineStripWithAdjacency = 7, - TriangleListWithAdjacency = 8, - TriangleStripWithAdjacency = 9, - PatchList = 10, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum PolygonMode { - Fill = 0, - Line = 1, - Point = 2, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum FrontFace { - CounterClockwise = 0, - Clockwise = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum CompareOp { - Never = 0, - Less = 1, - Equal = 2, - LessOrEqual = 3, - Greater = 4, - NotEqual = 5, - GreaterOrEqual = 6, - Always = 7, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum StencilOp { - Keep = 0, - Zero = 1, - Replace = 2, - IncrementAndClamp = 3, - DecrementAndClamp = 4, - Invert = 5, - IncrementAndWrap = 6, - DecrementAndWrap = 7, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum LogicOp { - Clear = 0, - And = 1, - AndReverse = 2, - Copy = 3, - AndInverted = 4, - No = 5, - Xor = 6, - Or = 7, - Nor = 8, - Equivalent = 9, - Invert = 10, - OrReverse = 11, - CopyInverted = 12, - OrInverted = 13, - Nand = 14, - Set = 15, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum BlendFactor { - Zero = 0, - One = 1, - SrcColor = 2, - OneMinusSrcColor = 3, - DstColor = 4, - OneMinusDstColor = 5, - SrcAlpha = 6, - OneMinusSrcAlpha = 7, - DstAlpha = 8, - OneMinusDstAlpha = 9, - ConstantColor = 10, - OneMinusConstantColor = 11, - ConstantAlpha = 12, - OneMinusConstantAlpha = 13, - SrcAlphaSaturate = 14, - Src1Color = 15, - OneMinusSrc1Color = 16, - Src1Alpha = 17, - OneMinusSrc1Alpha = 18, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum BlendOp { - Add = 0, - Subtract = 1, - ReverseSubtract = 2, - Min = 3, - Max = 4, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum DynamicState { - Viewport = 0, - Scissor = 1, - LineWidth = 2, - DepthBias = 3, - BlendConstants = 4, - DepthBounds = 5, - StencilCompareMask = 6, - StencilWriteMask = 7, - StencilReference = 8, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum Filter { - Nearest = 0, - Linear = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum SamplerMipmapMode { - Nearest = 0, - Linear = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum SamplerAddressMode { - Repeat = 0, - MirroredRepeat = 1, - ClampToEdge = 2, - ClampToBorder = 3, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum BorderColor { - FloatTransparentBlack = 0, - IntTransparentBlack = 1, - FloatOpaqueBlack = 2, - IntOpaqueBlack = 3, - FloatOpaqueWhite = 4, - IntOpaqueWhite = 5, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum DescriptorType { - Sampler = 0, - CombinedImageSampler = 1, - SampledImage = 2, - StorageImage = 3, - UniformTexelBuffer = 4, - StorageTexelBuffer = 5, - UniformBuffer = 6, - StorageBuffer = 7, - UniformBufferDynamic = 8, - StorageBufferDynamic = 9, - InputAttachment = 10, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum AttachmentLoadOp { - Load = 0, - Clear = 1, - DontCare = 2, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum AttachmentStoreOp { - Store = 0, - DontCare = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum PipelineBindPoint { - Graphics = 0, - Compute = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum CommandBufferLevel { - Primary = 0, - Secondary = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum IndexType { - Uint16 = 0, - Uint32 = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum SubpassContents { - Inline = 0, - SecondaryCommandBuffers = 1, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum ColorSpaceKHR { - SrgbNonlinear = 0, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum PresentModeKHR { - Immediate = 0, - Mailbox = 1, - Fifo = 2, - FifoRelaxed = 3, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum DebugReportObjectTypeEXT { - Unknown = 0, - Instance = 1, - PhysicalDevice = 2, - Device = 3, - Queue = 4, - Semaphore = 5, - CommandBuffer = 6, - Fence = 7, - DeviceMemory = 8, - Buffer = 9, - Image = 10, - Ent = 11, - QueryPool = 12, - BufferView = 13, - ImageView = 14, - ShaderModule = 15, - PipelineCache = 16, - PipelineLayout = 17, - RenderPass = 18, - Pipeline = 19, - DescriptorSetLayout = 20, - Sampler = 21, - DescriptorPool = 22, - DescriptorSet = 23, - Framebuffer = 24, - CommandPool = 25, - SurfaceKhr = 26, - SwapchainKhr = 27, - DebugReport = 28, - } - - #[repr(C)] - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub enum DebugReportErrorEXT { - None = 0, - CallbackRef = 1, - } - - macro_rules! vk_define_handle{ - ($name: ident) => { - #[derive(Clone, Copy, Debug)] - #[repr(C)] - pub struct $name{ - ptr: *mut u8 - } - - unsafe impl Send for $name {} - unsafe impl Sync for $name {} - - impl $name{ - pub unsafe fn null() -> Self{ - $name{ - ptr: ::std::ptr::null_mut() - } - } - } - } - } - - vk_define_handle!(Instance); - vk_define_handle!(Device); - vk_define_handle!(PhysicalDevice); - vk_define_handle!(Queue); - vk_define_handle!(CommandBuffer); - - handle_nondispatchable!(Semaphore); - handle_nondispatchable!(Fence); - handle_nondispatchable!(DeviceMemory); - handle_nondispatchable!(Buffer); - handle_nondispatchable!(Image); - handle_nondispatchable!(Event); - handle_nondispatchable!(QueryPool); - handle_nondispatchable!(BufferView); - handle_nondispatchable!(ImageView); - handle_nondispatchable!(ShaderModule); - handle_nondispatchable!(PipelineCache); - handle_nondispatchable!(PipelineLayout); - handle_nondispatchable!(RenderPass); - handle_nondispatchable!(Pipeline); - handle_nondispatchable!(DescriptorSetLayout); - handle_nondispatchable!(Sampler); - handle_nondispatchable!(DescriptorPool); - handle_nondispatchable!(DescriptorSet); - handle_nondispatchable!(Framebuffer); - handle_nondispatchable!(CommandPool); - handle_nondispatchable!(SurfaceKHR); - handle_nondispatchable!(SwapchainKHR); - handle_nondispatchable!(DisplayKHR); - handle_nondispatchable!(DisplayModeKHR); - handle_nondispatchable!(DebugReportCallbackEXT); - - pub const FORMAT_FEATURE_SAMPLED_IMAGE_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b1 }; - pub const FORMAT_FEATURE_STORAGE_IMAGE_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b10 }; - pub const FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b100 }; - pub const FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b1000 }; - pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b10000 }; - pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b100000 }; - pub const FORMAT_FEATURE_VERTEX_BUFFER_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b1000000 }; - pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b10000000 }; - pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b100000000 }; - pub const FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: FormatFeatureFlags = - FormatFeatureFlags { - flags: 0b1000000000, + ::std::mem::transmute(val) + }, }; - pub const FORMAT_FEATURE_BLIT_SRC_BIT: FormatFeatureFlags = FormatFeatureFlags { - flags: 0b10000000000, - }; - pub const FORMAT_FEATURE_BLIT_DST_BIT: FormatFeatureFlags = FormatFeatureFlags { - flags: 0b100000000000, - }; - pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: FormatFeatureFlags = - FormatFeatureFlags { - flags: 0b1000000000000, - }; - vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); - - pub const IMAGE_USAGE_TRANSFER_SRC_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b1 }; - pub const IMAGE_USAGE_TRANSFER_DST_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b10 }; - pub const IMAGE_USAGE_SAMPLED_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b100 }; - pub const IMAGE_USAGE_STORAGE_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b1000 }; - pub const IMAGE_USAGE_COLOR_ATTACHMENT_BIT: ImageUsageFlags = - ImageUsageFlags { flags: 0b10000 }; - pub const IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: ImageUsageFlags = - ImageUsageFlags { flags: 0b100000 }; - pub const IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: ImageUsageFlags = - ImageUsageFlags { flags: 0b1000000 }; - pub const IMAGE_USAGE_INPUT_ATTACHMENT_BIT: ImageUsageFlags = - ImageUsageFlags { flags: 0b10000000 }; - vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); - - pub const IMAGE_CREATE_SPARSE_BINDING_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b1 }; - pub const IMAGE_CREATE_SPARSE_RESIDENCY_BIT: ImageCreateFlags = - ImageCreateFlags { flags: 0b10 }; - pub const IMAGE_CREATE_SPARSE_ALIASED_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b100 }; - pub const IMAGE_CREATE_MUTABLE_FORMAT_BIT: ImageCreateFlags = - ImageCreateFlags { flags: 0b1000 }; - pub const IMAGE_CREATE_CUBE_COMPATIBLE_BIT: ImageCreateFlags = - ImageCreateFlags { flags: 0b10000 }; - vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); - - pub const SAMPLE_COUNT_1_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1 }; - pub const SAMPLE_COUNT_2_BIT: SampleCountFlags = SampleCountFlags { flags: 0b10 }; - pub const SAMPLE_COUNT_4_BIT: SampleCountFlags = SampleCountFlags { flags: 0b100 }; - pub const SAMPLE_COUNT_8_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1000 }; - pub const SAMPLE_COUNT_16_BIT: SampleCountFlags = SampleCountFlags { flags: 0b10000 }; - pub const SAMPLE_COUNT_32_BIT: SampleCountFlags = SampleCountFlags { flags: 0b100000 }; - pub const SAMPLE_COUNT_64_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1000000 }; - vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); - - pub const QUEUE_GRAPHICS_BIT: QueueFlags = QueueFlags { flags: 0b1 }; - pub const QUEUE_COMPUTE_BIT: QueueFlags = QueueFlags { flags: 0b10 }; - pub const QUEUE_TRANSFER_BIT: QueueFlags = QueueFlags { flags: 0b100 }; - pub const QUEUE_SPARSE_BINDING_BIT: QueueFlags = QueueFlags { flags: 0b1000 }; - vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); - - pub const MEMORY_PROPERTY_DEVICE_LOCAL_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b1 }; - pub const MEMORY_PROPERTY_HOST_VISIBLE_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b10 }; - pub const MEMORY_PROPERTY_HOST_COHERENT_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b100 }; - pub const MEMORY_PROPERTY_HOST_CACHED_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b1000 }; - pub const MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b10000 }; - vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); - - pub const MEMORY_HEAP_DEVICE_LOCAL_BIT: MemoryHeapFlags = MemoryHeapFlags { flags: 0b1 }; - vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); - - pub const PIPELINE_STAGE_TOP_OF_PIPE_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1 }; - pub const PIPELINE_STAGE_DRAW_INDIRECT_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10 }; - pub const PIPELINE_STAGE_VERTEX_INPUT_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b100 }; - pub const PIPELINE_STAGE_VERTEX_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1000 }; - pub const PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10000 }; - pub const PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b100000 }; - pub const PIPELINE_STAGE_GEOMETRY_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1000000 }; - pub const PIPELINE_STAGE_FRAGMENT_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10000000 }; - pub const PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b100000000 }; - pub const PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b1000000000, - }; - pub const PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b10000000000, - }; - pub const PIPELINE_STAGE_COMPUTE_SHADER_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b100000000000, - }; - pub const PIPELINE_STAGE_TRANSFER_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b1000000000000, - }; - pub const PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b10000000000000, - }; - pub const PIPELINE_STAGE_HOST_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b100000000000000, - }; - pub const PIPELINE_STAGE_ALL_GRAPHICS_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b1000000000000000, - }; - pub const PIPELINE_STAGE_ALL_COMMANDS_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b10000000000000000, - }; - vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); - - pub const IMAGE_ASPECT_COLOR_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b1 }; - pub const IMAGE_ASPECT_DEPTH_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b10 }; - pub const IMAGE_ASPECT_STENCIL_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b100 }; - pub const IMAGE_ASPECT_METADATA_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b1000 }; - vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); - - pub const SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: SparseImageFormatFlags = - SparseImageFormatFlags { flags: 0b1 }; - pub const SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: SparseImageFormatFlags = - SparseImageFormatFlags { flags: 0b10 }; - pub const SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: SparseImageFormatFlags = - SparseImageFormatFlags { flags: 0b100 }; - vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); - - pub const SPARSE_MEMORY_BIND_METADATA_BIT: SparseMemoryBindFlags = - SparseMemoryBindFlags { flags: 0b1 }; - vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); - - pub const FENCE_CREATE_SIGNALED_BIT: FenceCreateFlags = FenceCreateFlags { flags: 0b1 }; - vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); - - pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b1 }; - pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b10 }; - pub const QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b100 }; - pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: - QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b1000 }; - pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b10000 }; - pub const QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b100000 }; - pub const QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b1000000 }; - pub const QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: - QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b10000000 }; - pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: - QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b100000000 }; - pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: - QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { - flags: 0b1000000000, - }; - pub const QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { - flags: 0b10000000000, - }; - vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); - - pub const QUERY_RESULT_64_BIT: QueryResultFlags = QueryResultFlags { flags: 0b1 }; - pub const QUERY_RESULT_WAIT_BIT: QueryResultFlags = QueryResultFlags { flags: 0b10 }; - pub const QUERY_RESULT_WITH_AVAILABILITY_BIT: QueryResultFlags = - QueryResultFlags { flags: 0b100 }; - pub const QUERY_RESULT_PARTIAL_BIT: QueryResultFlags = QueryResultFlags { flags: 0b1000 }; - vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); - - pub const BUFFER_CREATE_SPARSE_BINDING_BIT: BufferCreateFlags = - BufferCreateFlags { flags: 0b1 }; - pub const BUFFER_CREATE_SPARSE_RESIDENCY_BIT: BufferCreateFlags = - BufferCreateFlags { flags: 0b10 }; - pub const BUFFER_CREATE_SPARSE_ALIASED_BIT: BufferCreateFlags = - BufferCreateFlags { flags: 0b100 }; - vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); - - pub const BUFFER_USAGE_TRANSFER_SRC_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b1 }; - pub const BUFFER_USAGE_TRANSFER_DST_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b10 }; - pub const BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b100 }; - pub const BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b1000 }; - pub const BUFFER_USAGE_UNIFORM_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b10000 }; - pub const BUFFER_USAGE_STORAGE_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b100000 }; - pub const BUFFER_USAGE_INDEX_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b1000000 }; - pub const BUFFER_USAGE_VERTEX_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b10000000 }; - pub const BUFFER_USAGE_INDIRECT_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b100000000 }; - vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); - - pub const PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: PipelineCreateFlags = - PipelineCreateFlags { flags: 0b1 }; - pub const PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: PipelineCreateFlags = - PipelineCreateFlags { flags: 0b10 }; - pub const PIPELINE_CREATE_DERIVATIVE_BIT: PipelineCreateFlags = - PipelineCreateFlags { flags: 0b100 }; - vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); - - pub const SHADER_STAGE_VERTEX_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b1 }; - pub const SHADER_STAGE_TESSELLATION_CONTROL_BIT: ShaderStageFlags = - ShaderStageFlags { flags: 0b10 }; - pub const SHADER_STAGE_TESSELLATION_EVALUATION_BIT: ShaderStageFlags = - ShaderStageFlags { flags: 0b100 }; - pub const SHADER_STAGE_GEOMETRY_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b1000 }; - pub const SHADER_STAGE_FRAGMENT_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b10000 }; - pub const SHADER_STAGE_COMPUTE_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b100000 }; - pub const SHADER_STAGE_ALL_GRAPHICS: ShaderStageFlags = ShaderStageFlags { flags: 0b11111 }; - pub const SHADER_STAGE_ALL: ShaderStageFlags = ShaderStageFlags { - flags: 0b1111111111111111111111111111111, - }; - vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); - - pub const CULL_MODE_NONE: CullModeFlags = CullModeFlags { flags: 0b0 }; - pub const CULL_MODE_FRONT_BIT: CullModeFlags = CullModeFlags { flags: 0b1 }; - pub const CULL_MODE_BACK_BIT: CullModeFlags = CullModeFlags { flags: 0b10 }; - pub const CULL_MODE_FRONT_AND_BACK: CullModeFlags = CullModeFlags { flags: 0b11 }; - vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); - - pub const COLOR_COMPONENT_R_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b1 }; - pub const COLOR_COMPONENT_G_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b10 }; - pub const COLOR_COMPONENT_B_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b100 }; - pub const COLOR_COMPONENT_A_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b1000 }; - vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); - - pub const DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: DescriptorPoolCreateFlags = - DescriptorPoolCreateFlags { flags: 0b1 }; - vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); - - pub const ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: AttachmentDescriptionFlags = - AttachmentDescriptionFlags { flags: 0b1 }; - vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); - - pub const ACCESS_INDIRECT_COMMAND_READ_BIT: AccessFlags = AccessFlags { flags: 0b1 }; - pub const ACCESS_INDEX_READ_BIT: AccessFlags = AccessFlags { flags: 0b10 }; - pub const ACCESS_VERTEX_ATTRIBUTE_READ_BIT: AccessFlags = AccessFlags { flags: 0b100 }; - pub const ACCESS_UNIFORM_READ_BIT: AccessFlags = AccessFlags { flags: 0b1000 }; - pub const ACCESS_INPUT_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000 }; - pub const ACCESS_SHADER_READ_BIT: AccessFlags = AccessFlags { flags: 0b100000 }; - pub const ACCESS_SHADER_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b1000000 }; - pub const ACCESS_COLOR_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000000 }; - pub const ACCESS_COLOR_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b100000000 }; - pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { - flags: 0b1000000000, - }; - pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b10000000000, - }; - pub const ACCESS_TRANSFER_READ_BIT: AccessFlags = AccessFlags { - flags: 0b100000000000, - }; - pub const ACCESS_TRANSFER_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b1000000000000, - }; - pub const ACCESS_HOST_READ_BIT: AccessFlags = AccessFlags { - flags: 0b10000000000000, - }; - pub const ACCESS_HOST_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b100000000000000, - }; - pub const ACCESS_MEMORY_READ_BIT: AccessFlags = AccessFlags { - flags: 0b1000000000000000, - }; - pub const ACCESS_MEMORY_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b10000000000000000, - }; - vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); - - pub const DEPENDENCY_BY_REGION_BIT: DependencyFlags = DependencyFlags { flags: 0b1 }; - vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); - - pub const COMMAND_POOL_CREATE_TRANSIENT_BIT: CommandPoolCreateFlags = - CommandPoolCreateFlags { flags: 0b1 }; - pub const COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: CommandPoolCreateFlags = - CommandPoolCreateFlags { flags: 0b10 }; - vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); - - pub const COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: CommandPoolResetFlags = - CommandPoolResetFlags { flags: 0b1 }; - vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); - - pub const COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: CommandBufferUsageFlags = - CommandBufferUsageFlags { flags: 0b1 }; - pub const COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: CommandBufferUsageFlags = - CommandBufferUsageFlags { flags: 0b10 }; - pub const COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: CommandBufferUsageFlags = - CommandBufferUsageFlags { flags: 0b100 }; - vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); - - pub const QUERY_CONTROL_PRECISE_BIT: QueryControlFlags = QueryControlFlags { flags: 0b1 }; - vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); - - pub const COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: CommandBufferResetFlags = - CommandBufferResetFlags { flags: 0b1 }; - vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); - - pub const STENCIL_FACE_FRONT_BIT: StencilFaceFlags = StencilFaceFlags { flags: 0b1 }; - pub const STENCIL_FACE_BACK_BIT: StencilFaceFlags = StencilFaceFlags { flags: 0b10 }; - pub const STENCIL_FRONT_AND_BACK: StencilFaceFlags = StencilFaceFlags { flags: 0b11 }; - vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); - - pub const SURFACE_TRANSFORM_IDENTITY_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b1 }; - pub const SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b10 }; - pub const SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b100 }; - pub const SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b1000 }; - pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b10000 }; - pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b100000 }; - pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b1000000 }; - pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b10000000 }; - pub const SURFACE_TRANSFORM_INHERIT_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b100000000 }; - vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); - - pub const COMPOSITE_ALPHA_OPAQUE_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b1 }; - pub const COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b10 }; - pub const COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b100 }; - pub const COMPOSITE_ALPHA_INHERIT_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b1000 }; - vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); - - pub const DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b1 }; - pub const DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b10 }; - pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b100 }; - pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b1000 }; - vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); - - pub const DEBUG_REPORT_INFORMATION_BIT_EXT: DebugReportFlagsEXT = - DebugReportFlagsEXT { flags: 0b1 }; - pub const DEBUG_REPORT_WARNING_BIT_EXT: DebugReportFlagsEXT = - DebugReportFlagsEXT { flags: 0b10 }; - pub const DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: DebugReportFlagsEXT = - DebugReportFlagsEXT { flags: 0b100 }; - pub const DEBUG_REPORT_ERROR_BIT_EXT: DebugReportFlagsEXT = - DebugReportFlagsEXT { flags: 0b1000 }; - pub const DEBUG_REPORT_DEBUG_BIT_EXT: DebugReportFlagsEXT = - DebugReportFlagsEXT { flags: 0b10000 }; - vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); - - pub type PFN_vkAllocationFunction = - unsafe extern "system" fn(*mut c_void, size_t, size_t, SystemAllocationScope) - -> *mut c_void; - - pub type PFN_vkReallocationFunction = - unsafe extern "system" fn(*mut c_void, *mut c_void, size_t, size_t, SystemAllocationScope) - -> *mut c_void; - - pub type PFN_vkFreeFunction = unsafe extern "system" fn(*mut c_void, *mut c_void); - - pub type PFN_vkInternalAllocationNotification = - unsafe extern "system" fn( - *mut c_void, - size_t, - InternalAllocationType, - SystemAllocationScope, - ); - - pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn( - *mut c_void, - size_t, - InternalAllocationType, - SystemAllocationScope, - ); - - pub type PFN_vkVoidFunction = unsafe extern "system" fn(); - - pub type PFN_vkDebugReportCallbackEXT = unsafe extern "system" fn( - DebugReportFlagsEXT, - DebugReportObjectTypeEXT, - uint64_t, - size_t, - int32_t, - *const c_char, - *const c_char, - *mut c_void, - ) -> Bool32; - -} -// FIX: Need better error handling for extensions -macro_rules! vk_functions { - ($struct_name: ident, $($raw_name: expr, $name: ident ($($param_name: ident: $param: ty),*,) -> $ret: ty;)+) => { - #[allow(non_camel_case_types)] - pub struct $struct_name{ - $( - $name: extern "system" fn ($($param_name: $param),*) -> $ret, - )+ - } - - impl Clone for $struct_name { - fn clone(&self) -> Self{ - $struct_name { - $( - $name: self.$name, - )+ - } - } - } - - unsafe impl Send for $struct_name {} - unsafe impl Sync for $struct_name {} - - impl $struct_name { - pub fn load(mut f: F) -> ::std::result::Result<$struct_name, Vec<&'static str>> - where F: FnMut(&::std::ffi::CStr) -> *const c_void - { - use std::ffi::{CString}; - use std::mem; - let mut err_str = Vec::new(); - let s = $struct_name { - $( - $name: unsafe { - let cname = CString::new($raw_name).unwrap(); - let val = f(&cname); - if val.is_null(){ - err_str.push(stringify!($raw_name)); - } - mem::transmute(val) - }, - )+ - }; - - if err_str.is_empty() { - Ok(s) - } - else{ - Err(err_str) - } - } - $( - #[inline] - pub unsafe fn $name(&self $(, $param_name: $param)*) -> $ret { - let fp = self.$name; - fp($($param_name),*) - } - )+ + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } -} - -pub mod cmds { - #![allow(dead_code)] - use super::*; - - vk_functions!{ - StaticFn, - "vkGetInstanceProcAddr", get_instance_proc_addr( - instance: Instance, - p_name: *const c_char, - ) -> PFN_vkVoidFunction; + pub unsafe fn get_instance_proc_addr( + &self, + instance: Instance, + p_name: *const c_char, + ) -> PFN_vkVoidFunction { + (self.get_instance_proc_addr)(instance, p_name) } - - vk_functions!{ - EntryFnV1_0, - "vkCreateInstance", create_instance( - p_create_info: *const InstanceCreateInfo, - p_allocator: *const AllocationCallbacks, - p_instance: *mut Instance, - ) -> Result; - - "vkEnumerateInstanceExtensionProperties", enumerate_instance_extension_properties( +} +pub struct EntryFnV1_0 { + create_instance: extern "system" fn( + p_create_info: *const InstanceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_instance: *const Instance, + ) -> Result, + enumerate_instance_extension_properties: + extern "system" fn( p_layer_name: *const c_char, - p_property_count: *mut uint32_t, - p_properties: *mut ExtensionProperties, - ) -> Result; - - "vkEnumerateInstanceLayerProperties", enumerate_instance_layer_properties( - p_property_count: *mut uint32_t, - p_properties: *mut LayerProperties, - ) -> Result; + p_property_count: *const uint32_t, + p_properties: *const ExtensionProperties, + ) -> Result, + enumerate_instance_layer_properties: + extern "system" fn(p_property_count: *const uint32_t, p_properties: *const LayerProperties) + -> Result, +} +unsafe impl Send for EntryFnV1_0 {} +unsafe impl Sync for EntryFnV1_0 {} +impl ::std::clone::Clone for EntryFnV1_0 { + fn clone(&self) -> Self { + EntryFnV1_0 { + create_instance: self.create_instance, + enumerate_instance_extension_properties: self.enumerate_instance_extension_properties, + enumerate_instance_layer_properties: self.enumerate_instance_layer_properties, + } } - - vk_functions!{ - InstanceFnV1_0, - - "vkDestroyInstance", destroy_instance( - instance: Instance, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkEnumeratePhysicalDevices", enumerate_physical_devices( - instance: Instance, - p_physical_device_count: *mut uint32_t, - p_physical_devices: *mut PhysicalDevice, - ) -> Result; - - "vkGetPhysicalDeviceFeatures", get_physical_device_features( - physical_device: PhysicalDevice, - p_features: *mut PhysicalDeviceFeatures, - ) -> (); - - "vkGetPhysicalDeviceFormatProperties", get_physical_device_format_properties( +} +impl EntryFnV1_0 { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = EntryFnV1_0 { + create_instance: unsafe { + let raw_name = stringify!(vkCreateInstance); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + enumerate_instance_extension_properties: unsafe { + let raw_name = stringify!(vkEnumerateInstanceExtensionProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + enumerate_instance_layer_properties: unsafe { + let raw_name = stringify!(vkEnumerateInstanceLayerProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_instance( + &self, + p_create_info: *const InstanceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_instance: *const Instance, + ) -> Result { + (self.create_instance)(p_create_info, p_allocator, p_instance) + } + pub unsafe fn enumerate_instance_extension_properties( + &self, + p_layer_name: *const c_char, + p_property_count: *const uint32_t, + p_properties: *const ExtensionProperties, + ) -> Result { + (self.enumerate_instance_extension_properties)(p_layer_name, p_property_count, p_properties) + } + pub unsafe fn enumerate_instance_layer_properties( + &self, + p_property_count: *const uint32_t, + p_properties: *const LayerProperties, + ) -> Result { + (self.enumerate_instance_layer_properties)(p_property_count, p_properties) + } +} +pub struct InstanceFnV1_0 { + destroy_instance: + extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks) -> c_void, + enumerate_physical_devices: extern "system" fn( + instance: Instance, + p_physical_device_count: *const uint32_t, + p_physical_devices: *const PhysicalDevice, + ) -> Result, + get_physical_device_features: extern "system" fn( + physical_device: PhysicalDevice, + p_features: *const PhysicalDeviceFeatures, + ) -> c_void, + get_physical_device_format_properties: + extern "system" fn( physical_device: PhysicalDevice, format: Format, - p_format_properties: *mut FormatProperties, - ) -> (); - - "vkGetPhysicalDeviceImageFormatProperties", get_physical_device_image_format_properties( + p_format_properties: *const FormatProperties, + ) -> c_void, + get_physical_device_image_format_properties: + extern "system" fn( physical_device: PhysicalDevice, format: Format, - typ: ImageType, + ty: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, - p_image_format_properties: *mut ImageFormatProperties, - ) -> Result; - - "vkGetPhysicalDeviceProperties", get_physical_device_properties( + p_image_format_properties: *const ImageFormatProperties, + ) -> Result, + get_physical_device_properties: + extern "system" fn( physical_device: PhysicalDevice, - p_properties: *mut PhysicalDeviceProperties, - ) -> (); - - "vkGetPhysicalDeviceQueueFamilyProperties", get_physical_device_queue_family_properties( + p_properties: *const PhysicalDeviceProperties, + ) -> c_void, + get_physical_device_queue_family_properties: + extern "system" fn( physical_device: PhysicalDevice, - p_queue_family_property_count: *mut uint32_t, - p_queue_family_properties: *mut QueueFamilyProperties, - ) -> (); - - "vkGetPhysicalDeviceMemoryProperties", get_physical_device_memory_properties( + p_queue_family_property_count: *const uint32_t, + p_queue_family_properties: *const QueueFamilyProperties, + ) -> c_void, + get_physical_device_memory_properties: + extern "system" fn( physical_device: PhysicalDevice, - p_memory_properties: *mut PhysicalDeviceMemoryProperties, - ) -> (); - - "vkGetDeviceProcAddr", get_device_proc_addr( - device: Device, - p_name: *const c_char, - ) -> PFN_vkVoidFunction; - - "vkCreateDevice", create_device( - physical_device: PhysicalDevice, - p_create_info: *const DeviceCreateInfo, - p_allocator: *const AllocationCallbacks, - p_device: *mut Device, - ) -> Result; - - "vkEnumerateDeviceExtensionProperties", enumerate_device_extension_properties( + p_memory_properties: *const PhysicalDeviceMemoryProperties, + ) -> c_void, + get_device_proc_addr: + extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction, + create_device: extern "system" fn( + physical_device: PhysicalDevice, + p_create_info: *const DeviceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_device: *const Device, + ) -> Result, + enumerate_device_extension_properties: + extern "system" fn( physical_device: PhysicalDevice, p_layer_name: *const c_char, - p_property_count: *mut uint32_t, - p_properties: *mut ExtensionProperties, - ) -> Result; - - - "vkEnumerateDeviceLayerProperties", enumerate_device_layer_properties( - physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, - p_properties: *mut LayerProperties, - ) -> Result; - - "vkGetPhysicalDeviceSparseImageFormatProperties", get_physical_device_sparse_image_format_properties( + p_property_count: *const uint32_t, + p_properties: *const ExtensionProperties, + ) -> Result, + enumerate_device_layer_properties: extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const LayerProperties, + ) -> Result, + get_physical_device_sparse_image_format_properties: + extern "system" fn( physical_device: PhysicalDevice, format: Format, - typ: ImageType, + ty: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, - p_property_count: *mut uint32_t, - p_properties: *mut SparseImageFormatProperties, - ) -> (); + p_property_count: *const uint32_t, + p_properties: *const SparseImageFormatProperties, + ) -> c_void, +} +unsafe impl Send for InstanceFnV1_0 {} +unsafe impl Sync for InstanceFnV1_0 {} +impl ::std::clone::Clone for InstanceFnV1_0 { + fn clone(&self) -> Self { + InstanceFnV1_0 { + destroy_instance: self.destroy_instance, + enumerate_physical_devices: self.enumerate_physical_devices, + get_physical_device_features: self.get_physical_device_features, + get_physical_device_format_properties: self.get_physical_device_format_properties, + get_physical_device_image_format_properties: self + .get_physical_device_image_format_properties, + get_physical_device_properties: self.get_physical_device_properties, + get_physical_device_queue_family_properties: self + .get_physical_device_queue_family_properties, + get_physical_device_memory_properties: self.get_physical_device_memory_properties, + get_device_proc_addr: self.get_device_proc_addr, + create_device: self.create_device, + enumerate_device_extension_properties: self.enumerate_device_extension_properties, + enumerate_device_layer_properties: self.enumerate_device_layer_properties, + get_physical_device_sparse_image_format_properties: self + .get_physical_device_sparse_image_format_properties, + } } - - vk_functions!{ - DeviceFnV1_0, - "vkDestroyDevice", destroy_device( - device: Device, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetDeviceQueue", get_device_queue( - device: Device, - queue_family_index: uint32_t, - queue_index: uint32_t, - p_queue: *mut Queue, - ) -> (); - - "vkQueueSubmit", queue_submit( - queue: Queue, - submit_count: uint32_t, - p_submits: *const SubmitInfo, - fence: Fence, - ) -> Result; - - "vkQueueWaitIdle", queue_wait_idle( - queue: Queue, - ) -> Result; - - "vkDeviceWaitIdle", device_wait_idle( - device: Device, - ) -> Result; - - "vkAllocateMemory", allocate_memory( - device: Device, - p_allocate_info: *const MemoryAllocateInfo, - p_allocator: *const AllocationCallbacks, - p_memory: *mut DeviceMemory, - ) -> Result; - - "vkFreeMemory", free_memory( +} +impl InstanceFnV1_0 { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = InstanceFnV1_0 { + destroy_instance: unsafe { + let raw_name = stringify!(vkDestroyInstance); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + enumerate_physical_devices: unsafe { + let raw_name = stringify!(vkEnumeratePhysicalDevices); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_features: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceFeatures); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_format_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_image_format_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_queue_family_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_memory_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_proc_addr: unsafe { + let raw_name = stringify!(vkGetDeviceProcAddr); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_device: unsafe { + let raw_name = stringify!(vkCreateDevice); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + enumerate_device_extension_properties: unsafe { + let raw_name = stringify!(vkEnumerateDeviceExtensionProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + enumerate_device_layer_properties: unsafe { + let raw_name = stringify!(vkEnumerateDeviceLayerProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_sparse_image_format_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn destroy_instance( + &self, + instance: Instance, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_instance)(instance, p_allocator) + } + pub unsafe fn enumerate_physical_devices( + &self, + instance: Instance, + p_physical_device_count: *const uint32_t, + p_physical_devices: *const PhysicalDevice, + ) -> Result { + (self.enumerate_physical_devices)(instance, p_physical_device_count, p_physical_devices) + } + pub unsafe fn get_physical_device_features( + &self, + physical_device: PhysicalDevice, + p_features: *const PhysicalDeviceFeatures, + ) -> c_void { + (self.get_physical_device_features)(physical_device, p_features) + } + pub unsafe fn get_physical_device_format_properties( + &self, + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *const FormatProperties, + ) -> c_void { + (self.get_physical_device_format_properties)(physical_device, format, p_format_properties) + } + pub unsafe fn get_physical_device_image_format_properties( + &self, + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + p_image_format_properties: *const ImageFormatProperties, + ) -> Result { + (self.get_physical_device_image_format_properties)( + physical_device, + format, + ty, + tiling, + usage, + flags, + p_image_format_properties, + ) + } + pub unsafe fn get_physical_device_properties( + &self, + physical_device: PhysicalDevice, + p_properties: *const PhysicalDeviceProperties, + ) -> c_void { + (self.get_physical_device_properties)(physical_device, p_properties) + } + pub unsafe fn get_physical_device_queue_family_properties( + &self, + physical_device: PhysicalDevice, + p_queue_family_property_count: *const uint32_t, + p_queue_family_properties: *const QueueFamilyProperties, + ) -> c_void { + (self.get_physical_device_queue_family_properties)( + physical_device, + p_queue_family_property_count, + p_queue_family_properties, + ) + } + pub unsafe fn get_physical_device_memory_properties( + &self, + physical_device: PhysicalDevice, + p_memory_properties: *const PhysicalDeviceMemoryProperties, + ) -> c_void { + (self.get_physical_device_memory_properties)(physical_device, p_memory_properties) + } + pub unsafe fn get_device_proc_addr( + &self, + device: Device, + p_name: *const c_char, + ) -> PFN_vkVoidFunction { + (self.get_device_proc_addr)(device, p_name) + } + pub unsafe fn create_device( + &self, + physical_device: PhysicalDevice, + p_create_info: *const DeviceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_device: *const Device, + ) -> Result { + (self.create_device)(physical_device, p_create_info, p_allocator, p_device) + } + pub unsafe fn enumerate_device_extension_properties( + &self, + physical_device: PhysicalDevice, + p_layer_name: *const c_char, + p_property_count: *const uint32_t, + p_properties: *const ExtensionProperties, + ) -> Result { + (self.enumerate_device_extension_properties)( + physical_device, + p_layer_name, + p_property_count, + p_properties, + ) + } + pub unsafe fn enumerate_device_layer_properties( + &self, + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const LayerProperties, + ) -> Result { + (self.enumerate_device_layer_properties)(physical_device, p_property_count, p_properties) + } + pub unsafe fn get_physical_device_sparse_image_format_properties( + &self, + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + samples: SampleCountFlags, + usage: ImageUsageFlags, + tiling: ImageTiling, + p_property_count: *const uint32_t, + p_properties: *const SparseImageFormatProperties, + ) -> c_void { + (self.get_physical_device_sparse_image_format_properties)( + physical_device, + format, + ty, + samples, + usage, + tiling, + p_property_count, + p_properties, + ) + } +} +pub struct DeviceFnV1_0 { + destroy_device: + extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks) -> c_void, + get_device_queue: extern "system" fn( + device: Device, + queue_family_index: uint32_t, + queue_index: uint32_t, + p_queue: *const Queue, + ) -> c_void, + queue_submit: extern "system" fn( + queue: Queue, + submit_count: uint32_t, + p_submits: *const SubmitInfo, + fence: Fence, + ) -> Result, + queue_wait_idle: extern "system" fn(queue: Queue) -> Result, + device_wait_idle: extern "system" fn(device: Device) -> Result, + allocate_memory: extern "system" fn( + device: Device, + p_allocate_info: *const MemoryAllocateInfo, + p_allocator: *const AllocationCallbacks, + p_memory: *const DeviceMemory, + ) -> Result, + free_memory: extern "system" fn( + device: Device, + memory: DeviceMemory, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + map_memory: extern "system" fn( + device: Device, + memory: DeviceMemory, + offset: DeviceSize, + size: DeviceSize, + flags: MemoryMapFlags, + pp_data: *mut *mut c_void, + ) -> Result, + unmap_memory: extern "system" fn(device: Device, memory: DeviceMemory) -> c_void, + flush_mapped_memory_ranges: extern "system" fn( + device: Device, + memory_range_count: uint32_t, + p_memory_ranges: *const MappedMemoryRange, + ) -> Result, + invalidate_mapped_memory_ranges: extern "system" fn( + device: Device, + memory_range_count: uint32_t, + p_memory_ranges: *const MappedMemoryRange, + ) -> Result, + get_device_memory_commitment: + extern "system" fn( device: Device, memory: DeviceMemory, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkMapMemory", map_memory( - device: Device, - memory: DeviceMemory, - offset: DeviceSize, - size: DeviceSize, - flags: MemoryMapFlags, - pp_data: *mut *mut c_void, - ) -> Result; - - "vkUnmapMemory", unmap_memory( - device: Device, - memory: DeviceMemory, - ) -> (); - - "vkFlushMappedMemoryRanges", flush_mapped_memory_ranges( - device: Device, - memory_range_count: uint32_t, - p_memory_ranges: *const MappedMemoryRange, - ) -> Result; - - "vkInvalidateMappedMemoryRanges", invalidate_mapped_memory_ranges( - device: Device, - memory_range_count: uint32_t, - p_memory_ranges: *const MappedMemoryRange, - ) -> Result; - - "vkGetDeviceMemoryCommitment", get_device_memory_commitment( - device: Device, - memory: DeviceMemory, - p_committed_memory_in_bytes: *mut DeviceSize, - ) -> (); - - "vkBindBufferMemory", bind_buffer_memory( + p_committed_memory_in_bytes: *const DeviceSize, + ) -> c_void, + bind_buffer_memory: extern "system" fn( + device: Device, + buffer: Buffer, + memory: DeviceMemory, + memory_offset: DeviceSize, + ) -> Result, + bind_image_memory: extern "system" fn( + device: Device, + image: Image, + memory: DeviceMemory, + memory_offset: DeviceSize, + ) -> Result, + get_buffer_memory_requirements: + extern "system" fn( device: Device, buffer: Buffer, - memory: DeviceMemory, - memory_offset: DeviceSize, - ) -> Result; - - "vkBindImageMemory", bind_image_memory( + p_memory_requirements: *const MemoryRequirements, + ) -> c_void, + get_image_memory_requirements: + extern "system" fn( device: Device, image: Image, - memory: DeviceMemory, - memory_offset: DeviceSize, - ) -> Result; - - "vkGetBufferMemoryRequirements", get_buffer_memory_requirements( - device: Device, - buffer: Buffer, - p_memory_requirements: *mut MemoryRequirements, - ) -> (); - - "vkGetImageMemoryRequirements", get_image_memory_requirements( + p_memory_requirements: *const MemoryRequirements, + ) -> c_void, + get_image_sparse_memory_requirements: + extern "system" fn( device: Device, image: Image, - p_memory_requirements: *mut MemoryRequirements, - ) -> (); - - "vkGetImageSparseMemoryRequirements", get_image_sparse_memory_requirements( - device: Device, - image: Image, - p_sparse_memory_requirement_count: *mut uint32_t, - p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, - ) -> (); - - "vkQueueBindSparse", queue_bind_sparse( - queue: Queue, - bind_info_count: uint32_t, - p_bind_info: *const BindSparseInfo, - fence: Fence, - ) -> Result; - - "vkCreateFence", create_fence( - device: Device, - p_create_info: *const FenceCreateInfo, - p_allocator: *const AllocationCallbacks, - p_fence: *mut Fence, - ) -> Result; - - "vkDestroyFence", destroy_fence( - device: Device, - fence: Fence, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkResetFences", reset_fences( - device: Device, - fence_count: uint32_t, - p_fences: *const Fence, - ) -> Result; - - "vkGetFenceStatus", get_fence_status( - device: Device, - fence: Fence, - ) -> Result; - - "vkWaitForFences", wait_for_fences( - device: Device, - fence_count: uint32_t, - p_fences: *const Fence, - wait_all: Bool32, - timeout: uint64_t, - ) -> Result; - - "vkCreateSemaphore", create_semaphore( - device: Device, - p_create_info: *const SemaphoreCreateInfo, - p_allocator: *const AllocationCallbacks, - p_semaphore: *mut Semaphore, - ) -> Result; - - "vkDestroySemaphore", destroy_semaphore( - device: Device, - semaphore: Semaphore, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateEvent", create_event( - device: Device, - p_create_info: *const EventCreateInfo, - p_allocator: *const AllocationCallbacks, - p_event: *mut Event, - ) -> Result; - - "vkDestroyEvent", destroy_event( - device: Device, - event: Event, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetEventStatus", get_event_status( - device: Device, - event: Event, - ) -> Result; - - "vkSetEvent", set_event( - device: Device, - event: Event, - ) -> Result; - - "vkResetEvent", reset_event( - device: Device, - event: Event, - ) -> Result; - - "vkCreateQueryPool", create_query_pool( - device: Device, - p_create_info: *const QueryPoolCreateInfo, - p_allocator: *const AllocationCallbacks, - p_query_pool: *mut QueryPool, - ) -> Result; - - "vkDestroyQueryPool", destroy_query_pool( - device: Device, - query_pool: QueryPool, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetQueryPoolResults", get_query_pool_results( - device: Device, - query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - data_size: size_t, - p_data: *mut c_void, - stride: DeviceSize, - flags: QueryResultFlags, - ) -> Result; - - "vkCreateBuffer", create_buffer( - device: Device, - p_create_info: *const BufferCreateInfo, - p_allocator: *const AllocationCallbacks, - p_buffer: *mut Buffer, - ) -> Result; - - "vkDestroyBuffer", destroy_buffer( - device: Device, - buffer: Buffer, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateBufferView", create_buffer_view( - device: Device, - p_create_info: *const BufferViewCreateInfo, - p_allocator: *const AllocationCallbacks, - p_view: *mut BufferView, - ) -> Result; - - "vkDestroyBufferView", destroy_buffer_view( - device: Device, - buffer_view: BufferView, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateImage", create_image( - device: Device, - p_create_info: *const ImageCreateInfo, - p_allocator: *const AllocationCallbacks, - p_image: *mut Image, - ) -> Result; - - "vkDestroyImage", destroy_image( - device: Device, - image: Image, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetImageSubresourceLayout", get_image_subresource_layout( - device: Device, - image: Image, - p_subresource: *const ImageSubresource, - p_layout: *mut SubresourceLayout, - ) -> (); - - "vkCreateImageView", create_image_view( - device: Device, - p_create_info: *const ImageViewCreateInfo, - p_allocator: *const AllocationCallbacks, - p_view: *mut ImageView, - ) -> Result; - - "vkDestroyImageView", destroy_image_view( - device: Device, - image_view: ImageView, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateShaderModule", create_shader_module( - device: Device, - p_create_info: *const ShaderModuleCreateInfo, - p_allocator: *const AllocationCallbacks, - p_shader_module: *mut ShaderModule, - ) -> Result; - - "vkDestroyShaderModule", destroy_shader_module( - device: Device, - shader_module: ShaderModule, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreatePipelineCache", create_pipeline_cache( - device: Device, - p_create_info: *const PipelineCacheCreateInfo, - p_allocator: *const AllocationCallbacks, - p_pipeline_cache: *mut PipelineCache, - ) -> Result; - - "vkDestroyPipelineCache", destroy_pipeline_cache( - device: Device, - pipeline_cache: PipelineCache, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetPipelineCacheData", get_pipeline_cache_data( - device: Device, - pipeline_cache: PipelineCache, - p_data_size: *mut size_t, - p_data: *mut c_void, - ) -> Result; - - "vkMergePipelineCaches", merge_pipeline_caches( - device: Device, - dst_cache: PipelineCache, - src_cache_count: uint32_t, - p_src_caches: *const PipelineCache, - ) -> Result; - - "vkCreateGraphicsPipelines", create_graphics_pipelines( + p_sparse_memory_requirement_count: *const uint32_t, + p_sparse_memory_requirements: *const SparseImageMemoryRequirements, + ) -> c_void, + queue_bind_sparse: extern "system" fn( + queue: Queue, + bind_info_count: uint32_t, + p_bind_info: *const BindSparseInfo, + fence: Fence, + ) -> Result, + create_fence: extern "system" fn( + device: Device, + p_create_info: *const FenceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result, + destroy_fence: + extern "system" fn(device: Device, fence: Fence, p_allocator: *const AllocationCallbacks) + -> c_void, + reset_fences: + extern "system" fn(device: Device, fence_count: uint32_t, p_fences: *const Fence) -> Result, + get_fence_status: extern "system" fn(device: Device, fence: Fence) -> Result, + wait_for_fences: extern "system" fn( + device: Device, + fence_count: uint32_t, + p_fences: *const Fence, + wait_all: Bool32, + timeout: uint64_t, + ) -> Result, + create_semaphore: extern "system" fn( + device: Device, + p_create_info: *const SemaphoreCreateInfo, + p_allocator: *const AllocationCallbacks, + p_semaphore: *const Semaphore, + ) -> Result, + destroy_semaphore: extern "system" fn( + device: Device, + semaphore: Semaphore, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_event: extern "system" fn( + device: Device, + p_create_info: *const EventCreateInfo, + p_allocator: *const AllocationCallbacks, + p_event: *const Event, + ) -> Result, + destroy_event: + extern "system" fn(device: Device, event: Event, p_allocator: *const AllocationCallbacks) + -> c_void, + get_event_status: extern "system" fn(device: Device, event: Event) -> Result, + set_event: extern "system" fn(device: Device, event: Event) -> Result, + reset_event: extern "system" fn(device: Device, event: Event) -> Result, + create_query_pool: extern "system" fn( + device: Device, + p_create_info: *const QueryPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_query_pool: *const QueryPool, + ) -> Result, + destroy_query_pool: extern "system" fn( + device: Device, + query_pool: QueryPool, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + get_query_pool_results: extern "system" fn( + device: Device, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + data_size: size_t, + p_data: *const c_void, + stride: DeviceSize, + flags: QueryResultFlags, + ) -> Result, + create_buffer: extern "system" fn( + device: Device, + p_create_info: *const BufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_buffer: *const Buffer, + ) -> Result, + destroy_buffer: + extern "system" fn(device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks) + -> c_void, + create_buffer_view: extern "system" fn( + device: Device, + p_create_info: *const BufferViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *const BufferView, + ) -> Result, + destroy_buffer_view: extern "system" fn( + device: Device, + buffer_view: BufferView, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_image: extern "system" fn( + device: Device, + p_create_info: *const ImageCreateInfo, + p_allocator: *const AllocationCallbacks, + p_image: *const Image, + ) -> Result, + destroy_image: + extern "system" fn(device: Device, image: Image, p_allocator: *const AllocationCallbacks) + -> c_void, + get_image_subresource_layout: extern "system" fn( + device: Device, + image: Image, + p_subresource: *const ImageSubresource, + p_layout: *const SubresourceLayout, + ) -> c_void, + create_image_view: extern "system" fn( + device: Device, + p_create_info: *const ImageViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *const ImageView, + ) -> Result, + destroy_image_view: extern "system" fn( + device: Device, + image_view: ImageView, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_shader_module: extern "system" fn( + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_allocator: *const AllocationCallbacks, + p_shader_module: *const ShaderModule, + ) -> Result, + destroy_shader_module: extern "system" fn( + device: Device, + shader_module: ShaderModule, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_pipeline_cache: extern "system" fn( + device: Device, + p_create_info: *const PipelineCacheCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_cache: *const PipelineCache, + ) -> Result, + destroy_pipeline_cache: extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + get_pipeline_cache_data: extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + p_data_size: *const size_t, + p_data: *const c_void, + ) -> Result, + merge_pipeline_caches: extern "system" fn( + device: Device, + dst_cache: PipelineCache, + src_cache_count: uint32_t, + p_src_caches: *const PipelineCache, + ) -> Result, + create_graphics_pipelines: + extern "system" fn( device: Device, pipeline_cache: PipelineCache, create_info_count: uint32_t, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, - ) -> Result; - - "vkCreateComputePipelines", create_compute_pipelines( - device: Device, - pipeline_cache: PipelineCache, - create_info_count: uint32_t, - p_create_infos: *const ComputePipelineCreateInfo, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, - ) -> Result; - - "vkDestroyPipeline", destroy_pipeline( - device: Device, - pipeline: Pipeline, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreatePipelineLayout", create_pipeline_layout( - device: Device, - p_create_info: *const PipelineLayoutCreateInfo, - p_allocator: *const AllocationCallbacks, - p_pipeline_layout: *mut PipelineLayout, - ) -> Result; - - "vkDestroyPipelineLayout", destroy_pipeline_layout( - device: Device, - pipeline_layout: PipelineLayout, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateSampler", create_sampler( - device: Device, - p_create_info: *const SamplerCreateInfo, - p_allocator: *const AllocationCallbacks, - p_sampler: *mut Sampler, - ) -> Result; - - "vkDestroySampler", destroy_sampler( - device: Device, - sampler: Sampler, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateDescriptorSetLayout", create_descriptor_set_layout( + p_pipelines: *const Pipeline, + ) -> Result, + create_compute_pipelines: extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: uint32_t, + p_create_infos: *const ComputePipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *const Pipeline, + ) -> Result, + destroy_pipeline: extern "system" fn( + device: Device, + pipeline: Pipeline, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_pipeline_layout: extern "system" fn( + device: Device, + p_create_info: *const PipelineLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_layout: *const PipelineLayout, + ) -> Result, + destroy_pipeline_layout: extern "system" fn( + device: Device, + pipeline_layout: PipelineLayout, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_sampler: extern "system" fn( + device: Device, + p_create_info: *const SamplerCreateInfo, + p_allocator: *const AllocationCallbacks, + p_sampler: *const Sampler, + ) -> Result, + destroy_sampler: extern "system" fn( + device: Device, + sampler: Sampler, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_descriptor_set_layout: + extern "system" fn( device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, - p_set_layout: *mut DescriptorSetLayout, - ) -> Result; - - "vkDestroyDescriptorSetLayout", destroy_descriptor_set_layout( - device: Device, - descriptor_set_layout: DescriptorSetLayout, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateDescriptorPool", create_descriptor_pool( - device: Device, - p_create_info: *const DescriptorPoolCreateInfo, - p_allocator: *const AllocationCallbacks, - p_descriptor_pool: *mut DescriptorPool, - ) -> Result; - - "vkDestroyDescriptorPool", destroy_descriptor_pool( - device: Device, - descriptor_pool: DescriptorPool, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkResetDescriptorPool", reset_descriptor_pool( - device: Device, - descriptor_pool: DescriptorPool, - flags: DescriptorPoolResetFlags, - ) -> Result; - - "vkAllocateDescriptorSets", allocate_descriptor_sets( - device: Device, - p_allocate_info: *const DescriptorSetAllocateInfo, - p_descriptor_sets: *mut DescriptorSet, - ) -> Result; - - "vkFreeDescriptorSets", free_descriptor_sets( - device: Device, - descriptor_pool: DescriptorPool, - descriptor_set_count: uint32_t, - p_descriptor_sets: *const DescriptorSet, - ) -> Result; - - "vkUpdateDescriptorSets", update_descriptor_sets( - device: Device, - descriptor_write_count: uint32_t, - p_descriptor_writes: *const WriteDescriptorSet, - descriptor_copy_count: uint32_t, - p_descriptor_copies: *const CopyDescriptorSet, - ) -> (); - - "vkCreateFramebuffer", create_framebuffer( - device: Device, - p_create_info: *const FramebufferCreateInfo, - p_allocator: *const AllocationCallbacks, - p_framebuffer: *mut Framebuffer, - ) -> Result; - - "vkDestroyFramebuffer", destroy_framebuffer( - device: Device, - framebuffer: Framebuffer, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkCreateRenderPass", create_render_pass( - device: Device, - p_create_info: *const RenderPassCreateInfo, - p_allocator: *const AllocationCallbacks, - p_render_pass: *mut RenderPass, - ) -> Result; - - "vkDestroyRenderPass", destroy_render_pass( - device: Device, - render_pass: RenderPass, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetRenderAreaGranularity", get_render_area_granularity( - device: Device, - render_pass: RenderPass, - p_granularity: *mut Extent2D, - ) -> (); - - "vkCreateCommandPool", create_command_pool( - device: Device, - p_create_info: *const CommandPoolCreateInfo, - p_allocator: *const AllocationCallbacks, - p_command_pool: *mut CommandPool, - ) -> Result; - - "vkDestroyCommandPool", destroy_command_pool( - device: Device, - command_pool: CommandPool, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkResetCommandPool", reset_command_pool( - device: Device, - command_pool: CommandPool, - flags: CommandPoolResetFlags, - ) -> Result; - - "vkAllocateCommandBuffers", allocate_command_buffers( - device: Device, - p_allocate_info: *const CommandBufferAllocateInfo, - p_command_buffers: *mut CommandBuffer, - ) -> Result; - - "vkFreeCommandBuffers", free_command_buffers( - device: Device, - command_pool: CommandPool, - command_buffer_count: uint32_t, - p_command_buffers: *const CommandBuffer, - ) -> (); - - "vkBeginCommandBuffer", begin_command_buffer( - command_buffer: CommandBuffer, - p_begin_info: *const CommandBufferBeginInfo, - ) -> Result; - - "vkEndCommandBuffer", end_command_buffer( - command_buffer: CommandBuffer, - ) -> Result; - - "vkResetCommandBuffer", reset_command_buffer( - command_buffer: CommandBuffer, - flags: CommandBufferResetFlags, - ) -> Result; - - "vkCmdBindPipeline", cmd_bind_pipeline( - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - pipeline: Pipeline, - ) -> (); - - "vkCmdSetViewport", cmd_set_viewport( - command_buffer: CommandBuffer, - first_viewport: uint32_t, - viewport_count: uint32_t, - p_viewports: *const Viewport, - ) -> (); - - "vkCmdSetScissor", cmd_set_scissor( - command_buffer: CommandBuffer, - first_scissor: uint32_t, - scissor_count: uint32_t, - p_scissors: *const Rect2D, - ) -> (); - - "vkCmdSetLineWidth", cmd_set_line_width( - command_buffer: CommandBuffer, - line_width: c_float, - ) -> (); - - "vkCmdSetDepthBias", cmd_set_depth_bias( - command_buffer: CommandBuffer, - depth_bias_constant_factor: c_float, - depth_bias_clamp: c_float, - depth_bias_slope_factor: c_float, - ) -> (); - - "vkCmdSetBlendConstants", cmd_set_blend_constants( - command_buffer: CommandBuffer, - blend_constants: *const [c_float; 4], - ) -> (); - - "vkCmdSetDepthBounds", cmd_set_depth_bounds( - command_buffer: CommandBuffer, - min_depth_bounds: c_float, - max_depth_bounds: c_float, - ) -> (); - - "vkCmdSetStencilCompareMask", cmd_set_stencil_compare_mask( - command_buffer: CommandBuffer, - face_mask: StencilFaceFlags, - compare_mask: uint32_t, - ) -> (); - - "vkCmdSetStencilWriteMask", cmd_set_stencil_write_mask( - command_buffer: CommandBuffer, - face_mask: StencilFaceFlags, - write_mask: uint32_t, - ) -> (); - - "vkCmdSetStencilReference", cmd_set_stencil_reference( - command_buffer: CommandBuffer, - face_mask: StencilFaceFlags, - reference: uint32_t, - ) -> (); - - "vkCmdBindDescriptorSets", cmd_bind_descriptor_sets( - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - layout: PipelineLayout, - first_set: uint32_t, - descriptor_set_count: uint32_t, - p_descriptor_sets: *const DescriptorSet, - dynamic_offset_count: uint32_t, - p_dynamic_offsets: *const uint32_t, - ) -> (); - - "vkCmdBindIndexBuffer", cmd_bind_index_buffer( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - index_type: IndexType, - ) -> (); - - "vkCmdBindVertexBuffers", cmd_bind_vertex_buffers( - command_buffer: CommandBuffer, - first_binding: uint32_t, - binding_count: uint32_t, - p_buffers: *const Buffer, - p_offsets: *const DeviceSize, - ) -> (); - - "vkCmdDraw", cmd_draw( - command_buffer: CommandBuffer, - vertex_count: uint32_t, - instance_count: uint32_t, - first_vertex: uint32_t, - first_instance: uint32_t, - ) -> (); - - "vkCmdDrawIndexed", cmd_draw_indexed( - command_buffer: CommandBuffer, - index_count: uint32_t, - instance_count: uint32_t, - first_index: uint32_t, - vertex_offset: int32_t, - first_instance: uint32_t, - ) -> (); - - "vkCmdDrawIndirect", cmd_draw_indirect( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, - ) -> (); - - "vkCmdDrawIndexedIndirect", cmd_draw_indexed_indirect( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, - ) -> (); - - "vkCmdDispatch", cmd_dispatch( - command_buffer: CommandBuffer, - x: uint32_t, - y: uint32_t, - z: uint32_t, - ) -> (); - - "vkCmdDispatchIndirect", cmd_dispatch_indirect( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - ) -> (); - - "vkCmdCopyBuffer", cmd_copy_buffer( - command_buffer: CommandBuffer, - src_buffer: Buffer, - dst_buffer: Buffer, - region_count: uint32_t, - p_regions: *const BufferCopy, - ) -> (); - - "vkCmdCopyImage", cmd_copy_image( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const ImageCopy, - ) -> (); - - "vkCmdBlitImage", cmd_blit_image( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const ImageBlit, - filter: Filter, - ) -> (); - - "vkCmdCopyBufferToImage", cmd_copy_buffer_to_image( - command_buffer: CommandBuffer, - src_buffer: Buffer, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const BufferImageCopy, - ) -> (); - - "vkCmdCopyImageToBuffer", cmd_copy_image_to_buffer( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_buffer: Buffer, - region_count: uint32_t, - p_regions: *const BufferImageCopy, - ) -> (); - - "vkCmdUpdateBuffer", cmd_update_buffer( - command_buffer: CommandBuffer, - dst_buffer: Buffer, - dst_offset: DeviceSize, - data_size: DeviceSize, - p_data: *const c_void, - ) -> (); - - "vkCmdFillBuffer", cmd_fill_buffer( - command_buffer: CommandBuffer, - dst_buffer: Buffer, - dst_offset: DeviceSize, - size: DeviceSize, - data: uint32_t, - ) -> (); - - "vkCmdClearColorImage", cmd_clear_color_image( - command_buffer: CommandBuffer, - image: Image, - image_layout: ImageLayout, - p_color: *const ClearColorValue, - range_count: uint32_t, - p_ranges: *const ImageSubresourceRange, - ) -> (); - - "vkCmdClearDepthStencilImage", cmd_clear_depth_stencil_image( + p_set_layout: *const DescriptorSetLayout, + ) -> Result, + destroy_descriptor_set_layout: extern "system" fn( + device: Device, + descriptor_set_layout: DescriptorSetLayout, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_descriptor_pool: extern "system" fn( + device: Device, + p_create_info: *const DescriptorPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_pool: *const DescriptorPool, + ) -> Result, + destroy_descriptor_pool: extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + reset_descriptor_pool: extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + flags: DescriptorPoolResetFlags, + ) -> Result, + allocate_descriptor_sets: extern "system" fn( + device: Device, + p_allocate_info: *const DescriptorSetAllocateInfo, + p_descriptor_sets: *const DescriptorSet, + ) -> Result, + free_descriptor_sets: extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + descriptor_set_count: uint32_t, + p_descriptor_sets: *const DescriptorSet, + ) -> Result, + update_descriptor_sets: extern "system" fn( + device: Device, + descriptor_write_count: uint32_t, + p_descriptor_writes: *const WriteDescriptorSet, + descriptor_copy_count: uint32_t, + p_descriptor_copies: *const CopyDescriptorSet, + ) -> c_void, + create_framebuffer: extern "system" fn( + device: Device, + p_create_info: *const FramebufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_framebuffer: *const Framebuffer, + ) -> Result, + destroy_framebuffer: extern "system" fn( + device: Device, + framebuffer: Framebuffer, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_render_pass: extern "system" fn( + device: Device, + p_create_info: *const RenderPassCreateInfo, + p_allocator: *const AllocationCallbacks, + p_render_pass: *const RenderPass, + ) -> Result, + destroy_render_pass: extern "system" fn( + device: Device, + render_pass: RenderPass, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + get_render_area_granularity: + extern "system" fn(device: Device, render_pass: RenderPass, p_granularity: *const Extent2D) + -> c_void, + create_command_pool: extern "system" fn( + device: Device, + p_create_info: *const CommandPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_command_pool: *const CommandPool, + ) -> Result, + destroy_command_pool: extern "system" fn( + device: Device, + command_pool: CommandPool, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + reset_command_pool: + extern "system" fn(device: Device, command_pool: CommandPool, flags: CommandPoolResetFlags) + -> Result, + allocate_command_buffers: extern "system" fn( + device: Device, + p_allocate_info: *const CommandBufferAllocateInfo, + p_command_buffers: *const CommandBuffer, + ) -> Result, + free_command_buffers: extern "system" fn( + device: Device, + command_pool: CommandPool, + command_buffer_count: uint32_t, + p_command_buffers: *const CommandBuffer, + ) -> c_void, + begin_command_buffer: extern "system" fn( + command_buffer: CommandBuffer, + p_begin_info: *const CommandBufferBeginInfo, + ) -> Result, + end_command_buffer: extern "system" fn(command_buffer: CommandBuffer) -> Result, + reset_command_buffer: + extern "system" fn(command_buffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result, + cmd_bind_pipeline: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + ) -> c_void, + cmd_set_viewport: extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: uint32_t, + viewport_count: uint32_t, + p_viewports: *const Viewport, + ) -> c_void, + cmd_set_scissor: extern "system" fn( + command_buffer: CommandBuffer, + first_scissor: uint32_t, + scissor_count: uint32_t, + p_scissors: *const Rect2D, + ) -> c_void, + cmd_set_line_width: + extern "system" fn(command_buffer: CommandBuffer, line_width: c_float) -> c_void, + cmd_set_depth_bias: extern "system" fn( + command_buffer: CommandBuffer, + depth_bias_constant_factor: c_float, + depth_bias_clamp: c_float, + depth_bias_slope_factor: c_float, + ) -> c_void, + cmd_set_blend_constants: + extern "system" fn(command_buffer: CommandBuffer, blend_constants: [c_float; 4]) -> c_void, + cmd_set_depth_bounds: extern "system" fn( + command_buffer: CommandBuffer, + min_depth_bounds: c_float, + max_depth_bounds: c_float, + ) -> c_void, + cmd_set_stencil_compare_mask: extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + compare_mask: uint32_t, + ) -> c_void, + cmd_set_stencil_write_mask: extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + write_mask: uint32_t, + ) -> c_void, + cmd_set_stencil_reference: extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + reference: uint32_t, + ) -> c_void, + cmd_bind_descriptor_sets: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: uint32_t, + descriptor_set_count: uint32_t, + p_descriptor_sets: *const DescriptorSet, + dynamic_offset_count: uint32_t, + p_dynamic_offsets: *const uint32_t, + ) -> c_void, + cmd_bind_index_buffer: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + index_type: IndexType, + ) -> c_void, + cmd_bind_vertex_buffers: extern "system" fn( + command_buffer: CommandBuffer, + first_binding: uint32_t, + binding_count: uint32_t, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + ) -> c_void, + cmd_draw: extern "system" fn( + command_buffer: CommandBuffer, + vertex_count: uint32_t, + instance_count: uint32_t, + first_vertex: uint32_t, + first_instance: uint32_t, + ) -> c_void, + cmd_draw_indexed: extern "system" fn( + command_buffer: CommandBuffer, + index_count: uint32_t, + instance_count: uint32_t, + first_index: uint32_t, + vertex_offset: int32_t, + first_instance: uint32_t, + ) -> c_void, + cmd_draw_indirect: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + cmd_draw_indexed_indirect: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + cmd_dispatch: extern "system" fn( + command_buffer: CommandBuffer, + group_count_x: uint32_t, + group_count_y: uint32_t, + group_count_z: uint32_t, + ) -> c_void, + cmd_dispatch_indirect: + extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize) + -> c_void, + cmd_copy_buffer: extern "system" fn( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_buffer: Buffer, + region_count: uint32_t, + p_regions: *const BufferCopy, + ) -> c_void, + cmd_copy_image: extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageCopy, + ) -> c_void, + cmd_blit_image: extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageBlit, + filter: Filter, + ) -> c_void, + cmd_copy_buffer_to_image: extern "system" fn( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const BufferImageCopy, + ) -> c_void, + cmd_copy_image_to_buffer: extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_buffer: Buffer, + region_count: uint32_t, + p_regions: *const BufferImageCopy, + ) -> c_void, + cmd_update_buffer: extern "system" fn( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + data_size: DeviceSize, + p_data: *const c_void, + ) -> c_void, + cmd_fill_buffer: extern "system" fn( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + size: DeviceSize, + data: uint32_t, + ) -> c_void, + cmd_clear_color_image: extern "system" fn( + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_color: *const ClearColorValue, + range_count: uint32_t, + p_ranges: *const ImageSubresourceRange, + ) -> c_void, + cmd_clear_depth_stencil_image: + extern "system" fn( command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, range_count: uint32_t, p_ranges: *const ImageSubresourceRange, - ) -> (); - - "vkCmdClearAttachments", cmd_clear_attachments( - command_buffer: CommandBuffer, - attachment_count: uint32_t, - p_attachments: *const ClearAttachment, - rect_count: uint32_t, - p_rects: *const ClearRect, - ) -> (); - - "vkCmdResolveImage", cmd_resolve_image( - command_buffer: CommandBuffer, - src_image: Image, - src_image_layout: ImageLayout, - dst_image: Image, - dst_image_layout: ImageLayout, - region_count: uint32_t, - p_regions: *const ImageResolve, - ) -> (); - - "vkCmdSetEvent", cmd_set_event( - command_buffer: CommandBuffer, - event: Event, - stage_mask: PipelineStageFlags, - ) -> (); - - "vkCmdResetEvent", cmd_reset_event( - command_buffer: CommandBuffer, - event: Event, - stage_mask: PipelineStageFlags, - ) -> (); - - "vkCmdWaitEvents", cmd_wait_events( - command_buffer: CommandBuffer, - event_count: uint32_t, - p_events: *const Event, - src_stage_mask: PipelineStageFlags, - dst_stage_mask: PipelineStageFlags, - memory_barrier_count: uint32_t, - p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, - p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, - p_image_memory_barriers: *const ImageMemoryBarrier, - ) -> (); - - "vkCmdPipelineBarrier", cmd_pipeline_barrier( - command_buffer: CommandBuffer, - src_stage_mask: PipelineStageFlags, - dst_stage_mask: PipelineStageFlags, - dependency_flags: DependencyFlags, - memory_barrier_count: uint32_t, - p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, - p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, - p_image_memory_barriers: *const ImageMemoryBarrier, - ) -> (); - - "vkCmdBeginQuery", cmd_begin_query( - command_buffer: CommandBuffer, - query_pool: QueryPool, - query: uint32_t, - flags: QueryControlFlags, - ) -> (); - - "vkCmdEndQuery", cmd_end_query( - command_buffer: CommandBuffer, - query_pool: QueryPool, - query: uint32_t, - ) -> (); - - "vkCmdResetQueryPool", cmd_reset_query_pool( - command_buffer: CommandBuffer, - query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - ) -> (); - - "vkCmdWriteTimestamp", cmd_write_timestamp( - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - query_pool: QueryPool, - query: uint32_t, - ) -> (); - - "vkCmdCopyQueryPoolResults", cmd_copy_query_pool_results( - command_buffer: CommandBuffer, - query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - dst_buffer: Buffer, - dst_offset: DeviceSize, - stride: DeviceSize, - flags: QueryResultFlags, - ) -> (); - - "vkCmdPushConstants", cmd_push_constants( - command_buffer: CommandBuffer, - layout: PipelineLayout, - stage_flags: ShaderStageFlags, - offset: uint32_t, - size: uint32_t, - p_values: *const c_void, - ) -> (); - - "vkCmdBeginRenderPass", cmd_begin_render_pass( - command_buffer: CommandBuffer, - p_render_pass_begin: *const RenderPassBeginInfo, - contents: SubpassContents, - ) -> (); - - "vkCmdNextSubpass", cmd_next_subpass( - command_buffer: CommandBuffer, - contents: SubpassContents, - ) -> (); - - "vkCmdEndRenderPass", cmd_end_render_pass( - command_buffer: CommandBuffer, - ) -> (); - - "vkCmdExecuteCommands", cmd_execute_commands( - command_buffer: CommandBuffer, - command_buffer_count: uint32_t, - p_command_buffers: *const CommandBuffer, - ) -> (); + ) -> c_void, + cmd_clear_attachments: extern "system" fn( + command_buffer: CommandBuffer, + attachment_count: uint32_t, + p_attachments: *const ClearAttachment, + rect_count: uint32_t, + p_rects: *const ClearRect, + ) -> c_void, + cmd_resolve_image: extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageResolve, + ) -> c_void, + cmd_set_event: extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, + ) -> c_void, + cmd_reset_event: extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, + ) -> c_void, + cmd_wait_events: extern "system" fn( + command_buffer: CommandBuffer, + event_count: uint32_t, + p_events: *const Event, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + memory_barrier_count: uint32_t, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: uint32_t, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: uint32_t, + p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> c_void, + cmd_pipeline_barrier: extern "system" fn( + command_buffer: CommandBuffer, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + dependency_flags: DependencyFlags, + memory_barrier_count: uint32_t, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: uint32_t, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: uint32_t, + p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> c_void, + cmd_begin_query: extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: uint32_t, + flags: QueryControlFlags, + ) -> c_void, + cmd_end_query: + extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: uint32_t) + -> c_void, + cmd_reset_query_pool: extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + ) -> c_void, + cmd_write_timestamp: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + query_pool: QueryPool, + query: uint32_t, + ) -> c_void, + cmd_copy_query_pool_results: extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + dst_buffer: Buffer, + dst_offset: DeviceSize, + stride: DeviceSize, + flags: QueryResultFlags, + ) -> c_void, + cmd_push_constants: extern "system" fn( + command_buffer: CommandBuffer, + layout: PipelineLayout, + stage_flags: ShaderStageFlags, + offset: uint32_t, + size: uint32_t, + p_values: *const c_void, + ) -> c_void, + cmd_begin_render_pass: extern "system" fn( + command_buffer: CommandBuffer, + p_render_pass_begin: *const RenderPassBeginInfo, + contents: SubpassContents, + ) -> c_void, + cmd_next_subpass: + extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents) -> c_void, + cmd_end_render_pass: extern "system" fn(command_buffer: CommandBuffer) -> c_void, + cmd_execute_commands: extern "system" fn( + command_buffer: CommandBuffer, + command_buffer_count: uint32_t, + p_command_buffers: *const CommandBuffer, + ) -> c_void, +} +unsafe impl Send for DeviceFnV1_0 {} +unsafe impl Sync for DeviceFnV1_0 {} +impl ::std::clone::Clone for DeviceFnV1_0 { + fn clone(&self) -> Self { + DeviceFnV1_0 { + destroy_device: self.destroy_device, + get_device_queue: self.get_device_queue, + queue_submit: self.queue_submit, + queue_wait_idle: self.queue_wait_idle, + device_wait_idle: self.device_wait_idle, + allocate_memory: self.allocate_memory, + free_memory: self.free_memory, + map_memory: self.map_memory, + unmap_memory: self.unmap_memory, + flush_mapped_memory_ranges: self.flush_mapped_memory_ranges, + invalidate_mapped_memory_ranges: self.invalidate_mapped_memory_ranges, + get_device_memory_commitment: self.get_device_memory_commitment, + bind_buffer_memory: self.bind_buffer_memory, + bind_image_memory: self.bind_image_memory, + get_buffer_memory_requirements: self.get_buffer_memory_requirements, + get_image_memory_requirements: self.get_image_memory_requirements, + get_image_sparse_memory_requirements: self.get_image_sparse_memory_requirements, + queue_bind_sparse: self.queue_bind_sparse, + create_fence: self.create_fence, + destroy_fence: self.destroy_fence, + reset_fences: self.reset_fences, + get_fence_status: self.get_fence_status, + wait_for_fences: self.wait_for_fences, + create_semaphore: self.create_semaphore, + destroy_semaphore: self.destroy_semaphore, + create_event: self.create_event, + destroy_event: self.destroy_event, + get_event_status: self.get_event_status, + set_event: self.set_event, + reset_event: self.reset_event, + create_query_pool: self.create_query_pool, + destroy_query_pool: self.destroy_query_pool, + get_query_pool_results: self.get_query_pool_results, + create_buffer: self.create_buffer, + destroy_buffer: self.destroy_buffer, + create_buffer_view: self.create_buffer_view, + destroy_buffer_view: self.destroy_buffer_view, + create_image: self.create_image, + destroy_image: self.destroy_image, + get_image_subresource_layout: self.get_image_subresource_layout, + create_image_view: self.create_image_view, + destroy_image_view: self.destroy_image_view, + create_shader_module: self.create_shader_module, + destroy_shader_module: self.destroy_shader_module, + create_pipeline_cache: self.create_pipeline_cache, + destroy_pipeline_cache: self.destroy_pipeline_cache, + get_pipeline_cache_data: self.get_pipeline_cache_data, + merge_pipeline_caches: self.merge_pipeline_caches, + create_graphics_pipelines: self.create_graphics_pipelines, + create_compute_pipelines: self.create_compute_pipelines, + destroy_pipeline: self.destroy_pipeline, + create_pipeline_layout: self.create_pipeline_layout, + destroy_pipeline_layout: self.destroy_pipeline_layout, + create_sampler: self.create_sampler, + destroy_sampler: self.destroy_sampler, + create_descriptor_set_layout: self.create_descriptor_set_layout, + destroy_descriptor_set_layout: self.destroy_descriptor_set_layout, + create_descriptor_pool: self.create_descriptor_pool, + destroy_descriptor_pool: self.destroy_descriptor_pool, + reset_descriptor_pool: self.reset_descriptor_pool, + allocate_descriptor_sets: self.allocate_descriptor_sets, + free_descriptor_sets: self.free_descriptor_sets, + update_descriptor_sets: self.update_descriptor_sets, + create_framebuffer: self.create_framebuffer, + destroy_framebuffer: self.destroy_framebuffer, + create_render_pass: self.create_render_pass, + destroy_render_pass: self.destroy_render_pass, + get_render_area_granularity: self.get_render_area_granularity, + create_command_pool: self.create_command_pool, + destroy_command_pool: self.destroy_command_pool, + reset_command_pool: self.reset_command_pool, + allocate_command_buffers: self.allocate_command_buffers, + free_command_buffers: self.free_command_buffers, + begin_command_buffer: self.begin_command_buffer, + end_command_buffer: self.end_command_buffer, + reset_command_buffer: self.reset_command_buffer, + cmd_bind_pipeline: self.cmd_bind_pipeline, + cmd_set_viewport: self.cmd_set_viewport, + cmd_set_scissor: self.cmd_set_scissor, + cmd_set_line_width: self.cmd_set_line_width, + cmd_set_depth_bias: self.cmd_set_depth_bias, + cmd_set_blend_constants: self.cmd_set_blend_constants, + cmd_set_depth_bounds: self.cmd_set_depth_bounds, + cmd_set_stencil_compare_mask: self.cmd_set_stencil_compare_mask, + cmd_set_stencil_write_mask: self.cmd_set_stencil_write_mask, + cmd_set_stencil_reference: self.cmd_set_stencil_reference, + cmd_bind_descriptor_sets: self.cmd_bind_descriptor_sets, + cmd_bind_index_buffer: self.cmd_bind_index_buffer, + cmd_bind_vertex_buffers: self.cmd_bind_vertex_buffers, + cmd_draw: self.cmd_draw, + cmd_draw_indexed: self.cmd_draw_indexed, + cmd_draw_indirect: self.cmd_draw_indirect, + cmd_draw_indexed_indirect: self.cmd_draw_indexed_indirect, + cmd_dispatch: self.cmd_dispatch, + cmd_dispatch_indirect: self.cmd_dispatch_indirect, + cmd_copy_buffer: self.cmd_copy_buffer, + cmd_copy_image: self.cmd_copy_image, + cmd_blit_image: self.cmd_blit_image, + cmd_copy_buffer_to_image: self.cmd_copy_buffer_to_image, + cmd_copy_image_to_buffer: self.cmd_copy_image_to_buffer, + cmd_update_buffer: self.cmd_update_buffer, + cmd_fill_buffer: self.cmd_fill_buffer, + cmd_clear_color_image: self.cmd_clear_color_image, + cmd_clear_depth_stencil_image: self.cmd_clear_depth_stencil_image, + cmd_clear_attachments: self.cmd_clear_attachments, + cmd_resolve_image: self.cmd_resolve_image, + cmd_set_event: self.cmd_set_event, + cmd_reset_event: self.cmd_reset_event, + cmd_wait_events: self.cmd_wait_events, + cmd_pipeline_barrier: self.cmd_pipeline_barrier, + cmd_begin_query: self.cmd_begin_query, + cmd_end_query: self.cmd_end_query, + cmd_reset_query_pool: self.cmd_reset_query_pool, + cmd_write_timestamp: self.cmd_write_timestamp, + cmd_copy_query_pool_results: self.cmd_copy_query_pool_results, + cmd_push_constants: self.cmd_push_constants, + cmd_begin_render_pass: self.cmd_begin_render_pass, + cmd_next_subpass: self.cmd_next_subpass, + cmd_end_render_pass: self.cmd_end_render_pass, + cmd_execute_commands: self.cmd_execute_commands, + } } - - vk_functions!{ - DisplaySwapchainFn, - "vkCreateSharedSwapchainsKHR", create_shared_swapchains_khr( - device: Device, - swapchain_count: uint32_t, - p_create_infos: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchains: *mut SwapchainKHR, - ) -> Result; +} +impl DeviceFnV1_0 { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = DeviceFnV1_0 { + destroy_device: unsafe { + let raw_name = stringify!(vkDestroyDevice); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_queue: unsafe { + let raw_name = stringify!(vkGetDeviceQueue); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_submit: unsafe { + let raw_name = stringify!(vkQueueSubmit); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_wait_idle: unsafe { + let raw_name = stringify!(vkQueueWaitIdle); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + device_wait_idle: unsafe { + let raw_name = stringify!(vkDeviceWaitIdle); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + allocate_memory: unsafe { + let raw_name = stringify!(vkAllocateMemory); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + free_memory: unsafe { + let raw_name = stringify!(vkFreeMemory); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + map_memory: unsafe { + let raw_name = stringify!(vkMapMemory); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + unmap_memory: unsafe { + let raw_name = stringify!(vkUnmapMemory); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + flush_mapped_memory_ranges: unsafe { + let raw_name = stringify!(vkFlushMappedMemoryRanges); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + invalidate_mapped_memory_ranges: unsafe { + let raw_name = stringify!(vkInvalidateMappedMemoryRanges); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_memory_commitment: unsafe { + let raw_name = stringify!(vkGetDeviceMemoryCommitment); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + bind_buffer_memory: unsafe { + let raw_name = stringify!(vkBindBufferMemory); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + bind_image_memory: unsafe { + let raw_name = stringify!(vkBindImageMemory); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_buffer_memory_requirements: unsafe { + let raw_name = stringify!(vkGetBufferMemoryRequirements); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_image_memory_requirements: unsafe { + let raw_name = stringify!(vkGetImageMemoryRequirements); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_image_sparse_memory_requirements: unsafe { + let raw_name = stringify!(vkGetImageSparseMemoryRequirements); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_bind_sparse: unsafe { + let raw_name = stringify!(vkQueueBindSparse); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_fence: unsafe { + let raw_name = stringify!(vkCreateFence); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_fence: unsafe { + let raw_name = stringify!(vkDestroyFence); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + reset_fences: unsafe { + let raw_name = stringify!(vkResetFences); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_fence_status: unsafe { + let raw_name = stringify!(vkGetFenceStatus); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + wait_for_fences: unsafe { + let raw_name = stringify!(vkWaitForFences); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_semaphore: unsafe { + let raw_name = stringify!(vkCreateSemaphore); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_semaphore: unsafe { + let raw_name = stringify!(vkDestroySemaphore); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_event: unsafe { + let raw_name = stringify!(vkCreateEvent); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_event: unsafe { + let raw_name = stringify!(vkDestroyEvent); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_event_status: unsafe { + let raw_name = stringify!(vkGetEventStatus); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + set_event: unsafe { + let raw_name = stringify!(vkSetEvent); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + reset_event: unsafe { + let raw_name = stringify!(vkResetEvent); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_query_pool: unsafe { + let raw_name = stringify!(vkCreateQueryPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_query_pool: unsafe { + let raw_name = stringify!(vkDestroyQueryPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_query_pool_results: unsafe { + let raw_name = stringify!(vkGetQueryPoolResults); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_buffer: unsafe { + let raw_name = stringify!(vkCreateBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_buffer: unsafe { + let raw_name = stringify!(vkDestroyBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_buffer_view: unsafe { + let raw_name = stringify!(vkCreateBufferView); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_buffer_view: unsafe { + let raw_name = stringify!(vkDestroyBufferView); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_image: unsafe { + let raw_name = stringify!(vkCreateImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_image: unsafe { + let raw_name = stringify!(vkDestroyImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_image_subresource_layout: unsafe { + let raw_name = stringify!(vkGetImageSubresourceLayout); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_image_view: unsafe { + let raw_name = stringify!(vkCreateImageView); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_image_view: unsafe { + let raw_name = stringify!(vkDestroyImageView); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_shader_module: unsafe { + let raw_name = stringify!(vkCreateShaderModule); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_shader_module: unsafe { + let raw_name = stringify!(vkDestroyShaderModule); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_pipeline_cache: unsafe { + let raw_name = stringify!(vkCreatePipelineCache); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_pipeline_cache: unsafe { + let raw_name = stringify!(vkDestroyPipelineCache); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_pipeline_cache_data: unsafe { + let raw_name = stringify!(vkGetPipelineCacheData); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + merge_pipeline_caches: unsafe { + let raw_name = stringify!(vkMergePipelineCaches); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_graphics_pipelines: unsafe { + let raw_name = stringify!(vkCreateGraphicsPipelines); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_compute_pipelines: unsafe { + let raw_name = stringify!(vkCreateComputePipelines); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_pipeline: unsafe { + let raw_name = stringify!(vkDestroyPipeline); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_pipeline_layout: unsafe { + let raw_name = stringify!(vkCreatePipelineLayout); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_pipeline_layout: unsafe { + let raw_name = stringify!(vkDestroyPipelineLayout); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_sampler: unsafe { + let raw_name = stringify!(vkCreateSampler); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_sampler: unsafe { + let raw_name = stringify!(vkDestroySampler); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_descriptor_set_layout: unsafe { + let raw_name = stringify!(vkCreateDescriptorSetLayout); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_descriptor_set_layout: unsafe { + let raw_name = stringify!(vkDestroyDescriptorSetLayout); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_descriptor_pool: unsafe { + let raw_name = stringify!(vkCreateDescriptorPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_descriptor_pool: unsafe { + let raw_name = stringify!(vkDestroyDescriptorPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + reset_descriptor_pool: unsafe { + let raw_name = stringify!(vkResetDescriptorPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + allocate_descriptor_sets: unsafe { + let raw_name = stringify!(vkAllocateDescriptorSets); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + free_descriptor_sets: unsafe { + let raw_name = stringify!(vkFreeDescriptorSets); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + update_descriptor_sets: unsafe { + let raw_name = stringify!(vkUpdateDescriptorSets); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_framebuffer: unsafe { + let raw_name = stringify!(vkCreateFramebuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_framebuffer: unsafe { + let raw_name = stringify!(vkDestroyFramebuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_render_pass: unsafe { + let raw_name = stringify!(vkCreateRenderPass); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_render_pass: unsafe { + let raw_name = stringify!(vkDestroyRenderPass); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_render_area_granularity: unsafe { + let raw_name = stringify!(vkGetRenderAreaGranularity); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_command_pool: unsafe { + let raw_name = stringify!(vkCreateCommandPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_command_pool: unsafe { + let raw_name = stringify!(vkDestroyCommandPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + reset_command_pool: unsafe { + let raw_name = stringify!(vkResetCommandPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + allocate_command_buffers: unsafe { + let raw_name = stringify!(vkAllocateCommandBuffers); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + free_command_buffers: unsafe { + let raw_name = stringify!(vkFreeCommandBuffers); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + begin_command_buffer: unsafe { + let raw_name = stringify!(vkBeginCommandBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + end_command_buffer: unsafe { + let raw_name = stringify!(vkEndCommandBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + reset_command_buffer: unsafe { + let raw_name = stringify!(vkResetCommandBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_bind_pipeline: unsafe { + let raw_name = stringify!(vkCmdBindPipeline); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_viewport: unsafe { + let raw_name = stringify!(vkCmdSetViewport); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_scissor: unsafe { + let raw_name = stringify!(vkCmdSetScissor); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_line_width: unsafe { + let raw_name = stringify!(vkCmdSetLineWidth); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_depth_bias: unsafe { + let raw_name = stringify!(vkCmdSetDepthBias); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_blend_constants: unsafe { + let raw_name = stringify!(vkCmdSetBlendConstants); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_depth_bounds: unsafe { + let raw_name = stringify!(vkCmdSetDepthBounds); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_stencil_compare_mask: unsafe { + let raw_name = stringify!(vkCmdSetStencilCompareMask); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_stencil_write_mask: unsafe { + let raw_name = stringify!(vkCmdSetStencilWriteMask); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_stencil_reference: unsafe { + let raw_name = stringify!(vkCmdSetStencilReference); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_bind_descriptor_sets: unsafe { + let raw_name = stringify!(vkCmdBindDescriptorSets); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_bind_index_buffer: unsafe { + let raw_name = stringify!(vkCmdBindIndexBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_bind_vertex_buffers: unsafe { + let raw_name = stringify!(vkCmdBindVertexBuffers); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw: unsafe { + let raw_name = stringify!(vkCmdDraw); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed: unsafe { + let raw_name = stringify!(vkCmdDrawIndexed); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indirect: unsafe { + let raw_name = stringify!(vkCmdDrawIndirect); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed_indirect: unsafe { + let raw_name = stringify!(vkCmdDrawIndexedIndirect); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_dispatch: unsafe { + let raw_name = stringify!(vkCmdDispatch); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_dispatch_indirect: unsafe { + let raw_name = stringify!(vkCmdDispatchIndirect); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_copy_buffer: unsafe { + let raw_name = stringify!(vkCmdCopyBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_copy_image: unsafe { + let raw_name = stringify!(vkCmdCopyImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_blit_image: unsafe { + let raw_name = stringify!(vkCmdBlitImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_copy_buffer_to_image: unsafe { + let raw_name = stringify!(vkCmdCopyBufferToImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_copy_image_to_buffer: unsafe { + let raw_name = stringify!(vkCmdCopyImageToBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_update_buffer: unsafe { + let raw_name = stringify!(vkCmdUpdateBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_fill_buffer: unsafe { + let raw_name = stringify!(vkCmdFillBuffer); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_clear_color_image: unsafe { + let raw_name = stringify!(vkCmdClearColorImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_clear_depth_stencil_image: unsafe { + let raw_name = stringify!(vkCmdClearDepthStencilImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_clear_attachments: unsafe { + let raw_name = stringify!(vkCmdClearAttachments); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_resolve_image: unsafe { + let raw_name = stringify!(vkCmdResolveImage); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_event: unsafe { + let raw_name = stringify!(vkCmdSetEvent); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_reset_event: unsafe { + let raw_name = stringify!(vkCmdResetEvent); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_wait_events: unsafe { + let raw_name = stringify!(vkCmdWaitEvents); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_pipeline_barrier: unsafe { + let raw_name = stringify!(vkCmdPipelineBarrier); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_begin_query: unsafe { + let raw_name = stringify!(vkCmdBeginQuery); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_end_query: unsafe { + let raw_name = stringify!(vkCmdEndQuery); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_reset_query_pool: unsafe { + let raw_name = stringify!(vkCmdResetQueryPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_write_timestamp: unsafe { + let raw_name = stringify!(vkCmdWriteTimestamp); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_copy_query_pool_results: unsafe { + let raw_name = stringify!(vkCmdCopyQueryPoolResults); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_push_constants: unsafe { + let raw_name = stringify!(vkCmdPushConstants); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_begin_render_pass: unsafe { + let raw_name = stringify!(vkCmdBeginRenderPass); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_next_subpass: unsafe { + let raw_name = stringify!(vkCmdNextSubpass); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_end_render_pass: unsafe { + let raw_name = stringify!(vkCmdEndRenderPass); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_execute_commands: unsafe { + let raw_name = stringify!(vkCmdExecuteCommands); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - - vk_functions!{ - SwapchainFn, - "vkCreateSwapchainKHR", create_swapchain_khr( - device: Device, - p_create_info: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchain: *mut SwapchainKHR, - ) -> Result; - - "vkDestroySwapchainKHR", destroy_swapchain_khr( - device: Device, - swapchain: SwapchainKHR, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetSwapchainImagesKHR", get_swapchain_images_khr( - device: Device, - swapchain: SwapchainKHR, - p_swapchain_image_count: *mut uint32_t, - p_swapchain_images: *mut Image, - ) -> Result; - - "vkAcquireNextImageKHR", acquire_next_image_khr( - device: Device, - swapchain: SwapchainKHR, - timeout: uint64_t, - semaphore: Semaphore, - fence: Fence, - p_image_index: *mut uint32_t, - ) -> Result; - - "vkQueuePresentKHR", queue_present_khr( - queue: Queue, - p_present_info: *const PresentInfoKHR, - ) -> Result; + pub unsafe fn destroy_device( + &self, + device: Device, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_device)(device, p_allocator) } - - vk_functions!{ - SurfaceFn, - "vkDestroySurfaceKHR", destroy_surface_khr( - instance: Instance, - surface: SurfaceKHR, + pub unsafe fn get_device_queue( + &self, + device: Device, + queue_family_index: uint32_t, + queue_index: uint32_t, + p_queue: *const Queue, + ) -> c_void { + (self.get_device_queue)(device, queue_family_index, queue_index, p_queue) + } + pub unsafe fn queue_submit( + &self, + queue: Queue, + submit_count: uint32_t, + p_submits: *const SubmitInfo, + fence: Fence, + ) -> Result { + (self.queue_submit)(queue, submit_count, p_submits, fence) + } + pub unsafe fn queue_wait_idle(&self, queue: Queue) -> Result { + (self.queue_wait_idle)(queue) + } + pub unsafe fn device_wait_idle(&self, device: Device) -> Result { + (self.device_wait_idle)(device) + } + pub unsafe fn allocate_memory( + &self, + device: Device, + p_allocate_info: *const MemoryAllocateInfo, + p_allocator: *const AllocationCallbacks, + p_memory: *const DeviceMemory, + ) -> Result { + (self.allocate_memory)(device, p_allocate_info, p_allocator, p_memory) + } + pub unsafe fn free_memory( + &self, + device: Device, + memory: DeviceMemory, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.free_memory)(device, memory, p_allocator) + } + pub unsafe fn map_memory( + &self, + device: Device, + memory: DeviceMemory, + offset: DeviceSize, + size: DeviceSize, + flags: MemoryMapFlags, + pp_data: *mut *mut c_void, + ) -> Result { + (self.map_memory)(device, memory, offset, size, flags, pp_data) + } + pub unsafe fn unmap_memory(&self, device: Device, memory: DeviceMemory) -> c_void { + (self.unmap_memory)(device, memory) + } + pub unsafe fn flush_mapped_memory_ranges( + &self, + device: Device, + memory_range_count: uint32_t, + p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + (self.flush_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) + } + pub unsafe fn invalidate_mapped_memory_ranges( + &self, + device: Device, + memory_range_count: uint32_t, + p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + (self.invalidate_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) + } + pub unsafe fn get_device_memory_commitment( + &self, + device: Device, + memory: DeviceMemory, + p_committed_memory_in_bytes: *const DeviceSize, + ) -> c_void { + (self.get_device_memory_commitment)(device, memory, p_committed_memory_in_bytes) + } + pub unsafe fn bind_buffer_memory( + &self, + device: Device, + buffer: Buffer, + memory: DeviceMemory, + memory_offset: DeviceSize, + ) -> Result { + (self.bind_buffer_memory)(device, buffer, memory, memory_offset) + } + pub unsafe fn bind_image_memory( + &self, + device: Device, + image: Image, + memory: DeviceMemory, + memory_offset: DeviceSize, + ) -> Result { + (self.bind_image_memory)(device, image, memory, memory_offset) + } + pub unsafe fn get_buffer_memory_requirements( + &self, + device: Device, + buffer: Buffer, + p_memory_requirements: *const MemoryRequirements, + ) -> c_void { + (self.get_buffer_memory_requirements)(device, buffer, p_memory_requirements) + } + pub unsafe fn get_image_memory_requirements( + &self, + device: Device, + image: Image, + p_memory_requirements: *const MemoryRequirements, + ) -> c_void { + (self.get_image_memory_requirements)(device, image, p_memory_requirements) + } + pub unsafe fn get_image_sparse_memory_requirements( + &self, + device: Device, + image: Image, + p_sparse_memory_requirement_count: *const uint32_t, + p_sparse_memory_requirements: *const SparseImageMemoryRequirements, + ) -> c_void { + (self.get_image_sparse_memory_requirements)( + device, + image, + p_sparse_memory_requirement_count, + p_sparse_memory_requirements, + ) + } + pub unsafe fn queue_bind_sparse( + &self, + queue: Queue, + bind_info_count: uint32_t, + p_bind_info: *const BindSparseInfo, + fence: Fence, + ) -> Result { + (self.queue_bind_sparse)(queue, bind_info_count, p_bind_info, fence) + } + pub unsafe fn create_fence( + &self, + device: Device, + p_create_info: *const FenceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result { + (self.create_fence)(device, p_create_info, p_allocator, p_fence) + } + pub unsafe fn destroy_fence( + &self, + device: Device, + fence: Fence, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_fence)(device, fence, p_allocator) + } + pub unsafe fn reset_fences( + &self, + device: Device, + fence_count: uint32_t, + p_fences: *const Fence, + ) -> Result { + (self.reset_fences)(device, fence_count, p_fences) + } + pub unsafe fn get_fence_status(&self, device: Device, fence: Fence) -> Result { + (self.get_fence_status)(device, fence) + } + pub unsafe fn wait_for_fences( + &self, + device: Device, + fence_count: uint32_t, + p_fences: *const Fence, + wait_all: Bool32, + timeout: uint64_t, + ) -> Result { + (self.wait_for_fences)(device, fence_count, p_fences, wait_all, timeout) + } + pub unsafe fn create_semaphore( + &self, + device: Device, + p_create_info: *const SemaphoreCreateInfo, + p_allocator: *const AllocationCallbacks, + p_semaphore: *const Semaphore, + ) -> Result { + (self.create_semaphore)(device, p_create_info, p_allocator, p_semaphore) + } + pub unsafe fn destroy_semaphore( + &self, + device: Device, + semaphore: Semaphore, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_semaphore)(device, semaphore, p_allocator) + } + pub unsafe fn create_event( + &self, + device: Device, + p_create_info: *const EventCreateInfo, + p_allocator: *const AllocationCallbacks, + p_event: *const Event, + ) -> Result { + (self.create_event)(device, p_create_info, p_allocator, p_event) + } + pub unsafe fn destroy_event( + &self, + device: Device, + event: Event, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_event)(device, event, p_allocator) + } + pub unsafe fn get_event_status(&self, device: Device, event: Event) -> Result { + (self.get_event_status)(device, event) + } + pub unsafe fn set_event(&self, device: Device, event: Event) -> Result { + (self.set_event)(device, event) + } + pub unsafe fn reset_event(&self, device: Device, event: Event) -> Result { + (self.reset_event)(device, event) + } + pub unsafe fn create_query_pool( + &self, + device: Device, + p_create_info: *const QueryPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_query_pool: *const QueryPool, + ) -> Result { + (self.create_query_pool)(device, p_create_info, p_allocator, p_query_pool) + } + pub unsafe fn destroy_query_pool( + &self, + device: Device, + query_pool: QueryPool, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_query_pool)(device, query_pool, p_allocator) + } + pub unsafe fn get_query_pool_results( + &self, + device: Device, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + data_size: size_t, + p_data: *const c_void, + stride: DeviceSize, + flags: QueryResultFlags, + ) -> Result { + (self.get_query_pool_results)( + device, + query_pool, + first_query, + query_count, + data_size, + p_data, + stride, + flags, + ) + } + pub unsafe fn create_buffer( + &self, + device: Device, + p_create_info: *const BufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_buffer: *const Buffer, + ) -> Result { + (self.create_buffer)(device, p_create_info, p_allocator, p_buffer) + } + pub unsafe fn destroy_buffer( + &self, + device: Device, + buffer: Buffer, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_buffer)(device, buffer, p_allocator) + } + pub unsafe fn create_buffer_view( + &self, + device: Device, + p_create_info: *const BufferViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *const BufferView, + ) -> Result { + (self.create_buffer_view)(device, p_create_info, p_allocator, p_view) + } + pub unsafe fn destroy_buffer_view( + &self, + device: Device, + buffer_view: BufferView, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_buffer_view)(device, buffer_view, p_allocator) + } + pub unsafe fn create_image( + &self, + device: Device, + p_create_info: *const ImageCreateInfo, + p_allocator: *const AllocationCallbacks, + p_image: *const Image, + ) -> Result { + (self.create_image)(device, p_create_info, p_allocator, p_image) + } + pub unsafe fn destroy_image( + &self, + device: Device, + image: Image, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_image)(device, image, p_allocator) + } + pub unsafe fn get_image_subresource_layout( + &self, + device: Device, + image: Image, + p_subresource: *const ImageSubresource, + p_layout: *const SubresourceLayout, + ) -> c_void { + (self.get_image_subresource_layout)(device, image, p_subresource, p_layout) + } + pub unsafe fn create_image_view( + &self, + device: Device, + p_create_info: *const ImageViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *const ImageView, + ) -> Result { + (self.create_image_view)(device, p_create_info, p_allocator, p_view) + } + pub unsafe fn destroy_image_view( + &self, + device: Device, + image_view: ImageView, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_image_view)(device, image_view, p_allocator) + } + pub unsafe fn create_shader_module( + &self, + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_allocator: *const AllocationCallbacks, + p_shader_module: *const ShaderModule, + ) -> Result { + (self.create_shader_module)(device, p_create_info, p_allocator, p_shader_module) + } + pub unsafe fn destroy_shader_module( + &self, + device: Device, + shader_module: ShaderModule, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_shader_module)(device, shader_module, p_allocator) + } + pub unsafe fn create_pipeline_cache( + &self, + device: Device, + p_create_info: *const PipelineCacheCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_cache: *const PipelineCache, + ) -> Result { + (self.create_pipeline_cache)(device, p_create_info, p_allocator, p_pipeline_cache) + } + pub unsafe fn destroy_pipeline_cache( + &self, + device: Device, + pipeline_cache: PipelineCache, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_pipeline_cache)(device, pipeline_cache, p_allocator) + } + pub unsafe fn get_pipeline_cache_data( + &self, + device: Device, + pipeline_cache: PipelineCache, + p_data_size: *const size_t, + p_data: *const c_void, + ) -> Result { + (self.get_pipeline_cache_data)(device, pipeline_cache, p_data_size, p_data) + } + pub unsafe fn merge_pipeline_caches( + &self, + device: Device, + dst_cache: PipelineCache, + src_cache_count: uint32_t, + p_src_caches: *const PipelineCache, + ) -> Result { + (self.merge_pipeline_caches)(device, dst_cache, src_cache_count, p_src_caches) + } + pub unsafe fn create_graphics_pipelines( + &self, + device: Device, + pipeline_cache: PipelineCache, + create_info_count: uint32_t, + p_create_infos: *const GraphicsPipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *const Pipeline, + ) -> Result { + (self.create_graphics_pipelines)( + device, + pipeline_cache, + create_info_count, + p_create_infos, + p_allocator, + p_pipelines, + ) + } + pub unsafe fn create_compute_pipelines( + &self, + device: Device, + pipeline_cache: PipelineCache, + create_info_count: uint32_t, + p_create_infos: *const ComputePipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *const Pipeline, + ) -> Result { + (self.create_compute_pipelines)( + device, + pipeline_cache, + create_info_count, + p_create_infos, + p_allocator, + p_pipelines, + ) + } + pub unsafe fn destroy_pipeline( + &self, + device: Device, + pipeline: Pipeline, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_pipeline)(device, pipeline, p_allocator) + } + pub unsafe fn create_pipeline_layout( + &self, + device: Device, + p_create_info: *const PipelineLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_layout: *const PipelineLayout, + ) -> Result { + (self.create_pipeline_layout)(device, p_create_info, p_allocator, p_pipeline_layout) + } + pub unsafe fn destroy_pipeline_layout( + &self, + device: Device, + pipeline_layout: PipelineLayout, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_pipeline_layout)(device, pipeline_layout, p_allocator) + } + pub unsafe fn create_sampler( + &self, + device: Device, + p_create_info: *const SamplerCreateInfo, + p_allocator: *const AllocationCallbacks, + p_sampler: *const Sampler, + ) -> Result { + (self.create_sampler)(device, p_create_info, p_allocator, p_sampler) + } + pub unsafe fn destroy_sampler( + &self, + device: Device, + sampler: Sampler, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_sampler)(device, sampler, p_allocator) + } + pub unsafe fn create_descriptor_set_layout( + &self, + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_set_layout: *const DescriptorSetLayout, + ) -> Result { + (self.create_descriptor_set_layout)(device, p_create_info, p_allocator, p_set_layout) + } + pub unsafe fn destroy_descriptor_set_layout( + &self, + device: Device, + descriptor_set_layout: DescriptorSetLayout, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_descriptor_set_layout)(device, descriptor_set_layout, p_allocator) + } + pub unsafe fn create_descriptor_pool( + &self, + device: Device, + p_create_info: *const DescriptorPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_pool: *const DescriptorPool, + ) -> Result { + (self.create_descriptor_pool)(device, p_create_info, p_allocator, p_descriptor_pool) + } + pub unsafe fn destroy_descriptor_pool( + &self, + device: Device, + descriptor_pool: DescriptorPool, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_descriptor_pool)(device, descriptor_pool, p_allocator) + } + pub unsafe fn reset_descriptor_pool( + &self, + device: Device, + descriptor_pool: DescriptorPool, + flags: DescriptorPoolResetFlags, + ) -> Result { + (self.reset_descriptor_pool)(device, descriptor_pool, flags) + } + pub unsafe fn allocate_descriptor_sets( + &self, + device: Device, + p_allocate_info: *const DescriptorSetAllocateInfo, + p_descriptor_sets: *const DescriptorSet, + ) -> Result { + (self.allocate_descriptor_sets)(device, p_allocate_info, p_descriptor_sets) + } + pub unsafe fn free_descriptor_sets( + &self, + device: Device, + descriptor_pool: DescriptorPool, + descriptor_set_count: uint32_t, + p_descriptor_sets: *const DescriptorSet, + ) -> Result { + (self.free_descriptor_sets)( + device, + descriptor_pool, + descriptor_set_count, + p_descriptor_sets, + ) + } + pub unsafe fn update_descriptor_sets( + &self, + device: Device, + descriptor_write_count: uint32_t, + p_descriptor_writes: *const WriteDescriptorSet, + descriptor_copy_count: uint32_t, + p_descriptor_copies: *const CopyDescriptorSet, + ) -> c_void { + (self.update_descriptor_sets)( + device, + descriptor_write_count, + p_descriptor_writes, + descriptor_copy_count, + p_descriptor_copies, + ) + } + pub unsafe fn create_framebuffer( + &self, + device: Device, + p_create_info: *const FramebufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_framebuffer: *const Framebuffer, + ) -> Result { + (self.create_framebuffer)(device, p_create_info, p_allocator, p_framebuffer) + } + pub unsafe fn destroy_framebuffer( + &self, + device: Device, + framebuffer: Framebuffer, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_framebuffer)(device, framebuffer, p_allocator) + } + pub unsafe fn create_render_pass( + &self, + device: Device, + p_create_info: *const RenderPassCreateInfo, + p_allocator: *const AllocationCallbacks, + p_render_pass: *const RenderPass, + ) -> Result { + (self.create_render_pass)(device, p_create_info, p_allocator, p_render_pass) + } + pub unsafe fn destroy_render_pass( + &self, + device: Device, + render_pass: RenderPass, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_render_pass)(device, render_pass, p_allocator) + } + pub unsafe fn get_render_area_granularity( + &self, + device: Device, + render_pass: RenderPass, + p_granularity: *const Extent2D, + ) -> c_void { + (self.get_render_area_granularity)(device, render_pass, p_granularity) + } + pub unsafe fn create_command_pool( + &self, + device: Device, + p_create_info: *const CommandPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_command_pool: *const CommandPool, + ) -> Result { + (self.create_command_pool)(device, p_create_info, p_allocator, p_command_pool) + } + pub unsafe fn destroy_command_pool( + &self, + device: Device, + command_pool: CommandPool, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_command_pool)(device, command_pool, p_allocator) + } + pub unsafe fn reset_command_pool( + &self, + device: Device, + command_pool: CommandPool, + flags: CommandPoolResetFlags, + ) -> Result { + (self.reset_command_pool)(device, command_pool, flags) + } + pub unsafe fn allocate_command_buffers( + &self, + device: Device, + p_allocate_info: *const CommandBufferAllocateInfo, + p_command_buffers: *const CommandBuffer, + ) -> Result { + (self.allocate_command_buffers)(device, p_allocate_info, p_command_buffers) + } + pub unsafe fn free_command_buffers( + &self, + device: Device, + command_pool: CommandPool, + command_buffer_count: uint32_t, + p_command_buffers: *const CommandBuffer, + ) -> c_void { + (self.free_command_buffers)( + device, + command_pool, + command_buffer_count, + p_command_buffers, + ) + } + pub unsafe fn begin_command_buffer( + &self, + command_buffer: CommandBuffer, + p_begin_info: *const CommandBufferBeginInfo, + ) -> Result { + (self.begin_command_buffer)(command_buffer, p_begin_info) + } + pub unsafe fn end_command_buffer(&self, command_buffer: CommandBuffer) -> Result { + (self.end_command_buffer)(command_buffer) + } + pub unsafe fn reset_command_buffer( + &self, + command_buffer: CommandBuffer, + flags: CommandBufferResetFlags, + ) -> Result { + (self.reset_command_buffer)(command_buffer, flags) + } + pub unsafe fn cmd_bind_pipeline( + &self, + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + ) -> c_void { + (self.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline) + } + pub unsafe fn cmd_set_viewport( + &self, + command_buffer: CommandBuffer, + first_viewport: uint32_t, + viewport_count: uint32_t, + p_viewports: *const Viewport, + ) -> c_void { + (self.cmd_set_viewport)(command_buffer, first_viewport, viewport_count, p_viewports) + } + pub unsafe fn cmd_set_scissor( + &self, + command_buffer: CommandBuffer, + first_scissor: uint32_t, + scissor_count: uint32_t, + p_scissors: *const Rect2D, + ) -> c_void { + (self.cmd_set_scissor)(command_buffer, first_scissor, scissor_count, p_scissors) + } + pub unsafe fn cmd_set_line_width( + &self, + command_buffer: CommandBuffer, + line_width: c_float, + ) -> c_void { + (self.cmd_set_line_width)(command_buffer, line_width) + } + pub unsafe fn cmd_set_depth_bias( + &self, + command_buffer: CommandBuffer, + depth_bias_constant_factor: c_float, + depth_bias_clamp: c_float, + depth_bias_slope_factor: c_float, + ) -> c_void { + (self.cmd_set_depth_bias)( + command_buffer, + depth_bias_constant_factor, + depth_bias_clamp, + depth_bias_slope_factor, + ) + } + pub unsafe fn cmd_set_blend_constants( + &self, + command_buffer: CommandBuffer, + blend_constants: [c_float; 4], + ) -> c_void { + (self.cmd_set_blend_constants)(command_buffer, blend_constants) + } + pub unsafe fn cmd_set_depth_bounds( + &self, + command_buffer: CommandBuffer, + min_depth_bounds: c_float, + max_depth_bounds: c_float, + ) -> c_void { + (self.cmd_set_depth_bounds)(command_buffer, min_depth_bounds, max_depth_bounds) + } + pub unsafe fn cmd_set_stencil_compare_mask( + &self, + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + compare_mask: uint32_t, + ) -> c_void { + (self.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask) + } + pub unsafe fn cmd_set_stencil_write_mask( + &self, + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + write_mask: uint32_t, + ) -> c_void { + (self.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask) + } + pub unsafe fn cmd_set_stencil_reference( + &self, + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + reference: uint32_t, + ) -> c_void { + (self.cmd_set_stencil_reference)(command_buffer, face_mask, reference) + } + pub unsafe fn cmd_bind_descriptor_sets( + &self, + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: uint32_t, + descriptor_set_count: uint32_t, + p_descriptor_sets: *const DescriptorSet, + dynamic_offset_count: uint32_t, + p_dynamic_offsets: *const uint32_t, + ) -> c_void { + (self.cmd_bind_descriptor_sets)( + command_buffer, + pipeline_bind_point, + layout, + first_set, + descriptor_set_count, + p_descriptor_sets, + dynamic_offset_count, + p_dynamic_offsets, + ) + } + pub unsafe fn cmd_bind_index_buffer( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + index_type: IndexType, + ) -> c_void { + (self.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type) + } + pub unsafe fn cmd_bind_vertex_buffers( + &self, + command_buffer: CommandBuffer, + first_binding: uint32_t, + binding_count: uint32_t, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + ) -> c_void { + (self.cmd_bind_vertex_buffers)( + command_buffer, + first_binding, + binding_count, + p_buffers, + p_offsets, + ) + } + pub unsafe fn cmd_draw( + &self, + command_buffer: CommandBuffer, + vertex_count: uint32_t, + instance_count: uint32_t, + first_vertex: uint32_t, + first_instance: uint32_t, + ) -> c_void { + (self.cmd_draw)( + command_buffer, + vertex_count, + instance_count, + first_vertex, + first_instance, + ) + } + pub unsafe fn cmd_draw_indexed( + &self, + command_buffer: CommandBuffer, + index_count: uint32_t, + instance_count: uint32_t, + first_index: uint32_t, + vertex_offset: int32_t, + first_instance: uint32_t, + ) -> c_void { + (self.cmd_draw_indexed)( + command_buffer, + index_count, + instance_count, + first_index, + vertex_offset, + first_instance, + ) + } + pub unsafe fn cmd_draw_indirect( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride) + } + pub unsafe fn cmd_draw_indexed_indirect( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indexed_indirect)(command_buffer, buffer, offset, draw_count, stride) + } + pub unsafe fn cmd_dispatch( + &self, + command_buffer: CommandBuffer, + group_count_x: uint32_t, + group_count_y: uint32_t, + group_count_z: uint32_t, + ) -> c_void { + (self.cmd_dispatch)(command_buffer, group_count_x, group_count_y, group_count_z) + } + pub unsafe fn cmd_dispatch_indirect( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + ) -> c_void { + (self.cmd_dispatch_indirect)(command_buffer, buffer, offset) + } + pub unsafe fn cmd_copy_buffer( + &self, + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_buffer: Buffer, + region_count: uint32_t, + p_regions: *const BufferCopy, + ) -> c_void { + (self.cmd_copy_buffer)( + command_buffer, + src_buffer, + dst_buffer, + region_count, + p_regions, + ) + } + pub unsafe fn cmd_copy_image( + &self, + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageCopy, + ) -> c_void { + (self.cmd_copy_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + region_count, + p_regions, + ) + } + pub unsafe fn cmd_blit_image( + &self, + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageBlit, + filter: Filter, + ) -> c_void { + (self.cmd_blit_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + region_count, + p_regions, + filter, + ) + } + pub unsafe fn cmd_copy_buffer_to_image( + &self, + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const BufferImageCopy, + ) -> c_void { + (self.cmd_copy_buffer_to_image)( + command_buffer, + src_buffer, + dst_image, + dst_image_layout, + region_count, + p_regions, + ) + } + pub unsafe fn cmd_copy_image_to_buffer( + &self, + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_buffer: Buffer, + region_count: uint32_t, + p_regions: *const BufferImageCopy, + ) -> c_void { + (self.cmd_copy_image_to_buffer)( + command_buffer, + src_image, + src_image_layout, + dst_buffer, + region_count, + p_regions, + ) + } + pub unsafe fn cmd_update_buffer( + &self, + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + data_size: DeviceSize, + p_data: *const c_void, + ) -> c_void { + (self.cmd_update_buffer)(command_buffer, dst_buffer, dst_offset, data_size, p_data) + } + pub unsafe fn cmd_fill_buffer( + &self, + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + size: DeviceSize, + data: uint32_t, + ) -> c_void { + (self.cmd_fill_buffer)(command_buffer, dst_buffer, dst_offset, size, data) + } + pub unsafe fn cmd_clear_color_image( + &self, + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_color: *const ClearColorValue, + range_count: uint32_t, + p_ranges: *const ImageSubresourceRange, + ) -> c_void { + (self.cmd_clear_color_image)( + command_buffer, + image, + image_layout, + p_color, + range_count, + p_ranges, + ) + } + pub unsafe fn cmd_clear_depth_stencil_image( + &self, + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_depth_stencil: *const ClearDepthStencilValue, + range_count: uint32_t, + p_ranges: *const ImageSubresourceRange, + ) -> c_void { + (self.cmd_clear_depth_stencil_image)( + command_buffer, + image, + image_layout, + p_depth_stencil, + range_count, + p_ranges, + ) + } + pub unsafe fn cmd_clear_attachments( + &self, + command_buffer: CommandBuffer, + attachment_count: uint32_t, + p_attachments: *const ClearAttachment, + rect_count: uint32_t, + p_rects: *const ClearRect, + ) -> c_void { + (self.cmd_clear_attachments)( + command_buffer, + attachment_count, + p_attachments, + rect_count, + p_rects, + ) + } + pub unsafe fn cmd_resolve_image( + &self, + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: uint32_t, + p_regions: *const ImageResolve, + ) -> c_void { + (self.cmd_resolve_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + region_count, + p_regions, + ) + } + pub unsafe fn cmd_set_event( + &self, + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, + ) -> c_void { + (self.cmd_set_event)(command_buffer, event, stage_mask) + } + pub unsafe fn cmd_reset_event( + &self, + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, + ) -> c_void { + (self.cmd_reset_event)(command_buffer, event, stage_mask) + } + pub unsafe fn cmd_wait_events( + &self, + command_buffer: CommandBuffer, + event_count: uint32_t, + p_events: *const Event, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + memory_barrier_count: uint32_t, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: uint32_t, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: uint32_t, + p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> c_void { + (self.cmd_wait_events)( + command_buffer, + event_count, + p_events, + src_stage_mask, + dst_stage_mask, + memory_barrier_count, + p_memory_barriers, + buffer_memory_barrier_count, + p_buffer_memory_barriers, + image_memory_barrier_count, + p_image_memory_barriers, + ) + } + pub unsafe fn cmd_pipeline_barrier( + &self, + command_buffer: CommandBuffer, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + dependency_flags: DependencyFlags, + memory_barrier_count: uint32_t, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: uint32_t, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: uint32_t, + p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> c_void { + (self.cmd_pipeline_barrier)( + command_buffer, + src_stage_mask, + dst_stage_mask, + dependency_flags, + memory_barrier_count, + p_memory_barriers, + buffer_memory_barrier_count, + p_buffer_memory_barriers, + image_memory_barrier_count, + p_image_memory_barriers, + ) + } + pub unsafe fn cmd_begin_query( + &self, + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: uint32_t, + flags: QueryControlFlags, + ) -> c_void { + (self.cmd_begin_query)(command_buffer, query_pool, query, flags) + } + pub unsafe fn cmd_end_query( + &self, + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: uint32_t, + ) -> c_void { + (self.cmd_end_query)(command_buffer, query_pool, query) + } + pub unsafe fn cmd_reset_query_pool( + &self, + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + ) -> c_void { + (self.cmd_reset_query_pool)(command_buffer, query_pool, first_query, query_count) + } + pub unsafe fn cmd_write_timestamp( + &self, + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + query_pool: QueryPool, + query: uint32_t, + ) -> c_void { + (self.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query) + } + pub unsafe fn cmd_copy_query_pool_results( + &self, + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: uint32_t, + query_count: uint32_t, + dst_buffer: Buffer, + dst_offset: DeviceSize, + stride: DeviceSize, + flags: QueryResultFlags, + ) -> c_void { + (self.cmd_copy_query_pool_results)( + command_buffer, + query_pool, + first_query, + query_count, + dst_buffer, + dst_offset, + stride, + flags, + ) + } + pub unsafe fn cmd_push_constants( + &self, + command_buffer: CommandBuffer, + layout: PipelineLayout, + stage_flags: ShaderStageFlags, + offset: uint32_t, + size: uint32_t, + p_values: *const c_void, + ) -> c_void { + (self.cmd_push_constants)(command_buffer, layout, stage_flags, offset, size, p_values) + } + pub unsafe fn cmd_begin_render_pass( + &self, + command_buffer: CommandBuffer, + p_render_pass_begin: *const RenderPassBeginInfo, + contents: SubpassContents, + ) -> c_void { + (self.cmd_begin_render_pass)(command_buffer, p_render_pass_begin, contents) + } + pub unsafe fn cmd_next_subpass( + &self, + command_buffer: CommandBuffer, + contents: SubpassContents, + ) -> c_void { + (self.cmd_next_subpass)(command_buffer, contents) + } + pub unsafe fn cmd_end_render_pass(&self, command_buffer: CommandBuffer) -> c_void { + (self.cmd_end_render_pass)(command_buffer) + } + pub unsafe fn cmd_execute_commands( + &self, + command_buffer: CommandBuffer, + command_buffer_count: uint32_t, + p_command_buffers: *const CommandBuffer, + ) -> c_void { + (self.cmd_execute_commands)(command_buffer, command_buffer_count, p_command_buffers) + } +} +pub struct EntryFnV1_1 {} +unsafe impl Send for EntryFnV1_1 {} +unsafe impl Sync for EntryFnV1_1 {} +impl ::std::clone::Clone for EntryFnV1_1 { + fn clone(&self) -> Self { + EntryFnV1_1 {} + } +} +impl EntryFnV1_1 { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = EntryFnV1_1 {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct InstanceFnV1_1 { enumerate_instance_version : extern "system" fn ( p_api_version : *const uint32_t , ) -> Result , enumerate_physical_device_groups : extern "system" fn ( instance : Instance , p_physical_device_group_count : *const uint32_t , p_physical_device_group_properties : *const PhysicalDeviceGroupProperties , ) -> Result , get_physical_device_features2 : extern "system" fn ( physical_device : PhysicalDevice , p_features : *const PhysicalDeviceFeatures2 , ) -> c_void , get_physical_device_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_properties : *const PhysicalDeviceProperties2 , ) -> c_void , get_physical_device_format_properties2 : extern "system" fn ( physical_device : PhysicalDevice , format : Format , p_format_properties : *const FormatProperties2 , ) -> c_void , get_physical_device_image_format_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_image_format_info : *const PhysicalDeviceImageFormatInfo2 , p_image_format_properties : *const ImageFormatProperties2 , ) -> Result , get_physical_device_queue_family_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_queue_family_property_count : *const uint32_t , p_queue_family_properties : *const QueueFamilyProperties2 , ) -> c_void , get_physical_device_memory_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_memory_properties : *const PhysicalDeviceMemoryProperties2 , ) -> c_void , get_physical_device_sparse_image_format_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_format_info : *const PhysicalDeviceSparseImageFormatInfo2 , p_property_count : *const uint32_t , p_properties : *const SparseImageFormatProperties2 , ) -> c_void , get_physical_device_external_buffer_properties : extern "system" fn ( physical_device : PhysicalDevice , p_external_buffer_info : *const PhysicalDeviceExternalBufferInfo , p_external_buffer_properties : *const ExternalBufferProperties , ) -> c_void , get_physical_device_external_fence_properties : extern "system" fn ( physical_device : PhysicalDevice , p_external_fence_info : *const PhysicalDeviceExternalFenceInfo , p_external_fence_properties : *const ExternalFenceProperties , ) -> c_void , get_physical_device_external_semaphore_properties : extern "system" fn ( physical_device : PhysicalDevice , p_external_semaphore_info : *const PhysicalDeviceExternalSemaphoreInfo , p_external_semaphore_properties : *const ExternalSemaphoreProperties , ) -> c_void , } +unsafe impl Send for InstanceFnV1_1 {} +unsafe impl Sync for InstanceFnV1_1 {} +impl ::std::clone::Clone for InstanceFnV1_1 { + fn clone(&self) -> Self { + InstanceFnV1_1 { + enumerate_instance_version: self.enumerate_instance_version, + enumerate_physical_device_groups: self.enumerate_physical_device_groups, + get_physical_device_features2: self.get_physical_device_features2, + get_physical_device_properties2: self.get_physical_device_properties2, + get_physical_device_format_properties2: self.get_physical_device_format_properties2, + get_physical_device_image_format_properties2: self + .get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: self + .get_physical_device_queue_family_properties2, + get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, + get_physical_device_sparse_image_format_properties2: self + .get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: self + .get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: self + .get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: self + .get_physical_device_external_semaphore_properties, + } + } +} +impl InstanceFnV1_1 { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = InstanceFnV1_1 { + enumerate_instance_version: unsafe { + let raw_name = stringify!(vkEnumerateInstanceVersion); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + enumerate_physical_device_groups: unsafe { + let raw_name = stringify!(vkEnumeratePhysicalDeviceGroups); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_features2: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceFeatures2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_properties2: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceProperties2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_format_properties2: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_image_format_properties2: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_queue_family_properties2: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_memory_properties2: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_sparse_image_format_properties2: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_external_buffer_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceExternalBufferProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_external_fence_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceExternalFenceProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_external_semaphore_properties: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceExternalSemaphoreProperties); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn enumerate_instance_version(&self, p_api_version: *const uint32_t) -> Result { + (self.enumerate_instance_version)(p_api_version) + } + pub unsafe fn enumerate_physical_device_groups( + &self, + instance: Instance, + p_physical_device_group_count: *const uint32_t, + p_physical_device_group_properties: *const PhysicalDeviceGroupProperties, + ) -> Result { + (self.enumerate_physical_device_groups)( + instance, + p_physical_device_group_count, + p_physical_device_group_properties, + ) + } + pub unsafe fn get_physical_device_features2( + &self, + physical_device: PhysicalDevice, + p_features: *const PhysicalDeviceFeatures2, + ) -> c_void { + (self.get_physical_device_features2)(physical_device, p_features) + } + pub unsafe fn get_physical_device_properties2( + &self, + physical_device: PhysicalDevice, + p_properties: *const PhysicalDeviceProperties2, + ) -> c_void { + (self.get_physical_device_properties2)(physical_device, p_properties) + } + pub unsafe fn get_physical_device_format_properties2( + &self, + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *const FormatProperties2, + ) -> c_void { + (self.get_physical_device_format_properties2)(physical_device, format, p_format_properties) + } + pub unsafe fn get_physical_device_image_format_properties2( + &self, + physical_device: PhysicalDevice, + p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + p_image_format_properties: *const ImageFormatProperties2, + ) -> Result { + (self.get_physical_device_image_format_properties2)( + physical_device, + p_image_format_info, + p_image_format_properties, + ) + } + pub unsafe fn get_physical_device_queue_family_properties2( + &self, + physical_device: PhysicalDevice, + p_queue_family_property_count: *const uint32_t, + p_queue_family_properties: *const QueueFamilyProperties2, + ) -> c_void { + (self.get_physical_device_queue_family_properties2)( + physical_device, + p_queue_family_property_count, + p_queue_family_properties, + ) + } + pub unsafe fn get_physical_device_memory_properties2( + &self, + physical_device: PhysicalDevice, + p_memory_properties: *const PhysicalDeviceMemoryProperties2, + ) -> c_void { + (self.get_physical_device_memory_properties2)(physical_device, p_memory_properties) + } + pub unsafe fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: PhysicalDevice, + p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + p_property_count: *const uint32_t, + p_properties: *const SparseImageFormatProperties2, + ) -> c_void { + (self.get_physical_device_sparse_image_format_properties2)( + physical_device, + p_format_info, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_physical_device_external_buffer_properties( + &self, + physical_device: PhysicalDevice, + p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + p_external_buffer_properties: *const ExternalBufferProperties, + ) -> c_void { + (self.get_physical_device_external_buffer_properties)( + physical_device, + p_external_buffer_info, + p_external_buffer_properties, + ) + } + pub unsafe fn get_physical_device_external_fence_properties( + &self, + physical_device: PhysicalDevice, + p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + p_external_fence_properties: *const ExternalFenceProperties, + ) -> c_void { + (self.get_physical_device_external_fence_properties)( + physical_device, + p_external_fence_info, + p_external_fence_properties, + ) + } + pub unsafe fn get_physical_device_external_semaphore_properties( + &self, + physical_device: PhysicalDevice, + p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + p_external_semaphore_properties: *const ExternalSemaphoreProperties, + ) -> c_void { + (self.get_physical_device_external_semaphore_properties)( + physical_device, + p_external_semaphore_info, + p_external_semaphore_properties, + ) + } +} +pub struct DeviceFnV1_1 { + bind_buffer_memory2: extern "system" fn( + device: Device, + bind_info_count: uint32_t, + p_bind_infos: *const BindBufferMemoryInfo, + ) -> Result, + bind_image_memory2: extern "system" fn( + device: Device, + bind_info_count: uint32_t, + p_bind_infos: *const BindImageMemoryInfo, + ) -> Result, + get_device_group_peer_memory_features: + extern "system" fn( + device: Device, + heap_index: uint32_t, + local_device_index: uint32_t, + remote_device_index: uint32_t, + p_peer_memory_features: *const PeerMemoryFeatureFlags, + ) -> c_void, + cmd_set_device_mask: + extern "system" fn(command_buffer: CommandBuffer, device_mask: uint32_t) -> c_void, + cmd_dispatch_base: extern "system" fn( + command_buffer: CommandBuffer, + base_group_x: uint32_t, + base_group_y: uint32_t, + base_group_z: uint32_t, + group_count_x: uint32_t, + group_count_y: uint32_t, + group_count_z: uint32_t, + ) -> c_void, + get_image_memory_requirements2: + extern "system" fn( + device: Device, + p_info: *const ImageMemoryRequirementsInfo2, + p_memory_requirements: *const MemoryRequirements2, + ) -> c_void, + get_buffer_memory_requirements2: + extern "system" fn( + device: Device, + p_info: *const BufferMemoryRequirementsInfo2, + p_memory_requirements: *const MemoryRequirements2, + ) -> c_void, + get_image_sparse_memory_requirements2: + extern "system" fn( + device: Device, + p_info: *const ImageSparseMemoryRequirementsInfo2, + p_sparse_memory_requirement_count: *const uint32_t, + p_sparse_memory_requirements: *const SparseImageMemoryRequirements2, + ) -> c_void, + trim_command_pool: + extern "system" fn(device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags) + -> c_void, + get_device_queue2: extern "system" fn( + device: Device, + p_queue_info: *const DeviceQueueInfo2, + p_queue: *const Queue, + ) -> c_void, + create_sampler_ycbcr_conversion: + extern "system" fn( + device: Device, + p_create_info: *const SamplerYcbcrConversionCreateInfo, p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkGetPhysicalDeviceSurfaceSupportKHR", get_physical_device_surface_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - surface: SurfaceKHR, - p_supported: *mut Bool32, - ) -> Result; - - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", get_physical_device_surface_capabilities_khr( + p_ycbcr_conversion: *const SamplerYcbcrConversion, + ) -> Result, + destroy_sampler_ycbcr_conversion: extern "system" fn( + device: Device, + ycbcr_conversion: SamplerYcbcrConversion, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_descriptor_update_template: + extern "system" fn( + device: Device, + p_create_info: *const DescriptorUpdateTemplateCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_update_template: *const DescriptorUpdateTemplate, + ) -> Result, + destroy_descriptor_update_template: + extern "system" fn( + device: Device, + descriptor_update_template: DescriptorUpdateTemplate, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + update_descriptor_set_with_template: + extern "system" fn( + device: Device, + descriptor_set: DescriptorSet, + descriptor_update_template: DescriptorUpdateTemplate, + p_data: *const c_void, + ) -> c_void, + get_descriptor_set_layout_support: + extern "system" fn( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_support: *const DescriptorSetLayoutSupport, + ) -> c_void, +} +unsafe impl Send for DeviceFnV1_1 {} +unsafe impl Sync for DeviceFnV1_1 {} +impl ::std::clone::Clone for DeviceFnV1_1 { + fn clone(&self) -> Self { + DeviceFnV1_1 { + bind_buffer_memory2: self.bind_buffer_memory2, + bind_image_memory2: self.bind_image_memory2, + get_device_group_peer_memory_features: self.get_device_group_peer_memory_features, + cmd_set_device_mask: self.cmd_set_device_mask, + cmd_dispatch_base: self.cmd_dispatch_base, + get_image_memory_requirements2: self.get_image_memory_requirements2, + get_buffer_memory_requirements2: self.get_buffer_memory_requirements2, + get_image_sparse_memory_requirements2: self.get_image_sparse_memory_requirements2, + trim_command_pool: self.trim_command_pool, + get_device_queue2: self.get_device_queue2, + create_sampler_ycbcr_conversion: self.create_sampler_ycbcr_conversion, + destroy_sampler_ycbcr_conversion: self.destroy_sampler_ycbcr_conversion, + create_descriptor_update_template: self.create_descriptor_update_template, + destroy_descriptor_update_template: self.destroy_descriptor_update_template, + update_descriptor_set_with_template: self.update_descriptor_set_with_template, + get_descriptor_set_layout_support: self.get_descriptor_set_layout_support, + } + } +} +impl DeviceFnV1_1 { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = DeviceFnV1_1 { + bind_buffer_memory2: unsafe { + let raw_name = stringify!(vkBindBufferMemory2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + bind_image_memory2: unsafe { + let raw_name = stringify!(vkBindImageMemory2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_peer_memory_features: unsafe { + let raw_name = stringify!(vkGetDeviceGroupPeerMemoryFeatures); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_set_device_mask: unsafe { + let raw_name = stringify!(vkCmdSetDeviceMask); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_dispatch_base: unsafe { + let raw_name = stringify!(vkCmdDispatchBase); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_image_memory_requirements2: unsafe { + let raw_name = stringify!(vkGetImageMemoryRequirements2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_buffer_memory_requirements2: unsafe { + let raw_name = stringify!(vkGetBufferMemoryRequirements2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_image_sparse_memory_requirements2: unsafe { + let raw_name = stringify!(vkGetImageSparseMemoryRequirements2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + trim_command_pool: unsafe { + let raw_name = stringify!(vkTrimCommandPool); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_queue2: unsafe { + let raw_name = stringify!(vkGetDeviceQueue2); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_sampler_ycbcr_conversion: unsafe { + let raw_name = stringify!(vkCreateSamplerYcbcrConversion); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_sampler_ycbcr_conversion: unsafe { + let raw_name = stringify!(vkDestroySamplerYcbcrConversion); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_descriptor_update_template: unsafe { + let raw_name = stringify!(vkCreateDescriptorUpdateTemplate); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_descriptor_update_template: unsafe { + let raw_name = stringify!(vkDestroyDescriptorUpdateTemplate); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + update_descriptor_set_with_template: unsafe { + let raw_name = stringify!(vkUpdateDescriptorSetWithTemplate); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_descriptor_set_layout_support: unsafe { + let raw_name = stringify!(vkGetDescriptorSetLayoutSupport); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn bind_buffer_memory2( + &self, + device: Device, + bind_info_count: uint32_t, + p_bind_infos: *const BindBufferMemoryInfo, + ) -> Result { + (self.bind_buffer_memory2)(device, bind_info_count, p_bind_infos) + } + pub unsafe fn bind_image_memory2( + &self, + device: Device, + bind_info_count: uint32_t, + p_bind_infos: *const BindImageMemoryInfo, + ) -> Result { + (self.bind_image_memory2)(device, bind_info_count, p_bind_infos) + } + pub unsafe fn get_device_group_peer_memory_features( + &self, + device: Device, + heap_index: uint32_t, + local_device_index: uint32_t, + remote_device_index: uint32_t, + p_peer_memory_features: *const PeerMemoryFeatureFlags, + ) -> c_void { + (self.get_device_group_peer_memory_features)( + device, + heap_index, + local_device_index, + remote_device_index, + p_peer_memory_features, + ) + } + pub unsafe fn cmd_set_device_mask( + &self, + command_buffer: CommandBuffer, + device_mask: uint32_t, + ) -> c_void { + (self.cmd_set_device_mask)(command_buffer, device_mask) + } + pub unsafe fn cmd_dispatch_base( + &self, + command_buffer: CommandBuffer, + base_group_x: uint32_t, + base_group_y: uint32_t, + base_group_z: uint32_t, + group_count_x: uint32_t, + group_count_y: uint32_t, + group_count_z: uint32_t, + ) -> c_void { + (self.cmd_dispatch_base)( + command_buffer, + base_group_x, + base_group_y, + base_group_z, + group_count_x, + group_count_y, + group_count_z, + ) + } + pub unsafe fn get_image_memory_requirements2( + &self, + device: Device, + p_info: *const ImageMemoryRequirementsInfo2, + p_memory_requirements: *const MemoryRequirements2, + ) -> c_void { + (self.get_image_memory_requirements2)(device, p_info, p_memory_requirements) + } + pub unsafe fn get_buffer_memory_requirements2( + &self, + device: Device, + p_info: *const BufferMemoryRequirementsInfo2, + p_memory_requirements: *const MemoryRequirements2, + ) -> c_void { + (self.get_buffer_memory_requirements2)(device, p_info, p_memory_requirements) + } + pub unsafe fn get_image_sparse_memory_requirements2( + &self, + device: Device, + p_info: *const ImageSparseMemoryRequirementsInfo2, + p_sparse_memory_requirement_count: *const uint32_t, + p_sparse_memory_requirements: *const SparseImageMemoryRequirements2, + ) -> c_void { + (self.get_image_sparse_memory_requirements2)( + device, + p_info, + p_sparse_memory_requirement_count, + p_sparse_memory_requirements, + ) + } + pub unsafe fn trim_command_pool( + &self, + device: Device, + command_pool: CommandPool, + flags: CommandPoolTrimFlags, + ) -> c_void { + (self.trim_command_pool)(device, command_pool, flags) + } + pub unsafe fn get_device_queue2( + &self, + device: Device, + p_queue_info: *const DeviceQueueInfo2, + p_queue: *const Queue, + ) -> c_void { + (self.get_device_queue2)(device, p_queue_info, p_queue) + } + pub unsafe fn create_sampler_ycbcr_conversion( + &self, + device: Device, + p_create_info: *const SamplerYcbcrConversionCreateInfo, + p_allocator: *const AllocationCallbacks, + p_ycbcr_conversion: *const SamplerYcbcrConversion, + ) -> Result { + (self.create_sampler_ycbcr_conversion)( + device, + p_create_info, + p_allocator, + p_ycbcr_conversion, + ) + } + pub unsafe fn destroy_sampler_ycbcr_conversion( + &self, + device: Device, + ycbcr_conversion: SamplerYcbcrConversion, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_sampler_ycbcr_conversion)(device, ycbcr_conversion, p_allocator) + } + pub unsafe fn create_descriptor_update_template( + &self, + device: Device, + p_create_info: *const DescriptorUpdateTemplateCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_update_template: *const DescriptorUpdateTemplate, + ) -> Result { + (self.create_descriptor_update_template)( + device, + p_create_info, + p_allocator, + p_descriptor_update_template, + ) + } + pub unsafe fn destroy_descriptor_update_template( + &self, + device: Device, + descriptor_update_template: DescriptorUpdateTemplate, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_descriptor_update_template)(device, descriptor_update_template, p_allocator) + } + pub unsafe fn update_descriptor_set_with_template( + &self, + device: Device, + descriptor_set: DescriptorSet, + descriptor_update_template: DescriptorUpdateTemplate, + p_data: *const c_void, + ) -> c_void { + (self.update_descriptor_set_with_template)( + device, + descriptor_set, + descriptor_update_template, + p_data, + ) + } + pub unsafe fn get_descriptor_set_layout_support( + &self, + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_support: *const DescriptorSetLayoutSupport, + ) -> c_void { + (self.get_descriptor_set_layout_support)(device, p_create_info, p_support) + } +} +pub type SampleMask = uint32_t; +pub type Bool32 = uint32_t; +pub type Flags = uint32_t; +pub type DeviceSize = uint64_t; +vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags); +vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags); +vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags); +vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(MirSurfaceCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags); +vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags); +vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags); +vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags); +vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags); +vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags); +vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags); +vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags); +vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags); +vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags); +vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags); +vk_bitflags_wrapped!( + PipelineRasterizationConservativeStateCreateFlagsEXT, + 0b0, + Flags +); +define_handle!(Instance); +define_handle!(PhysicalDevice); +define_handle!(Device); +define_handle!(Queue); +define_handle!(CommandBuffer); +handle_nondispatchable!(DeviceMemory); +handle_nondispatchable!(CommandPool); +handle_nondispatchable!(Buffer); +handle_nondispatchable!(BufferView); +handle_nondispatchable!(Image); +handle_nondispatchable!(ImageView); +handle_nondispatchable!(ShaderModule); +handle_nondispatchable!(Pipeline); +handle_nondispatchable!(PipelineLayout); +handle_nondispatchable!(Sampler); +handle_nondispatchable!(DescriptorSet); +handle_nondispatchable!(DescriptorSetLayout); +handle_nondispatchable!(DescriptorPool); +handle_nondispatchable!(Fence); +handle_nondispatchable!(Semaphore); +handle_nondispatchable!(Event); +handle_nondispatchable!(QueryPool); +handle_nondispatchable!(Framebuffer); +handle_nondispatchable!(RenderPass); +handle_nondispatchable!(PipelineCache); +handle_nondispatchable!(ObjectTableNVX); +handle_nondispatchable!(IndirectCommandsLayoutNVX); +handle_nondispatchable!(DescriptorUpdateTemplate); +handle_nondispatchable!(SamplerYcbcrConversion); +handle_nondispatchable!(ValidationCacheEXT); +handle_nondispatchable!(DisplayKHR); +handle_nondispatchable!(DisplayModeKHR); +handle_nondispatchable!(SurfaceKHR); +handle_nondispatchable!(SwapchainKHR); +handle_nondispatchable!(DebugReportCallbackEXT); +handle_nondispatchable!(DebugUtilsMessengerEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkInternalAllocationNotification = unsafe extern "system" fn() -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn() -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkReallocationFunction = unsafe extern "system" fn() -> *const c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkAllocationFunction = unsafe extern "system" fn() -> *const c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkFreeFunction = unsafe extern "system" fn() -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkVoidFunction = unsafe extern "system" fn() -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkDebugReportCallbackEXT = unsafe extern "system" fn() -> Bool32; +#[allow(non_camel_case_types)] +pub type PFN_vkDebugUtilsMessengerCallbackEXT = unsafe extern "system" fn() -> Bool32; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BaseOutStructure { + pub s_type: StructureType, + pub p_next: *const BaseOutStructure, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BaseInStructure { + pub s_type: StructureType, + pub p_next: *const BaseInStructure, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Offset2D { + pub x: int32_t, + pub y: int32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Offset3D { + pub x: int32_t, + pub y: int32_t, + pub z: int32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Extent2D { + pub width: uint32_t, + pub height: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Extent3D { + pub width: uint32_t, + pub height: uint32_t, + pub depth: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Viewport { + pub x: c_float, + pub y: c_float, + pub width: c_float, + pub height: c_float, + pub min_depth: c_float, + pub max_depth: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Rect2D { + pub offset: Offset2D, + pub extent: Extent2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ClearRect { + pub rect: Rect2D, + pub base_array_layer: uint32_t, + pub layer_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ComponentMapping { + pub r: ComponentSwizzle, + pub g: ComponentSwizzle, + pub b: ComponentSwizzle, + pub a: ComponentSwizzle, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceProperties { + pub api_version: uint32_t, + pub driver_version: uint32_t, + pub vendor_id: uint32_t, + pub device_id: uint32_t, + pub device_type: PhysicalDeviceType, + pub device_name: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE], + pub pipeline_cache_uuid: [uint8_t; VK_UUID_SIZE], + pub limits: PhysicalDeviceLimits, + pub sparse_properties: PhysicalDeviceSparseProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExtensionProperties { + pub extension_name: [c_char; VK_MAX_EXTENSION_NAME_SIZE], + pub spec_version: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct LayerProperties { + pub layer_name: [c_char; VK_MAX_EXTENSION_NAME_SIZE], + pub spec_version: uint32_t, + pub implementation_version: uint32_t, + pub description: [c_char; VK_MAX_DESCRIPTION_SIZE], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ApplicationInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_application_name: *const c_char, + pub application_version: uint32_t, + pub p_engine_name: *const c_char, + pub engine_version: uint32_t, + pub api_version: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AllocationCallbacks { + pub p_user_data: *const c_void, + pub pfn_allocation: PFN_vkAllocationFunction, + pub pfn_reallocation: PFN_vkReallocationFunction, + pub pfn_free: PFN_vkFreeFunction, + pub pfn_internal_allocation: PFN_vkInternalAllocationNotification, + pub pfn_internal_free: PFN_vkInternalFreeNotification, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceQueueCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceQueueCreateFlags, + pub queue_family_index: uint32_t, + pub queue_count: uint32_t, + pub p_queue_priorities: *const c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceCreateFlags, + pub queue_create_info_count: uint32_t, + pub p_queue_create_infos: *const DeviceQueueCreateInfo, + pub enabled_layer_count: uint32_t, + pub pp_enabled_layer_names: *const c_char, + pub enabled_extension_count: uint32_t, + pub pp_enabled_extension_names: *const c_char, + pub p_enabled_features: *const PhysicalDeviceFeatures, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct InstanceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: InstanceCreateFlags, + pub p_application_info: *const ApplicationInfo, + pub enabled_layer_count: uint32_t, + pub pp_enabled_layer_names: *const c_char, + pub enabled_extension_count: uint32_t, + pub pp_enabled_extension_names: *const c_char, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct QueueFamilyProperties { + pub queue_flags: QueueFlags, + pub queue_count: uint32_t, + pub timestamp_valid_bits: uint32_t, + pub min_image_transfer_granularity: Extent3D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMemoryProperties { + pub memory_type_count: uint32_t, + pub memory_types: [MemoryType; VK_MAX_MEMORY_TYPES], + pub memory_heap_count: uint32_t, + pub memory_heaps: [MemoryHeap; VK_MAX_MEMORY_HEAPS], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub allocation_size: DeviceSize, + pub memory_type_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryRequirements { + pub size: DeviceSize, + pub alignment: DeviceSize, + pub memory_type_bits: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageFormatProperties { + pub aspect_mask: ImageAspectFlags, + pub image_granularity: Extent3D, + pub flags: SparseImageFormatFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageMemoryRequirements { + pub format_properties: SparseImageFormatProperties, + pub image_mip_tail_first_lod: uint32_t, + pub image_mip_tail_size: DeviceSize, + pub image_mip_tail_offset: DeviceSize, + pub image_mip_tail_stride: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryType { + pub property_flags: MemoryPropertyFlags, + pub heap_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryHeap { + pub size: DeviceSize, + pub flags: MemoryHeapFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MappedMemoryRange { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub offset: DeviceSize, + pub size: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FormatProperties { + pub linear_tiling_features: FormatFeatureFlags, + pub optimal_tiling_features: FormatFeatureFlags, + pub buffer_features: FormatFeatureFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageFormatProperties { + pub max_extent: Extent3D, + pub max_mip_levels: uint32_t, + pub max_array_layers: uint32_t, + pub sample_counts: SampleCountFlags, + pub max_resource_size: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorBufferInfo { + pub buffer: Buffer, + pub offset: DeviceSize, + pub range: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorImageInfo { + pub sampler: Sampler, + pub image_view: ImageView, + pub image_layout: ImageLayout, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct WriteDescriptorSet { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dst_set: DescriptorSet, + pub dst_binding: uint32_t, + pub dst_array_element: uint32_t, + pub descriptor_count: uint32_t, + pub descriptor_type: DescriptorType, + pub p_image_info: *const DescriptorImageInfo, + pub p_buffer_info: *const DescriptorBufferInfo, + pub p_texel_buffer_view: *const BufferView, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CopyDescriptorSet { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_set: DescriptorSet, + pub src_binding: uint32_t, + pub src_array_element: uint32_t, + pub dst_set: DescriptorSet, + pub dst_binding: uint32_t, + pub dst_array_element: uint32_t, + pub descriptor_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferCreateFlags, + pub size: DeviceSize, + pub usage: BufferUsageFlags, + pub sharing_mode: SharingMode, + pub queue_family_index_count: uint32_t, + pub p_queue_family_indices: *const uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BufferViewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferViewCreateFlags, + pub buffer: Buffer, + pub format: Format, + pub offset: DeviceSize, + pub range: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageSubresource { + pub aspect_mask: ImageAspectFlags, + pub mip_level: uint32_t, + pub array_layer: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageSubresourceLayers { + pub aspect_mask: ImageAspectFlags, + pub mip_level: uint32_t, + pub base_array_layer: uint32_t, + pub layer_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageSubresourceRange { + pub aspect_mask: ImageAspectFlags, + pub base_mip_level: uint32_t, + pub level_count: uint32_t, + pub base_array_layer: uint32_t, + pub layer_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BufferMemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub src_queue_family_index: uint32_t, + pub dst_queue_family_index: uint32_t, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageMemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub old_layout: ImageLayout, + pub new_layout: ImageLayout, + pub src_queue_family_index: uint32_t, + pub dst_queue_family_index: uint32_t, + pub image: Image, + pub subresource_range: ImageSubresourceRange, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCreateFlags, + pub image_type: ImageType, + pub format: Format, + pub extent: Extent3D, + pub mip_levels: uint32_t, + pub array_layers: uint32_t, + pub samples: SampleCountFlags, + pub tiling: ImageTiling, + pub usage: ImageUsageFlags, + pub sharing_mode: SharingMode, + pub queue_family_index_count: uint32_t, + pub p_queue_family_indices: *const uint32_t, + pub initial_layout: ImageLayout, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SubresourceLayout { + pub offset: DeviceSize, + pub size: DeviceSize, + pub row_pitch: DeviceSize, + pub array_pitch: DeviceSize, + pub depth_pitch: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageViewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageViewCreateFlags, + pub image: Image, + pub view_type: ImageViewType, + pub format: Format, + pub components: ComponentMapping, + pub subresource_range: ImageSubresourceRange, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BufferCopy { + pub src_offset: DeviceSize, + pub dst_offset: DeviceSize, + pub size: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseMemoryBind { + pub resource_offset: DeviceSize, + pub size: DeviceSize, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub flags: SparseMemoryBindFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageMemoryBind { + pub subresource: ImageSubresource, + pub offset: Offset3D, + pub extent: Extent3D, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub flags: SparseMemoryBindFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseBufferMemoryBindInfo { + pub buffer: Buffer, + pub bind_count: uint32_t, + pub p_binds: *const SparseMemoryBind, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageOpaqueMemoryBindInfo { + pub image: Image, + pub bind_count: uint32_t, + pub p_binds: *const SparseMemoryBind, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageMemoryBindInfo { + pub image: Image, + pub bind_count: uint32_t, + pub p_binds: *const SparseImageMemoryBind, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindSparseInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: uint32_t, + pub p_wait_semaphores: *const Semaphore, + pub buffer_bind_count: uint32_t, + pub p_buffer_binds: *const SparseBufferMemoryBindInfo, + pub image_opaque_bind_count: uint32_t, + pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo, + pub image_bind_count: uint32_t, + pub p_image_binds: *const SparseImageMemoryBindInfo, + pub signal_semaphore_count: uint32_t, + pub p_signal_semaphores: *const Semaphore, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageCopy { + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageBlit { + pub src_subresource: ImageSubresourceLayers, + pub src_offsets: [Offset3D; 2], + pub dst_subresource: ImageSubresourceLayers, + pub dst_offsets: [Offset3D; 2], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BufferImageCopy { + pub buffer_offset: DeviceSize, + pub buffer_row_length: uint32_t, + pub buffer_image_height: uint32_t, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageResolve { + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ShaderModuleCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ShaderModuleCreateFlags, + pub code_size: size_t, + pub p_code: *const uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetLayoutBinding { + pub binding: uint32_t, + pub descriptor_type: DescriptorType, + pub descriptor_count: uint32_t, + pub stage_flags: ShaderStageFlags, + pub p_immutable_samplers: *const Sampler, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetLayoutCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorSetLayoutCreateFlags, + pub binding_count: uint32_t, + pub p_bindings: *const DescriptorSetLayoutBinding, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorPoolSize { + pub ty: DescriptorType, + pub descriptor_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorPoolCreateFlags, + pub max_sets: uint32_t, + pub pool_size_count: uint32_t, + pub p_pool_sizes: *const DescriptorPoolSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_pool: DescriptorPool, + pub descriptor_set_count: uint32_t, + pub p_set_layouts: *const DescriptorSetLayout, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SpecializationMapEntry { + pub constant_id: uint32_t, + pub offset: uint32_t, + pub size: size_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SpecializationInfo { + pub map_entry_count: uint32_t, + pub p_map_entries: *const SpecializationMapEntry, + pub data_size: size_t, + pub p_data: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineShaderStageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineShaderStageCreateFlags, + pub stage: ShaderStageFlags, + pub module: ShaderModule, + pub p_name: *const c_char, + pub p_specialization_info: *const SpecializationInfo, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ComputePipelineCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage: PipelineShaderStageCreateInfo, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: int32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct VertexInputBindingDescription { + pub binding: uint32_t, + pub stride: uint32_t, + pub input_rate: VertexInputRate, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct VertexInputAttributeDescription { + pub location: uint32_t, + pub binding: uint32_t, + pub format: Format, + pub offset: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineVertexInputStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineVertexInputStateCreateFlags, + pub vertex_binding_description_count: uint32_t, + pub p_vertex_binding_descriptions: *const VertexInputBindingDescription, + pub vertex_attribute_description_count: uint32_t, + pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineInputAssemblyStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineInputAssemblyStateCreateFlags, + pub topology: PrimitiveTopology, + pub primitive_restart_enable: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineTessellationStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineTessellationStateCreateFlags, + pub patch_control_points: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineViewportStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineViewportStateCreateFlags, + pub viewport_count: uint32_t, + pub p_viewports: *const Viewport, + pub scissor_count: uint32_t, + pub p_scissors: *const Rect2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineRasterizationStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationStateCreateFlags, + pub depth_clamp_enable: Bool32, + pub rasterizer_discard_enable: Bool32, + pub polygon_mode: PolygonMode, + pub cull_mode: CullModeFlags, + pub front_face: FrontFace, + pub depth_bias_enable: Bool32, + pub depth_bias_constant_factor: c_float, + pub depth_bias_clamp: c_float, + pub depth_bias_slope_factor: c_float, + pub line_width: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineMultisampleStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineMultisampleStateCreateFlags, + pub rasterization_samples: SampleCountFlags, + pub sample_shading_enable: Bool32, + pub min_sample_shading: c_float, + pub p_sample_mask: *const SampleMask, + pub alpha_to_coverage_enable: Bool32, + pub alpha_to_one_enable: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineColorBlendAttachmentState { + pub blend_enable: Bool32, + pub src_color_blend_factor: BlendFactor, + pub dst_color_blend_factor: BlendFactor, + pub color_blend_op: BlendOp, + pub src_alpha_blend_factor: BlendFactor, + pub dst_alpha_blend_factor: BlendFactor, + pub alpha_blend_op: BlendOp, + pub color_write_mask: ColorComponentFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineColorBlendStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineColorBlendStateCreateFlags, + pub logic_op_enable: Bool32, + pub logic_op: LogicOp, + pub attachment_count: uint32_t, + pub p_attachments: *const PipelineColorBlendAttachmentState, + pub blend_constants: [c_float; 4], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineDynamicStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDynamicStateCreateFlags, + pub dynamic_state_count: uint32_t, + pub p_dynamic_states: *const DynamicState, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct StencilOpState { + pub fail_op: StencilOp, + pub pass_op: StencilOp, + pub depth_fail_op: StencilOp, + pub compare_op: CompareOp, + pub compare_mask: uint32_t, + pub write_mask: uint32_t, + pub reference: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineDepthStencilStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDepthStencilStateCreateFlags, + pub depth_test_enable: Bool32, + pub depth_write_enable: Bool32, + pub depth_compare_op: CompareOp, + pub depth_bounds_test_enable: Bool32, + pub stencil_test_enable: Bool32, + pub front: StencilOpState, + pub back: StencilOpState, + pub min_depth_bounds: c_float, + pub max_depth_bounds: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GraphicsPipelineCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: uint32_t, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, + pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo, + pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, + pub p_viewport_state: *const PipelineViewportStateCreateInfo, + pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo, + pub p_multisample_state: *const PipelineMultisampleStateCreateInfo, + pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo, + pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, + pub layout: PipelineLayout, + pub render_pass: RenderPass, + pub subpass: uint32_t, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: int32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineCacheCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCacheCreateFlags, + pub initial_data_size: size_t, + pub p_initial_data: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PushConstantRange { + pub stage_flags: ShaderStageFlags, + pub offset: uint32_t, + pub size: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineLayoutCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineLayoutCreateFlags, + pub set_layout_count: uint32_t, + pub p_set_layouts: *const DescriptorSetLayout, + pub push_constant_range_count: uint32_t, + pub p_push_constant_ranges: *const PushConstantRange, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SamplerCreateFlags, + pub mag_filter: Filter, + pub min_filter: Filter, + pub mipmap_mode: SamplerMipmapMode, + pub address_mode_u: SamplerAddressMode, + pub address_mode_v: SamplerAddressMode, + pub address_mode_w: SamplerAddressMode, + pub mip_lod_bias: c_float, + pub anisotropy_enable: Bool32, + pub max_anisotropy: c_float, + pub compare_enable: Bool32, + pub compare_op: CompareOp, + pub min_lod: c_float, + pub max_lod: c_float, + pub border_color: BorderColor, + pub unnormalized_coordinates: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CommandPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: CommandPoolCreateFlags, + pub queue_family_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CommandBufferAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub command_pool: CommandPool, + pub level: CommandBufferLevel, + pub command_buffer_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CommandBufferInheritanceInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub render_pass: RenderPass, + pub subpass: uint32_t, + pub framebuffer: Framebuffer, + pub occlusion_query_enable: Bool32, + pub query_flags: QueryControlFlags, + pub pipeline_statistics: QueryPipelineStatisticFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CommandBufferBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: CommandBufferUsageFlags, + pub p_inheritance_info: *const CommandBufferInheritanceInfo, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RenderPassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub render_pass: RenderPass, + pub framebuffer: Framebuffer, + pub render_area: Rect2D, + pub clear_value_count: uint32_t, + pub p_clear_values: *const ClearValue, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union ClearColorValue { + pub float32: [c_float; 4], + pub int32: [int32_t; 4], + pub uint32: [uint32_t; 4], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ClearDepthStencilValue { + pub depth: c_float, + pub stencil: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union ClearValue { + pub color: ClearColorValue, + pub depth_stencil: ClearDepthStencilValue, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ClearAttachment { + pub aspect_mask: ImageAspectFlags, + pub color_attachment: uint32_t, + pub clear_value: ClearValue, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AttachmentDescription { + pub flags: AttachmentDescriptionFlags, + pub format: Format, + pub samples: SampleCountFlags, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub stencil_load_op: AttachmentLoadOp, + pub stencil_store_op: AttachmentStoreOp, + pub initial_layout: ImageLayout, + pub final_layout: ImageLayout, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AttachmentReference { + pub attachment: uint32_t, + pub layout: ImageLayout, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SubpassDescription { + pub flags: SubpassDescriptionFlags, + pub pipeline_bind_point: PipelineBindPoint, + pub input_attachment_count: uint32_t, + pub p_input_attachments: *const AttachmentReference, + pub color_attachment_count: uint32_t, + pub p_color_attachments: *const AttachmentReference, + pub p_resolve_attachments: *const AttachmentReference, + pub p_depth_stencil_attachment: *const AttachmentReference, + pub preserve_attachment_count: uint32_t, + pub p_preserve_attachments: *const uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SubpassDependency { + pub src_subpass: uint32_t, + pub dst_subpass: uint32_t, + pub src_stage_mask: PipelineStageFlags, + pub dst_stage_mask: PipelineStageFlags, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub dependency_flags: DependencyFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RenderPassCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderPassCreateFlags, + pub attachment_count: uint32_t, + pub p_attachments: *const AttachmentDescription, + pub subpass_count: uint32_t, + pub p_subpasses: *const SubpassDescription, + pub dependency_count: uint32_t, + pub p_dependencies: *const SubpassDependency, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct EventCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: EventCreateFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FenceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: FenceCreateFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceFeatures { + pub robust_buffer_access: Bool32, + pub full_draw_index_uint32: Bool32, + pub image_cube_array: Bool32, + pub independent_blend: Bool32, + pub geometry_shader: Bool32, + pub tessellation_shader: Bool32, + pub sample_rate_shading: Bool32, + pub dual_src_blend: Bool32, + pub logic_op: Bool32, + pub multi_draw_indirect: Bool32, + pub draw_indirect_first_instance: Bool32, + pub depth_clamp: Bool32, + pub depth_bias_clamp: Bool32, + pub fill_mode_non_solid: Bool32, + pub depth_bounds: Bool32, + pub wide_lines: Bool32, + pub large_points: Bool32, + pub alpha_to_one: Bool32, + pub multi_viewport: Bool32, + pub sampler_anisotropy: Bool32, + pub texture_compression_etc2: Bool32, + pub texture_compression_astc_ldr: Bool32, + pub texture_compression_bc: Bool32, + pub occlusion_query_precise: Bool32, + pub pipeline_statistics_query: Bool32, + pub vertex_pipeline_stores_and_atomics: Bool32, + pub fragment_stores_and_atomics: Bool32, + pub shader_tessellation_and_geometry_point_size: Bool32, + pub shader_image_gather_extended: Bool32, + pub shader_storage_image_extended_formats: Bool32, + pub shader_storage_image_multisample: Bool32, + pub shader_storage_image_read_without_format: Bool32, + pub shader_storage_image_write_without_format: Bool32, + pub shader_uniform_buffer_array_dynamic_indexing: Bool32, + pub shader_sampled_image_array_dynamic_indexing: Bool32, + pub shader_storage_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_image_array_dynamic_indexing: Bool32, + pub shader_clip_distance: Bool32, + pub shader_cull_distance: Bool32, + pub shader_float64: Bool32, + pub shader_int64: Bool32, + pub shader_int16: Bool32, + pub shader_resource_residency: Bool32, + pub shader_resource_min_lod: Bool32, + pub sparse_binding: Bool32, + pub sparse_residency_buffer: Bool32, + pub sparse_residency_image2_d: Bool32, + pub sparse_residency_image3_d: Bool32, + pub sparse_residency2_samples: Bool32, + pub sparse_residency4_samples: Bool32, + pub sparse_residency8_samples: Bool32, + pub sparse_residency16_samples: Bool32, + pub sparse_residency_aliased: Bool32, + pub variable_multisample_rate: Bool32, + pub inherited_queries: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSparseProperties { + pub residency_standard2_d_block_shape: Bool32, + pub residency_standard2_d_multisample_block_shape: Bool32, + pub residency_standard3_d_block_shape: Bool32, + pub residency_aligned_mip_size: Bool32, + pub residency_non_resident_strict: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceLimits { + pub max_image_dimension1_d: uint32_t, + pub max_image_dimension2_d: uint32_t, + pub max_image_dimension3_d: uint32_t, + pub max_image_dimension_cube: uint32_t, + pub max_image_array_layers: uint32_t, + pub max_texel_buffer_elements: uint32_t, + pub max_uniform_buffer_range: uint32_t, + pub max_storage_buffer_range: uint32_t, + pub max_push_constants_size: uint32_t, + pub max_memory_allocation_count: uint32_t, + pub max_sampler_allocation_count: uint32_t, + pub buffer_image_granularity: DeviceSize, + pub sparse_address_space_size: DeviceSize, + pub max_bound_descriptor_sets: uint32_t, + pub max_per_stage_descriptor_samplers: uint32_t, + pub max_per_stage_descriptor_uniform_buffers: uint32_t, + pub max_per_stage_descriptor_storage_buffers: uint32_t, + pub max_per_stage_descriptor_sampled_images: uint32_t, + pub max_per_stage_descriptor_storage_images: uint32_t, + pub max_per_stage_descriptor_input_attachments: uint32_t, + pub max_per_stage_resources: uint32_t, + pub max_descriptor_set_samplers: uint32_t, + pub max_descriptor_set_uniform_buffers: uint32_t, + pub max_descriptor_set_uniform_buffers_dynamic: uint32_t, + pub max_descriptor_set_storage_buffers: uint32_t, + pub max_descriptor_set_storage_buffers_dynamic: uint32_t, + pub max_descriptor_set_sampled_images: uint32_t, + pub max_descriptor_set_storage_images: uint32_t, + pub max_descriptor_set_input_attachments: uint32_t, + pub max_vertex_input_attributes: uint32_t, + pub max_vertex_input_bindings: uint32_t, + pub max_vertex_input_attribute_offset: uint32_t, + pub max_vertex_input_binding_stride: uint32_t, + pub max_vertex_output_components: uint32_t, + pub max_tessellation_generation_level: uint32_t, + pub max_tessellation_patch_size: uint32_t, + pub max_tessellation_control_per_vertex_input_components: uint32_t, + pub max_tessellation_control_per_vertex_output_components: uint32_t, + pub max_tessellation_control_per_patch_output_components: uint32_t, + pub max_tessellation_control_total_output_components: uint32_t, + pub max_tessellation_evaluation_input_components: uint32_t, + pub max_tessellation_evaluation_output_components: uint32_t, + pub max_geometry_shader_invocations: uint32_t, + pub max_geometry_input_components: uint32_t, + pub max_geometry_output_components: uint32_t, + pub max_geometry_output_vertices: uint32_t, + pub max_geometry_total_output_components: uint32_t, + pub max_fragment_input_components: uint32_t, + pub max_fragment_output_attachments: uint32_t, + pub max_fragment_dual_src_attachments: uint32_t, + pub max_fragment_combined_output_resources: uint32_t, + pub max_compute_shared_memory_size: uint32_t, + pub max_compute_work_group_count: [uint32_t; 3], + pub max_compute_work_group_invocations: uint32_t, + pub max_compute_work_group_size: [uint32_t; 3], + pub sub_pixel_precision_bits: uint32_t, + pub sub_texel_precision_bits: uint32_t, + pub mipmap_precision_bits: uint32_t, + pub max_draw_indexed_index_value: uint32_t, + pub max_draw_indirect_count: uint32_t, + pub max_sampler_lod_bias: c_float, + pub max_sampler_anisotropy: c_float, + pub max_viewports: uint32_t, + pub max_viewport_dimensions: [uint32_t; 2], + pub viewport_bounds_range: [c_float; 2], + pub viewport_sub_pixel_bits: uint32_t, + pub min_memory_map_alignment: size_t, + pub min_texel_buffer_offset_alignment: DeviceSize, + pub min_uniform_buffer_offset_alignment: DeviceSize, + pub min_storage_buffer_offset_alignment: DeviceSize, + pub min_texel_offset: int32_t, + pub max_texel_offset: uint32_t, + pub min_texel_gather_offset: int32_t, + pub max_texel_gather_offset: uint32_t, + pub min_interpolation_offset: c_float, + pub max_interpolation_offset: c_float, + pub sub_pixel_interpolation_offset_bits: uint32_t, + pub max_framebuffer_width: uint32_t, + pub max_framebuffer_height: uint32_t, + pub max_framebuffer_layers: uint32_t, + pub framebuffer_color_sample_counts: SampleCountFlags, + pub framebuffer_depth_sample_counts: SampleCountFlags, + pub framebuffer_stencil_sample_counts: SampleCountFlags, + pub framebuffer_no_attachments_sample_counts: SampleCountFlags, + pub max_color_attachments: uint32_t, + pub sampled_image_color_sample_counts: SampleCountFlags, + pub sampled_image_integer_sample_counts: SampleCountFlags, + pub sampled_image_depth_sample_counts: SampleCountFlags, + pub sampled_image_stencil_sample_counts: SampleCountFlags, + pub storage_image_sample_counts: SampleCountFlags, + pub max_sample_mask_words: uint32_t, + pub timestamp_compute_and_graphics: Bool32, + pub timestamp_period: c_float, + pub max_clip_distances: uint32_t, + pub max_cull_distances: uint32_t, + pub max_combined_clip_and_cull_distances: uint32_t, + pub discrete_queue_priorities: uint32_t, + pub point_size_range: [c_float; 2], + pub line_width_range: [c_float; 2], + pub point_size_granularity: c_float, + pub line_width_granularity: c_float, + pub strict_lines: Bool32, + pub standard_sample_locations: Bool32, + pub optimal_buffer_copy_offset_alignment: DeviceSize, + pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, + pub non_coherent_atom_size: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SemaphoreCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SemaphoreCreateFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct QueryPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: QueryPoolCreateFlags, + pub query_type: QueryType, + pub query_count: uint32_t, + pub pipeline_statistics: QueryPipelineStatisticFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FramebufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: FramebufferCreateFlags, + pub render_pass: RenderPass, + pub attachment_count: uint32_t, + pub p_attachments: *const ImageView, + pub width: uint32_t, + pub height: uint32_t, + pub layers: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DrawIndirectCommand { + pub vertex_count: uint32_t, + pub instance_count: uint32_t, + pub first_vertex: uint32_t, + pub first_instance: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DrawIndexedIndirectCommand { + pub index_count: uint32_t, + pub instance_count: uint32_t, + pub first_index: uint32_t, + pub vertex_offset: int32_t, + pub first_instance: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DispatchIndirectCommand { + pub x: uint32_t, + pub y: uint32_t, + pub z: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: uint32_t, + pub p_wait_semaphores: *const Semaphore, + pub p_wait_dst_stage_mask: *const PipelineStageFlags, + pub command_buffer_count: uint32_t, + pub p_command_buffers: *const CommandBuffer, + pub signal_semaphore_count: uint32_t, + pub p_signal_semaphores: *const Semaphore, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPropertiesKHR { + pub display: DisplayKHR, + pub display_name: *const c_char, + pub physical_dimensions: Extent2D, + pub physical_resolution: Extent2D, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub plane_reorder_possible: Bool32, + pub persistent_content: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPlanePropertiesKHR { + pub current_display: DisplayKHR, + pub current_stack_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayModeParametersKHR { + pub visible_region: Extent2D, + pub refresh_rate: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayModePropertiesKHR { + pub display_mode: DisplayModeKHR, + pub parameters: DisplayModeParametersKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayModeCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplayModeCreateFlagsKHR, + pub parameters: DisplayModeParametersKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPlaneCapabilitiesKHR { + pub supported_alpha: DisplayPlaneAlphaFlagsKHR, + pub min_src_position: Offset2D, + pub max_src_position: Offset2D, + pub min_src_extent: Extent2D, + pub max_src_extent: Extent2D, + pub min_dst_position: Offset2D, + pub max_dst_position: Offset2D, + pub min_dst_extent: Extent2D, + pub max_dst_extent: Extent2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplaySurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplaySurfaceCreateFlagsKHR, + pub display_mode: DisplayModeKHR, + pub plane_index: uint32_t, + pub plane_stack_index: uint32_t, + pub transform: SurfaceTransformFlagsKHR, + pub global_alpha: c_float, + pub alpha_mode: DisplayPlaneAlphaFlagsKHR, + pub image_extent: Extent2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_rect: Rect2D, + pub dst_rect: Rect2D, + pub persistent: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SurfaceCapabilitiesKHR { + pub min_image_count: uint32_t, + pub max_image_count: uint32_t, + pub current_extent: Extent2D, + pub min_image_extent: Extent2D, + pub max_image_extent: Extent2D, + pub max_image_array_layers: uint32_t, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub current_transform: SurfaceTransformFlagsKHR, + pub supported_composite_alpha: CompositeAlphaFlagsKHR, + pub supported_usage_flags: ImageUsageFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AndroidSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AndroidSurfaceCreateFlagsKHR, + pub window: *const ANativeWindow, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MirSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MirSurfaceCreateFlagsKHR, + pub connection: *const MirConnection, + pub mir_surface: *const MirSurface, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ViSurfaceCreateInfoNN { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ViSurfaceCreateFlagsNN, + pub window: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct WaylandSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: WaylandSurfaceCreateFlagsKHR, + pub display: *const wl_display, + pub surface: *const wl_surface, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Win32SurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: Win32SurfaceCreateFlagsKHR, + pub hinstance: HINSTANCE, + pub hwnd: HWND, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct XlibSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XlibSurfaceCreateFlagsKHR, + pub dpy: *const Display, + pub window: Window, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct XcbSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XcbSurfaceCreateFlagsKHR, + pub connection: *const xcb_connection_t, + pub window: xcb_window_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SurfaceFormatKHR { + pub format: Format, + pub color_space: ColorSpaceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SwapchainCreateFlagsKHR, + pub surface: SurfaceKHR, + pub min_image_count: uint32_t, + pub image_format: Format, + pub image_color_space: ColorSpaceKHR, + pub image_extent: Extent2D, + pub image_array_layers: uint32_t, + pub image_usage: ImageUsageFlags, + pub image_sharing_mode: SharingMode, + pub queue_family_index_count: uint32_t, + pub p_queue_family_indices: *const uint32_t, + pub pre_transform: SurfaceTransformFlagsKHR, + pub composite_alpha: CompositeAlphaFlagsKHR, + pub present_mode: PresentModeKHR, + pub clipped: Bool32, + pub old_swapchain: SwapchainKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: uint32_t, + pub p_wait_semaphores: *const Semaphore, + pub swapchain_count: uint32_t, + pub p_swapchains: *const SwapchainKHR, + pub p_image_indices: *const uint32_t, + pub p_results: *const Result, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugReportCallbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugReportFlagsEXT, + pub pfn_callback: PFN_vkDebugReportCallbackEXT, + pub p_user_data: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ValidationFlagsEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub disabled_validation_check_count: uint32_t, + pub p_disabled_validation_checks: *const ValidationCheckEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineRasterizationStateRasterizationOrderAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub rasterization_order: RasterizationOrderAMD, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugMarkerObjectNameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: DebugReportObjectTypeEXT, + pub object: uint64_t, + pub p_object_name: *const c_char, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugMarkerObjectTagInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: DebugReportObjectTypeEXT, + pub object: uint64_t, + pub tag_name: uint64_t, + pub tag_size: size_t, + pub p_tag: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugMarkerMarkerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_marker_name: *const c_char, + pub color: [c_float; 4], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DedicatedAllocationImageCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dedicated_allocation: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DedicatedAllocationBufferCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dedicated_allocation: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DedicatedAllocationMemoryAllocateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub buffer: Buffer, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalImageFormatPropertiesNV { + pub image_format_properties: ImageFormatProperties, + pub external_memory_features: ExternalMemoryFeatureFlagsNV, + pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, + pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalMemoryImageCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlagsNV, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportMemoryAllocateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlagsNV, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportMemoryWin32HandleInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlagsNV, + pub handle: HANDLE, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportMemoryWin32HandleInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Win32KeyedMutexAcquireReleaseInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acquire_count: uint32_t, + pub p_acquire_syncs: *const DeviceMemory, + pub p_acquire_keys: *const uint64_t, + pub p_acquire_timeout_milliseconds: *const uint32_t, + pub release_count: uint32_t, + pub p_release_syncs: *const DeviceMemory, + pub p_release_keys: *const uint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGeneratedCommandsFeaturesNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub compute_binding_point_support: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGeneratedCommandsLimitsNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_indirect_commands_layout_token_count: uint32_t, + pub max_object_entry_counts: uint32_t, + pub min_sequence_count_buffer_offset_alignment: uint32_t, + pub min_sequence_index_buffer_offset_alignment: uint32_t, + pub min_commands_token_buffer_offset_alignment: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct IndirectCommandsTokenNVX { + pub token_type: IndirectCommandsTokenTypeNVX, + pub buffer: Buffer, + pub offset: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct IndirectCommandsLayoutTokenNVX { + pub token_type: IndirectCommandsTokenTypeNVX, + pub binding_unit: uint32_t, + pub dynamic_count: uint32_t, + pub divisor: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct IndirectCommandsLayoutCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline_bind_point: PipelineBindPoint, + pub flags: IndirectCommandsLayoutUsageFlagsNVX, + pub token_count: uint32_t, + pub p_tokens: *const IndirectCommandsLayoutTokenNVX, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CmdProcessCommandsInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_table: ObjectTableNVX, + pub indirect_commands_layout: IndirectCommandsLayoutNVX, + pub indirect_commands_token_count: uint32_t, + pub p_indirect_commands_tokens: *const IndirectCommandsTokenNVX, + pub max_sequences_count: uint32_t, + pub target_command_buffer: CommandBuffer, + pub sequences_count_buffer: Buffer, + pub sequences_count_offset: DeviceSize, + pub sequences_index_buffer: Buffer, + pub sequences_index_offset: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CmdReserveSpaceForCommandsInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_table: ObjectTableNVX, + pub indirect_commands_layout: IndirectCommandsLayoutNVX, + pub max_sequences_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectTableCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_count: uint32_t, + pub p_object_entry_types: *const ObjectEntryTypeNVX, + pub p_object_entry_counts: *const uint32_t, + pub p_object_entry_usage_flags: *const ObjectEntryUsageFlagsNVX, + pub max_uniform_buffers_per_descriptor: uint32_t, + pub max_storage_buffers_per_descriptor: uint32_t, + pub max_storage_images_per_descriptor: uint32_t, + pub max_sampled_images_per_descriptor: uint32_t, + pub max_pipeline_layouts: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectTableEntryNVX { + pub ty: ObjectEntryTypeNVX, + pub flags: ObjectEntryUsageFlagsNVX, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectTablePipelineEntryNVX { + pub ty: ObjectEntryTypeNVX, + pub flags: ObjectEntryUsageFlagsNVX, + pub pipeline: Pipeline, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectTableDescriptorSetEntryNVX { + pub ty: ObjectEntryTypeNVX, + pub flags: ObjectEntryUsageFlagsNVX, + pub pipeline_layout: PipelineLayout, + pub descriptor_set: DescriptorSet, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectTableVertexBufferEntryNVX { + pub ty: ObjectEntryTypeNVX, + pub flags: ObjectEntryUsageFlagsNVX, + pub buffer: Buffer, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectTableIndexBufferEntryNVX { + pub ty: ObjectEntryTypeNVX, + pub flags: ObjectEntryUsageFlagsNVX, + pub buffer: Buffer, + pub index_type: IndexType, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectTablePushConstantEntryNVX { + pub ty: ObjectEntryTypeNVX, + pub flags: ObjectEntryUsageFlagsNVX, + pub pipeline_layout: PipelineLayout, + pub stage_flags: ShaderStageFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceFeatures2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub features: PhysicalDeviceFeatures, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceFeatures2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceProperties2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub properties: PhysicalDeviceProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceProperties2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FormatProperties2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format_properties: FormatProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FormatProperties2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageFormatProperties2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_format_properties: ImageFormatProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageFormatProperties2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceImageFormatInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ty: ImageType, + pub tiling: ImageTiling, + pub usage: ImageUsageFlags, + pub flags: ImageCreateFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceImageFormatInfo2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct QueueFamilyProperties2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue_family_properties: QueueFamilyProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct QueueFamilyProperties2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMemoryProperties2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_properties: PhysicalDeviceMemoryProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMemoryProperties2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageFormatProperties2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub properties: SparseImageFormatProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageFormatProperties2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSparseImageFormatInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ty: ImageType, + pub samples: SampleCountFlags, + pub usage: ImageUsageFlags, + pub tiling: ImageTiling, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSparseImageFormatInfo2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDevicePushDescriptorPropertiesKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_push_descriptors: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PresentRegionsKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: uint32_t, + pub p_regions: *const PresentRegionKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PresentRegionKHR { + pub rectangle_count: uint32_t, + pub p_rectangles: *const RectLayerKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RectLayerKHR { + pub offset: Offset2D, + pub extent: Extent2D, + pub layer: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceVariablePointerFeatures { + pub s_type: StructureType, + pub p_next: *const c_void, + pub variable_pointers_storage_buffer: Bool32, + pub variable_pointers: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceVariablePointerFeaturesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalMemoryProperties { + pub external_memory_features: ExternalMemoryFeatureFlags, + pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, + pub compatible_handle_types: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalMemoryPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalImageFormatInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalImageFormatInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalImageFormatProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub external_memory_properties: ExternalMemoryProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalImageFormatPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalBufferInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferCreateFlags, + pub usage: BufferUsageFlags, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalBufferInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalBufferProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub external_memory_properties: ExternalMemoryProperties, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalBufferPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceIDProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_uuid: [uint8_t; VK_UUID_SIZE], + pub driver_uuid: [uint8_t; VK_UUID_SIZE], + pub device_luid: [uint8_t; VK_LUID_SIZE], + pub device_node_mask: uint32_t, + pub device_luid_valid: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceIDPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalMemoryImageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalMemoryImageCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalMemoryBufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalMemoryBufferCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportMemoryAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportMemoryAllocateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportMemoryWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportMemoryWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryWin32HandlePropertiesKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_type_bits: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportMemoryFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub fd: c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryFdPropertiesKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_type_bits: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Win32KeyedMutexAcquireReleaseInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acquire_count: uint32_t, + pub p_acquire_syncs: *const DeviceMemory, + pub p_acquire_keys: *const uint64_t, + pub p_acquire_timeouts: *const uint32_t, + pub release_count: uint32_t, + pub p_release_syncs: *const DeviceMemory, + pub p_release_keys: *const uint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalSemaphoreInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalSemaphoreInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalSemaphoreProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, + pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags, + pub external_semaphore_features: ExternalSemaphoreFeatureFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalSemaphorePropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportSemaphoreCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalSemaphoreHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportSemaphoreCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportSemaphoreWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportSemaphoreWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct D3D12FenceSubmitInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_values_count: uint32_t, + pub p_wait_semaphore_values: *const uint64_t, + pub signal_semaphore_values_count: uint32_t, + pub p_signal_semaphore_values: *const uint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SemaphoreGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportSemaphoreFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub fd: c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SemaphoreGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalFenceInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalFenceHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalFenceInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalFenceProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags, + pub compatible_handle_types: ExternalFenceHandleTypeFlags, + pub external_fence_features: ExternalFenceFeatureFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalFencePropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportFenceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalFenceHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportFenceCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportFenceWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub flags: FenceImportFlags, + pub handle_type: ExternalFenceHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExportFenceWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FenceGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub handle_type: ExternalFenceHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportFenceFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub flags: FenceImportFlags, + pub handle_type: ExternalFenceHandleTypeFlags, + pub fd: c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FenceGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub handle_type: ExternalFenceHandleTypeFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMultiviewFeatures { + pub s_type: StructureType, + pub p_next: *const c_void, + pub multiview: Bool32, + pub multiview_geometry_shader: Bool32, + pub multiview_tessellation_shader: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMultiviewFeaturesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMultiviewProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_multiview_view_count: uint32_t, + pub max_multiview_instance_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMultiviewPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RenderPassMultiviewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub subpass_count: uint32_t, + pub p_view_masks: *const uint32_t, + pub dependency_count: uint32_t, + pub p_view_offsets: *const int32_t, + pub correlation_mask_count: uint32_t, + pub p_correlation_masks: *const uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RenderPassMultiviewCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SurfaceCapabilities2EXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_image_count: uint32_t, + pub max_image_count: uint32_t, + pub current_extent: Extent2D, + pub min_image_extent: Extent2D, + pub max_image_extent: Extent2D, + pub max_image_array_layers: uint32_t, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub current_transform: SurfaceTransformFlagsKHR, + pub supported_composite_alpha: CompositeAlphaFlagsKHR, + pub supported_usage_flags: ImageUsageFlags, + pub supported_surface_counters: SurfaceCounterFlagsEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPowerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub power_state: DisplayPowerStateEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_event: DeviceEventTypeEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_event: DisplayEventTypeEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SwapchainCounterCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface_counters: SurfaceCounterFlagsEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceGroupProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub physical_device_count: uint32_t, + pub physical_devices: [PhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE], + pub subset_allocation: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceGroupPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryAllocateFlagsInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MemoryAllocateFlags, + pub device_mask: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryAllocateFlagsInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindBufferMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindBufferMemoryInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindBufferMemoryDeviceGroupInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_index_count: uint32_t, + pub p_device_indices: *const uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindBufferMemoryDeviceGroupInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindImageMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindImageMemoryInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindImageMemoryDeviceGroupInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_index_count: uint32_t, + pub p_device_indices: *const uint32_t, + pub split_instance_bind_region_count: uint32_t, + pub p_split_instance_bind_regions: *const Rect2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindImageMemoryDeviceGroupInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupRenderPassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_mask: uint32_t, + pub device_render_area_count: uint32_t, + pub p_device_render_areas: *const Rect2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupRenderPassBeginInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupCommandBufferBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_mask: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupCommandBufferBeginInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: uint32_t, + pub p_wait_semaphore_device_indices: *const uint32_t, + pub command_buffer_count: uint32_t, + pub p_command_buffer_device_masks: *const uint32_t, + pub signal_semaphore_count: uint32_t, + pub p_signal_semaphore_device_indices: *const uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupSubmitInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupBindSparseInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub resource_device_index: uint32_t, + pub memory_device_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupBindSparseInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupPresentCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub present_mask: [uint32_t; VK_MAX_DEVICE_GROUP_SIZE], + pub modes: DeviceGroupPresentModeFlagsKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageSwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindImageMemorySwapchainInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub image_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AcquireNextImageInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub timeout: uint64_t, + pub semaphore: Semaphore, + pub fence: Fence, + pub device_mask: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupPresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: uint32_t, + pub p_device_masks: *const uint32_t, + pub mode: DeviceGroupPresentModeFlagsKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupDeviceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub physical_device_count: uint32_t, + pub p_physical_devices: *const PhysicalDevice, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupDeviceCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceGroupSwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub modes: DeviceGroupPresentModeFlagsKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorUpdateTemplateEntry { + pub dst_binding: uint32_t, + pub dst_array_element: uint32_t, + pub descriptor_count: uint32_t, + pub descriptor_type: DescriptorType, + pub offset: size_t, + pub stride: size_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorUpdateTemplateEntryKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorUpdateTemplateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorUpdateTemplateCreateFlags, + pub descriptor_update_entry_count: uint32_t, + pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry, + pub template_type: DescriptorUpdateTemplateType, + pub descriptor_set_layout: DescriptorSetLayout, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline_layout: PipelineLayout, + pub set: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorUpdateTemplateCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct XYColorEXT { + pub x: c_float, + pub y: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct HdrMetadataEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_primary_red: XYColorEXT, + pub display_primary_green: XYColorEXT, + pub display_primary_blue: XYColorEXT, + pub white_point: XYColorEXT, + pub max_luminance: c_float, + pub min_luminance: c_float, + pub max_content_light_level: c_float, + pub max_frame_average_light_level: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RefreshCycleDurationGOOGLE { + pub refresh_duration: uint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PastPresentationTimingGOOGLE { + pub present_id: uint32_t, + pub desired_present_time: uint64_t, + pub actual_present_time: uint64_t, + pub earliest_present_time: uint64_t, + pub present_margin: uint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PresentTimesInfoGOOGLE { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: uint32_t, + pub p_times: *const PresentTimeGOOGLE, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PresentTimeGOOGLE { + pub present_id: uint32_t, + pub desired_present_time: uint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct IOSSurfaceCreateInfoMVK { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: IOSSurfaceCreateFlagsMVK, + pub p_view: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MacOSSurfaceCreateInfoMVK { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MacOSSurfaceCreateFlagsMVK, + pub p_view: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ViewportWScalingNV { + pub xcoeff: c_float, + pub ycoeff: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineViewportWScalingStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub viewport_w_scaling_enable: Bool32, + pub viewport_count: uint32_t, + pub p_viewport_w_scalings: *const ViewportWScalingNV, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ViewportSwizzleNV { + pub x: ViewportCoordinateSwizzleNV, + pub y: ViewportCoordinateSwizzleNV, + pub z: ViewportCoordinateSwizzleNV, + pub w: ViewportCoordinateSwizzleNV, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineViewportSwizzleStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineViewportSwizzleStateCreateFlagsNV, + pub viewport_count: uint32_t, + pub p_viewport_swizzles: *const ViewportSwizzleNV, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_discard_rectangles: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineDiscardRectangleStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDiscardRectangleStateCreateFlagsEXT, + pub discard_rectangle_mode: DiscardRectangleModeEXT, + pub discard_rectangle_count: uint32_t, + pub p_discard_rectangles: *const Rect2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub per_view_position_all_components: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct InputAttachmentAspectReference { + pub subpass: uint32_t, + pub input_attachment_index: uint32_t, + pub aspect_mask: ImageAspectFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct InputAttachmentAspectReferenceKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RenderPassInputAttachmentAspectCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub aspect_reference_count: uint32_t, + pub p_aspect_references: *const InputAttachmentAspectReference, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RenderPassInputAttachmentAspectCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSurfaceInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface: SurfaceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SurfaceCapabilities2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface_capabilities: SurfaceCapabilitiesKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SurfaceFormat2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface_format: SurfaceFormatKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayProperties2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_properties: DisplayPropertiesKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPlaneProperties2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_plane_properties: DisplayPlanePropertiesKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayModeProperties2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_mode_properties: DisplayModePropertiesKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPlaneInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mode: DisplayModeKHR, + pub plane_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DisplayPlaneCapabilities2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub capabilities: DisplayPlaneCapabilitiesKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SharedPresentSurfaceCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shared_present_supported_usage_flags: ImageUsageFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDevice16BitStorageFeatures { + pub s_type: StructureType, + pub p_next: *const c_void, + pub storage_buffer16_bit_access: Bool32, + pub uniform_and_storage_buffer16_bit_access: Bool32, + pub storage_push_constant16: Bool32, + pub storage_input_output16: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDevice16BitStorageFeaturesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSubgroupProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub subgroup_size: uint32_t, + pub supported_stages: ShaderStageFlags, + pub supported_operations: SubgroupFeatureFlags, + pub quad_operations_in_all_stages: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BufferMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BufferMemoryRequirementsInfo2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageMemoryRequirementsInfo2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageSparseMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageSparseMemoryRequirementsInfo2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryRequirements2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_requirements: MemoryRequirements, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryRequirements2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageMemoryRequirements2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_requirements: SparseImageMemoryRequirements, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SparseImageMemoryRequirements2KHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDevicePointClippingProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub point_clipping_behavior: PointClippingBehavior, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDevicePointClippingPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryDedicatedRequirements { + pub s_type: StructureType, + pub p_next: *const c_void, + pub prefers_dedicated_allocation: Bool32, + pub requires_dedicated_allocation: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryDedicatedRequirementsKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryDedicatedAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub buffer: Buffer, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryDedicatedAllocateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageViewUsageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: ImageUsageFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageViewUsageCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineTessellationDomainOriginStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub domain_origin: TessellationDomainOrigin, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineTessellationDomainOriginStateCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerYcbcrConversionInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub conversion: SamplerYcbcrConversion, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerYcbcrConversionInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerYcbcrConversionCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ycbcr_model: SamplerYcbcrModelConversion, + pub ycbcr_range: SamplerYcbcrRange, + pub components: ComponentMapping, + pub x_chroma_offset: ChromaLocation, + pub y_chroma_offset: ChromaLocation, + pub chroma_filter: Filter, + pub force_explicit_reconstruction: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerYcbcrConversionCreateInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindImagePlaneMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane_aspect: ImageAspectFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BindImagePlaneMemoryInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImagePlaneMemoryRequirementsInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane_aspect: ImageAspectFlags, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImagePlaneMemoryRequirementsInfoKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sampler_ycbcr_conversion: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerYcbcrConversionImageFormatProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub combined_image_sampler_descriptor_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerYcbcrConversionImageFormatPropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct TextureLODGatherFormatPropertiesAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub supports_texture_gather_lod_bias_amd: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ProtectedSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub protected_submit: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceProtectedMemoryFeatures { + pub s_type: StructureType, + pub p_next: *const c_void, + pub protected_memory: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceProtectedMemoryProperties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub protected_no_fault: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceQueueInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceQueueCreateFlags, + pub queue_family_index: uint32_t, + pub queue_index: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineCoverageToColorStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageToColorStateCreateFlagsNV, + pub coverage_to_color_enable: Bool32, + pub coverage_to_color_location: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub filter_minmax_single_component_formats: Bool32, + pub filter_minmax_image_component_mapping: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SampleLocationEXT { + pub x: c_float, + pub y: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SampleLocationsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_locations_per_pixel: SampleCountFlags, + pub sample_location_grid_size: Extent2D, + pub sample_locations_count: uint32_t, + pub p_sample_locations: *const SampleLocationEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AttachmentSampleLocationsEXT { + pub attachment_index: uint32_t, + pub sample_locations_info: SampleLocationsInfoEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SubpassSampleLocationsEXT { + pub subpass_index: uint32_t, + pub sample_locations_info: SampleLocationsInfoEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RenderPassSampleLocationsBeginInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_initial_sample_locations_count: uint32_t, + pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT, + pub post_subpass_sample_locations_count: uint32_t, + pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineSampleLocationsStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_locations_enable: Bool32, + pub sample_locations_info: SampleLocationsInfoEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceSampleLocationsPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_location_sample_counts: SampleCountFlags, + pub max_sample_location_grid_size: Extent2D, + pub sample_location_coordinate_range: [c_float; 2], + pub sample_location_sub_pixel_bits: uint32_t, + pub variable_sample_locations: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MultisamplePropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_sample_location_grid_size: Extent2D, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SamplerReductionModeCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reduction_mode: SamplerReductionModeEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub advanced_blend_coherent_operations: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub advanced_blend_max_color_attachments: uint32_t, + pub advanced_blend_independent_blend: Bool32, + pub advanced_blend_non_premultiplied_src_color: Bool32, + pub advanced_blend_non_premultiplied_dst_color: Bool32, + pub advanced_blend_correlated_overlap: Bool32, + pub advanced_blend_all_operations: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_premultiplied: Bool32, + pub dst_premultiplied: Bool32, + pub blend_overlap: BlendOverlapEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineCoverageModulationStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageModulationStateCreateFlagsNV, + pub coverage_modulation_mode: CoverageModulationModeNV, + pub coverage_modulation_table_enable: Bool32, + pub coverage_modulation_table_count: uint32_t, + pub p_coverage_modulation_table: *const c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImageFormatListCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_format_count: uint32_t, + pub p_view_formats: *const Format, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ValidationCacheCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ValidationCacheCreateFlagsEXT, + pub initial_data_size: size_t, + pub p_initial_data: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ShaderModuleValidationCacheCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub validation_cache: ValidationCacheEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMaintenance3Properties { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_per_set_descriptors: uint32_t, + pub max_memory_allocation_size: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceMaintenance3PropertiesKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetLayoutSupport { + pub s_type: StructureType, + pub p_next: *const c_void, + pub supported: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetLayoutSupportKHR {} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceShaderDrawParameterFeatures { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shader_draw_parameters: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NativeBufferANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle: *const c_void, + pub stride: c_int, + pub format: c_int, + pub usage: c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ShaderResourceUsageAMD { + pub num_used_vgprs: uint32_t, + pub num_used_sgprs: uint32_t, + pub lds_size_per_local_work_group: uint32_t, + pub lds_usage_size_in_bytes: size_t, + pub scratch_mem_usage_in_bytes: size_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ShaderStatisticsInfoAMD { + pub shader_stage_mask: ShaderStageFlags, + pub resource_usage: ShaderResourceUsageAMD, + pub num_physical_vgprs: uint32_t, + pub num_physical_sgprs: uint32_t, + pub num_available_vgprs: uint32_t, + pub num_available_sgprs: uint32_t, + pub compute_work_group_size: [uint32_t; 3], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DeviceQueueGlobalPriorityCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub global_priority: QueueGlobalPriorityEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugUtilsObjectNameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: ObjectType, + pub object_handle: uint64_t, + pub p_object_name: *const c_char, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugUtilsObjectTagInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: ObjectType, + pub object_handle: uint64_t, + pub tag_name: uint64_t, + pub tag_size: size_t, + pub p_tag: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugUtilsLabelEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_label_name: *const c_char, + pub color: [c_float; 4], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugUtilsMessengerCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugUtilsMessengerCreateFlagsEXT, + pub message_severity: DebugUtilsMessageSeverityFlagsEXT, + pub message_type: DebugUtilsMessageTypeFlagsEXT, + pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, + pub p_user_data: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DebugUtilsMessengerCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugUtilsMessengerCallbackDataFlagsEXT, + pub p_message_id_name: *const c_char, + pub message_id_number: int32_t, + pub p_message: *const c_char, + pub queue_label_count: uint32_t, + pub p_queue_labels: *const DebugUtilsLabelEXT, + pub cmd_buf_label_count: uint32_t, + pub p_cmd_buf_labels: *const DebugUtilsLabelEXT, + pub object_count: uint32_t, + pub p_objects: *const DebugUtilsObjectNameInfoEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportMemoryHostPointerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub p_host_pointer: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryHostPointerPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_type_bits: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_imported_host_pointer_alignment: DeviceSize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub primitive_overestimation_size: c_float, + pub max_extra_primitive_overestimation_size: c_float, + pub extra_primitive_overestimation_size_granularity: c_float, + pub primitive_underestimation: Bool32, + pub conservative_point_and_line_rasterization: Bool32, + pub degenerate_triangles_rasterized: Bool32, + pub degenerate_lines_rasterized: Bool32, + pub fully_covered_fragment_shader_input_variable: Bool32, + pub conservative_rasterization_post_depth_coverage: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceShaderCorePropertiesAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shader_engine_count: uint32_t, + pub shader_arrays_per_engine_count: uint32_t, + pub compute_units_per_shader_array: uint32_t, + pub simd_per_compute_unit: uint32_t, + pub wavefronts_per_simd: uint32_t, + pub wavefront_size: uint32_t, + pub sgprs_per_simd: uint32_t, + pub min_sgpr_allocation: uint32_t, + pub max_sgpr_allocation: uint32_t, + pub sgpr_allocation_granularity: uint32_t, + pub vgprs_per_simd: uint32_t, + pub min_vgpr_allocation: uint32_t, + pub max_vgpr_allocation: uint32_t, + pub vgpr_allocation_granularity: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineRasterizationConservativeStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT, + pub conservative_rasterization_mode: ConservativeRasterizationModeEXT, + pub extra_primitive_overestimation_size: c_float, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceDescriptorIndexingFeaturesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shader_input_attachment_array_dynamic_indexing: Bool32, + pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_uniform_buffer_array_non_uniform_indexing: Bool32, + pub shader_sampled_image_array_non_uniform_indexing: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_image_array_non_uniform_indexing: Bool32, + pub shader_input_attachment_array_non_uniform_indexing: Bool32, + pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32, + pub descriptor_binding_uniform_buffer_update_after_bind: Bool32, + pub descriptor_binding_sampled_image_update_after_bind: Bool32, + pub descriptor_binding_storage_image_update_after_bind: Bool32, + pub descriptor_binding_storage_buffer_update_after_bind: Bool32, + pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_update_unused_while_pending: Bool32, + pub descriptor_binding_partially_bound: Bool32, + pub descriptor_binding_variable_descriptor_count: Bool32, + pub runtime_descriptor_array: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_update_after_bind_descriptors_in_all_pools: uint32_t, + pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_sampled_image_array_non_uniform_indexing_native: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_storage_image_array_non_uniform_indexing_native: Bool32, + pub shader_input_attachment_array_non_uniform_indexing_native: Bool32, + pub robust_buffer_access_update_after_bind: Bool32, + pub quad_divergent_implicit_lod: Bool32, + pub max_per_stage_descriptor_update_after_bind_samplers: uint32_t, + pub max_per_stage_descriptor_update_after_bind_uniform_buffers: uint32_t, + pub max_per_stage_descriptor_update_after_bind_storage_buffers: uint32_t, + pub max_per_stage_descriptor_update_after_bind_sampled_images: uint32_t, + pub max_per_stage_descriptor_update_after_bind_storage_images: uint32_t, + pub max_per_stage_descriptor_update_after_bind_input_attachments: uint32_t, + pub max_per_stage_update_after_bind_resources: uint32_t, + pub max_descriptor_set_update_after_bind_samplers: uint32_t, + pub max_descriptor_set_update_after_bind_uniform_buffers: uint32_t, + pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: uint32_t, + pub max_descriptor_set_update_after_bind_storage_buffers: uint32_t, + pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: uint32_t, + pub max_descriptor_set_update_after_bind_sampled_images: uint32_t, + pub max_descriptor_set_update_after_bind_storage_images: uint32_t, + pub max_descriptor_set_update_after_bind_input_attachments: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub binding_count: uint32_t, + pub p_binding_flags: *const DescriptorBindingFlagsEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_set_count: uint32_t, + pub p_descriptor_counts: *const uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_variable_descriptor_count: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct VertexInputBindingDivisorDescriptionEXT { + pub binding: uint32_t, + pub divisor: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PipelineVertexInputDivisorStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_binding_divisor_count: uint32_t, + pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_vertex_attrib_divisor: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ImportAndroidHardwareBufferInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: *const AHardwareBuffer, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AndroidHardwareBufferUsageANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub android_hardware_buffer_usage: uint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AndroidHardwareBufferPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub allocation_size: DeviceSize, + pub memory_type_bits: uint32_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MemoryGetAndroidHardwareBufferInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AndroidHardwareBufferFormatPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub external_format: uint64_t, + pub format_features: FormatFeatureFlags, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ExternalFormatANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub external_format: uint64_t, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ImageLayout { + Undefined = 0, + General = 1, + ColorAttachmentOptimal = 2, + DepthStencilAttachmentOptimal = 3, + DepthStencilReadOnlyOptimal = 4, + ShaderReadOnlyOptimal = 5, + TransferSrcOptimal = 6, + TransferDstOptimal = 7, + Preinitialized = 8, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum AttachmentLoadOp { + Load = 0, + Clear = 1, + DontCare = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum AttachmentStoreOp { + Store = 0, + DontCare = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ImageType { + Type1d = 0, + Type2d = 1, + Type3d = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ImageTiling { + Optimal = 0, + Linear = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ImageViewType { + Type1d = 0, + Type2d = 1, + Type3d = 2, + Cube = 3, + Type1dArray = 4, + Type2dArray = 5, + CubeArray = 6, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum CommandBufferLevel { + Primary = 0, + Secondary = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ComponentSwizzle { + Identity = 0, + Zero = 1, + One = 2, + R = 3, + G = 4, + B = 5, + A = 6, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DescriptorType { + Sampler = 0, + CombinedImageSampler = 1, + SampledImage = 2, + StorageImage = 3, + UniformTexelBuffer = 4, + StorageTexelBuffer = 5, + UniformBuffer = 6, + StorageBuffer = 7, + UniformBufferDynamic = 8, + StorageBufferDynamic = 9, + InputAttachment = 10, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum QueryType { + Occlusion = 0, + PipelineStatistics = 1, + Timestamp = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum BorderColor { + FloatTransparentBlack = 0, + IntTransparentBlack = 1, + FloatOpaqueBlack = 2, + IntOpaqueBlack = 3, + FloatOpaqueWhite = 4, + IntOpaqueWhite = 5, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum PipelineBindPoint { + Graphics = 0, + Compute = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum PipelineCacheHeaderVersion { + One = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum PrimitiveTopology { + PointList = 0, + LineList = 1, + LineStrip = 2, + TriangleList = 3, + TriangleStrip = 4, + TriangleFan = 5, + LineListWithAdjacency = 6, + LineStripWithAdjacency = 7, + TriangleListWithAdjacency = 8, + TriangleStripWithAdjacency = 9, + PatchList = 10, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SharingMode { + Exclusive = 0, + Concurrent = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum IndexType { + Uint16 = 0, + Uint32 = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum Filter { + Nearest = 0, + Linear = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SamplerMipmapMode { + Nearest = 0, + Linear = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SamplerAddressMode { + Repeat = 0, + MirroredRepeat = 1, + ClampToEdge = 2, + ClampToBorder = 3, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum CompareOp { + Never = 0, + Less = 1, + Equal = 2, + LessOrEqual = 3, + Greater = 4, + NotEqual = 5, + GreaterOrEqual = 6, + Always = 7, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum PolygonMode { + Fill = 0, + Line = 1, + Point = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum FrontFace { + CounterClockwise = 0, + Clockwise = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum BlendFactor { + Zero = 0, + One = 1, + SrcColor = 2, + OneMinusSrcColor = 3, + DstColor = 4, + OneMinusDstColor = 5, + SrcAlpha = 6, + OneMinusSrcAlpha = 7, + DstAlpha = 8, + OneMinusDstAlpha = 9, + ConstantColor = 10, + OneMinusConstantColor = 11, + ConstantAlpha = 12, + OneMinusConstantAlpha = 13, + SrcAlphaSaturate = 14, + Src1Color = 15, + OneMinusSrc1Color = 16, + Src1Alpha = 17, + OneMinusSrc1Alpha = 18, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum BlendOp { + Add = 0, + Subtract = 1, + ReverseSubtract = 2, + Min = 3, + Max = 4, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum StencilOp { + Keep = 0, + Zero = 1, + Replace = 2, + IncrementAndClamp = 3, + DecrementAndClamp = 4, + Invert = 5, + IncrementAndWrap = 6, + DecrementAndWrap = 7, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum LogicOp { + Clear = 0, + And = 1, + AndReverse = 2, + Copy = 3, + AndInverted = 4, + NoOp = 5, + Xor = 6, + Or = 7, + Nor = 8, + Equivalent = 9, + Invert = 10, + OrReverse = 11, + CopyInverted = 12, + OrInverted = 13, + Nand = 14, + Set = 15, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum InternalAllocationType { + Executable = 0, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SystemAllocationScope { + Command = 0, + Object = 1, + Cache = 2, + Device = 3, + Instance = 4, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum PhysicalDeviceType { + Other = 0, + IntegratedGpu = 1, + DiscreteGpu = 2, + VirtualGpu = 3, + Cpu = 4, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum VertexInputRate { + Vertex = 0, + Instance = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum Format { + Undefined = 0, + R4g4UnormPack8 = 1, + R4g4b4a4UnormPack16 = 2, + B4g4r4a4UnormPack16 = 3, + R5g6b5UnormPack16 = 4, + B5g6r5UnormPack16 = 5, + R5g5b5a1UnormPack16 = 6, + B5g5r5a1UnormPack16 = 7, + A1r5g5b5UnormPack16 = 8, + R8Unorm = 9, + R8Snorm = 10, + R8Uscaled = 11, + R8Sscaled = 12, + R8Uint = 13, + R8Sint = 14, + R8Srgb = 15, + R8g8Unorm = 16, + R8g8Snorm = 17, + R8g8Uscaled = 18, + R8g8Sscaled = 19, + R8g8Uint = 20, + R8g8Sint = 21, + R8g8Srgb = 22, + R8g8b8Unorm = 23, + R8g8b8Snorm = 24, + R8g8b8Uscaled = 25, + R8g8b8Sscaled = 26, + R8g8b8Uint = 27, + R8g8b8Sint = 28, + R8g8b8Srgb = 29, + B8g8r8Unorm = 30, + B8g8r8Snorm = 31, + B8g8r8Uscaled = 32, + B8g8r8Sscaled = 33, + B8g8r8Uint = 34, + B8g8r8Sint = 35, + B8g8r8Srgb = 36, + R8g8b8a8Unorm = 37, + R8g8b8a8Snorm = 38, + R8g8b8a8Uscaled = 39, + R8g8b8a8Sscaled = 40, + R8g8b8a8Uint = 41, + R8g8b8a8Sint = 42, + R8g8b8a8Srgb = 43, + B8g8r8a8Unorm = 44, + B8g8r8a8Snorm = 45, + B8g8r8a8Uscaled = 46, + B8g8r8a8Sscaled = 47, + B8g8r8a8Uint = 48, + B8g8r8a8Sint = 49, + B8g8r8a8Srgb = 50, + A8b8g8r8UnormPack32 = 51, + A8b8g8r8SnormPack32 = 52, + A8b8g8r8UscaledPack32 = 53, + A8b8g8r8SscaledPack32 = 54, + A8b8g8r8UintPack32 = 55, + A8b8g8r8SintPack32 = 56, + A8b8g8r8SrgbPack32 = 57, + A2r10g10b10UnormPack32 = 58, + A2r10g10b10SnormPack32 = 59, + A2r10g10b10UscaledPack32 = 60, + A2r10g10b10SscaledPack32 = 61, + A2r10g10b10UintPack32 = 62, + A2r10g10b10SintPack32 = 63, + A2b10g10r10UnormPack32 = 64, + A2b10g10r10SnormPack32 = 65, + A2b10g10r10UscaledPack32 = 66, + A2b10g10r10SscaledPack32 = 67, + A2b10g10r10UintPack32 = 68, + A2b10g10r10SintPack32 = 69, + R16Unorm = 70, + R16Snorm = 71, + R16Uscaled = 72, + R16Sscaled = 73, + R16Uint = 74, + R16Sint = 75, + R16Sfloat = 76, + R16g16Unorm = 77, + R16g16Snorm = 78, + R16g16Uscaled = 79, + R16g16Sscaled = 80, + R16g16Uint = 81, + R16g16Sint = 82, + R16g16Sfloat = 83, + R16g16b16Unorm = 84, + R16g16b16Snorm = 85, + R16g16b16Uscaled = 86, + R16g16b16Sscaled = 87, + R16g16b16Uint = 88, + R16g16b16Sint = 89, + R16g16b16Sfloat = 90, + R16g16b16a16Unorm = 91, + R16g16b16a16Snorm = 92, + R16g16b16a16Uscaled = 93, + R16g16b16a16Sscaled = 94, + R16g16b16a16Uint = 95, + R16g16b16a16Sint = 96, + R16g16b16a16Sfloat = 97, + R32Uint = 98, + R32Sint = 99, + R32Sfloat = 100, + R32g32Uint = 101, + R32g32Sint = 102, + R32g32Sfloat = 103, + R32g32b32Uint = 104, + R32g32b32Sint = 105, + R32g32b32Sfloat = 106, + R32g32b32a32Uint = 107, + R32g32b32a32Sint = 108, + R32g32b32a32Sfloat = 109, + R64Uint = 110, + R64Sint = 111, + R64Sfloat = 112, + R64g64Uint = 113, + R64g64Sint = 114, + R64g64Sfloat = 115, + R64g64b64Uint = 116, + R64g64b64Sint = 117, + R64g64b64Sfloat = 118, + R64g64b64a64Uint = 119, + R64g64b64a64Sint = 120, + R64g64b64a64Sfloat = 121, + B10g11r11UfloatPack32 = 122, + E5b9g9r9UfloatPack32 = 123, + D16Unorm = 124, + X8D24UnormPack32 = 125, + D32Sfloat = 126, + S8Uint = 127, + D16UnormS8Uint = 128, + D24UnormS8Uint = 129, + D32SfloatS8Uint = 130, + Bc1RgbUnormBlock = 131, + Bc1RgbSrgbBlock = 132, + Bc1RgbaUnormBlock = 133, + Bc1RgbaSrgbBlock = 134, + Bc2UnormBlock = 135, + Bc2SrgbBlock = 136, + Bc3UnormBlock = 137, + Bc3SrgbBlock = 138, + Bc4UnormBlock = 139, + Bc4SnormBlock = 140, + Bc5UnormBlock = 141, + Bc5SnormBlock = 142, + Bc6hUfloatBlock = 143, + Bc6hSfloatBlock = 144, + Bc7UnormBlock = 145, + Bc7SrgbBlock = 146, + Etc2R8g8b8UnormBlock = 147, + Etc2R8g8b8SrgbBlock = 148, + Etc2R8g8b8a1UnormBlock = 149, + Etc2R8g8b8a1SrgbBlock = 150, + Etc2R8g8b8a8UnormBlock = 151, + Etc2R8g8b8a8SrgbBlock = 152, + EacR11UnormBlock = 153, + EacR11SnormBlock = 154, + EacR11g11UnormBlock = 155, + EacR11g11SnormBlock = 156, + Astc4x4UnormBlock = 157, + Astc4x4SrgbBlock = 158, + Astc5x4UnormBlock = 159, + Astc5x4SrgbBlock = 160, + Astc5x5UnormBlock = 161, + Astc5x5SrgbBlock = 162, + Astc6x5UnormBlock = 163, + Astc6x5SrgbBlock = 164, + Astc6x6UnormBlock = 165, + Astc6x6SrgbBlock = 166, + Astc8x5UnormBlock = 167, + Astc8x5SrgbBlock = 168, + Astc8x6UnormBlock = 169, + Astc8x6SrgbBlock = 170, + Astc8x8UnormBlock = 171, + Astc8x8SrgbBlock = 172, + Astc10x5UnormBlock = 173, + Astc10x5SrgbBlock = 174, + Astc10x6UnormBlock = 175, + Astc10x6SrgbBlock = 176, + Astc10x8UnormBlock = 177, + Astc10x8SrgbBlock = 178, + Astc10x10UnormBlock = 179, + Astc10x10SrgbBlock = 180, + Astc12x10UnormBlock = 181, + Astc12x10SrgbBlock = 182, + Astc12x12UnormBlock = 183, + Astc12x12SrgbBlock = 184, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum StructureType { + ApplicationInfo = 0, + InstanceCreateInfo = 1, + DeviceQueueCreateInfo = 2, + DeviceCreateInfo = 3, + SubmitInfo = 4, + MemoryAllocateInfo = 5, + MappedMemoryRange = 6, + BindSparseInfo = 7, + FenceCreateInfo = 8, + SemaphoreCreateInfo = 9, + EventCreateInfo = 10, + QueryPoolCreateInfo = 11, + BufferCreateInfo = 12, + BufferViewCreateInfo = 13, + ImageCreateInfo = 14, + ImageViewCreateInfo = 15, + ShaderModuleCreateInfo = 16, + PipelineCacheCreateInfo = 17, + PipelineShaderStageCreateInfo = 18, + PipelineVertexInputStateCreateInfo = 19, + PipelineInputAssemblyStateCreateInfo = 20, + PipelineTessellationStateCreateInfo = 21, + PipelineViewportStateCreateInfo = 22, + PipelineRasterizationStateCreateInfo = 23, + PipelineMultisampleStateCreateInfo = 24, + PipelineDepthStencilStateCreateInfo = 25, + PipelineColorBlendStateCreateInfo = 26, + PipelineDynamicStateCreateInfo = 27, + GraphicsPipelineCreateInfo = 28, + ComputePipelineCreateInfo = 29, + PipelineLayoutCreateInfo = 30, + SamplerCreateInfo = 31, + DescriptorSetLayoutCreateInfo = 32, + DescriptorPoolCreateInfo = 33, + DescriptorSetAllocateInfo = 34, + WriteDescriptorSet = 35, + CopyDescriptorSet = 36, + FramebufferCreateInfo = 37, + RenderPassCreateInfo = 38, + CommandPoolCreateInfo = 39, + CommandBufferAllocateInfo = 40, + CommandBufferInheritanceInfo = 41, + CommandBufferBeginInfo = 42, + RenderPassBeginInfo = 43, + BufferMemoryBarrier = 44, + ImageMemoryBarrier = 45, + MemoryBarrier = 46, + LoaderInstanceCreateInfo = 47, + LoaderDeviceCreateInfo = 48, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SubpassContents { + Inline = 0, + SecondaryCommandBuffers = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum Result { + Success = 0, + NotReady = 1, + Timeout = 2, + EventSet = 3, + EventReset = 4, + Incomplete = 5, + ErrorOutOfHostMemory = -1, + ErrorOutOfDeviceMemory = -2, + ErrorInitializationFailed = -3, + ErrorDeviceLost = -4, + ErrorMemoryMapFailed = -5, + ErrorLayerNotPresent = -6, + ErrorExtensionNotPresent = -7, + ErrorFeatureNotPresent = -8, + ErrorIncompatibleDriver = -9, + ErrorTooManyObjects = -10, + ErrorFormatNotSupported = -11, + ErrorFragmentedPool = -12, +} +impl ::std::error::Error for Result { + fn description(&self) -> &str { + "vk::Result" + } +} +impl ::std::fmt::Display for Result { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + writeln!(fmt, "vk::Result::{:?}", self)?; + match self { + Result::Success => write!(fmt, "Command completed successfully"), + Result::NotReady => write!(fmt, "A fence or query has not yet completed"), + Result::Timeout => write!( + fmt, + "A wait operation has not completed in the specified time" + ), + Result::EventSet => write!(fmt, "An event is signaled"), + Result::EventReset => write!(fmt, "An event is unsignaled"), + Result::Incomplete => write!(fmt, "A return array was too small for the result"), + Result::ErrorOutOfHostMemory => write!(fmt, "A host memory allocation has failed"), + Result::ErrorOutOfDeviceMemory => write!(fmt, "A device memory allocation has failed"), + Result::ErrorInitializationFailed => { + write!(fmt, "Initialization of a object has failed") + } + Result::ErrorDeviceLost => write!( + fmt, + "The logical device has been lost. See <>" + ), + Result::ErrorMemoryMapFailed => write!(fmt, "Mapping of a memory object has failed"), + Result::ErrorLayerNotPresent => write!(fmt, "Layer specified does not exist"), + Result::ErrorExtensionNotPresent => write!(fmt, "Extension specified does not exist"), + Result::ErrorFeatureNotPresent => { + write!(fmt, "Requested feature is not available on this device") + } + Result::ErrorIncompatibleDriver => write!(fmt, "Unable to find a Vulkan driver"), + Result::ErrorTooManyObjects => write!( + fmt, + "Too many objects of the type have already been created" + ), + Result::ErrorFormatNotSupported => { + write!(fmt, "Requested format is not supported on this device") + } + Result::ErrorFragmentedPool => write!( + fmt, + "A requested pool allocation has failed due to fragmentation of the pool\'s memory" + ), + } + } +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DynamicState { + Viewport = 0, + Scissor = 1, + LineWidth = 2, + DepthBias = 3, + BlendConstants = 4, + DepthBounds = 5, + StencilCompareMask = 6, + StencilWriteMask = 7, + StencilReference = 8, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DescriptorUpdateTemplateType { + DescriptorSet = 0, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ObjectType { + Unknown = 0, + Instance = 1, + PhysicalDevice = 2, + Device = 3, + Queue = 4, + Semaphore = 5, + CommandBuffer = 6, + Fence = 7, + DeviceMemory = 8, + Buffer = 9, + Image = 10, + Event = 11, + QueryPool = 12, + BufferView = 13, + ImageView = 14, + ShaderModule = 15, + PipelineCache = 16, + PipelineLayout = 17, + RenderPass = 18, + Pipeline = 19, + DescriptorSetLayout = 20, + Sampler = 21, + DescriptorPool = 22, + DescriptorSet = 23, + Framebuffer = 24, + CommandPool = 25, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum PresentModeKHR { + Immediate = 0, + Mailbox = 1, + Fifo = 2, + FifoRelaxed = 3, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ColorSpaceKHR { + SrgbNonlinear = 0, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DebugReportObjectTypeEXT { + Unknown = 0, + Instance = 1, + PhysicalDevice = 2, + Device = 3, + Queue = 4, + Semaphore = 5, + CommandBuffer = 6, + Fence = 7, + DeviceMemory = 8, + Buffer = 9, + Image = 10, + Event = 11, + QueryPool = 12, + BufferView = 13, + ImageView = 14, + ShaderModule = 15, + PipelineCache = 16, + PipelineLayout = 17, + RenderPass = 18, + Pipeline = 19, + DescriptorSetLayout = 20, + Sampler = 21, + DescriptorPool = 22, + DescriptorSet = 23, + Framebuffer = 24, + CommandPool = 25, + SurfaceKhr = 26, + SwapchainKhr = 27, + DebugReportCallback = 28, + DisplayKhr = 29, + DisplayModeKhr = 30, + ObjectTableNvx = 31, + IndirectCommandsLayoutNvx = 32, + ValidationCache = 33, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum RasterizationOrderAMD { + Strict = 0, + Relaxed = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ValidationCheckEXT { + All = 0, + Shaders = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum IndirectCommandsTokenTypeNVX { + Pipeline = 0, + DescriptorSet = 1, + IndexBuffer = 2, + VertexBuffer = 3, + PushConstant = 4, + DrawIndexed = 5, + Draw = 6, + Dispatch = 7, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ObjectEntryTypeNVX { + DescriptorSet = 0, + Pipeline = 1, + IndexBuffer = 2, + VertexBuffer = 3, + PushConstant = 4, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DisplayPowerStateEXT { + Off = 0, + Suspend = 1, + On = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DeviceEventTypeEXT { + DisplayHotplug = 0, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DisplayEventTypeEXT { + FirstPixelOut = 0, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ViewportCoordinateSwizzleNV { + PositiveX = 0, + NegativeX = 1, + PositiveY = 2, + NegativeY = 3, + PositiveZ = 4, + NegativeZ = 5, + PositiveW = 6, + NegativeW = 7, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum DiscardRectangleModeEXT { + Inclusive = 0, + Exclusive = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum PointClippingBehavior { + AllClipPlanes = 0, + UserClipPlanesOnly = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SamplerReductionModeEXT { + WeightedAverage = 0, + Min = 1, + Max = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum TessellationDomainOrigin { + UpperLeft = 0, + LowerLeft = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SamplerYcbcrModelConversion { + RgbIdentity = 0, + YcbcrIdentity = 1, + Ycbcr709 = 2, + Ycbcr601 = 3, + Ycbcr2020 = 4, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum SamplerYcbcrRange { + ItuFull = 0, + ItuNarrow = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ChromaLocation { + CositedEven = 0, + Midpoint = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum BlendOverlapEXT { + Uncorrelated = 0, + Disjoint = 1, + Conjoint = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum CoverageModulationModeNV { + None = 0, + Rgb = 1, + Alpha = 2, + Rgba = 3, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ValidationCacheHeaderVersionEXT { + One = 1, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ShaderInfoTypeAMD { + Statistics = 0, + Binary = 1, + Disassembly = 2, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum QueueGlobalPriorityEXT { + Low = 128, + Medium = 256, + High = 512, + Realtime = 1024, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(C)] +pub enum ConservativeRasterizationModeEXT { + Disabled = 0, + Overestimate = 1, + Underestimate = 2, +} +pub const CULL_MODE_FRONT_BIT: CullModeFlags = CullModeFlags { flags: 0b1 }; +pub const CULL_MODE_BACK_BIT: CullModeFlags = CullModeFlags { flags: 0b10 }; +pub const CULL_MODE_FRONT_AND_BACK: CullModeFlags = CullModeFlags { flags: 0x00000003 }; +vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); +pub const QUEUE_GRAPHICS_BIT: QueueFlags = QueueFlags { flags: 0b1 }; +pub const QUEUE_COMPUTE_BIT: QueueFlags = QueueFlags { flags: 0b10 }; +pub const QUEUE_TRANSFER_BIT: QueueFlags = QueueFlags { flags: 0b100 }; +pub const QUEUE_SPARSE_BINDING_BIT: QueueFlags = QueueFlags { flags: 0b1000 }; +vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); +vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); +pub const MEMORY_PROPERTY_DEVICE_LOCAL_BIT: MemoryPropertyFlags = + MemoryPropertyFlags { flags: 0b1 }; +pub const MEMORY_PROPERTY_HOST_VISIBLE_BIT: MemoryPropertyFlags = + MemoryPropertyFlags { flags: 0b10 }; +pub const MEMORY_PROPERTY_HOST_COHERENT_BIT: MemoryPropertyFlags = + MemoryPropertyFlags { flags: 0b100 }; +pub const MEMORY_PROPERTY_HOST_CACHED_BIT: MemoryPropertyFlags = + MemoryPropertyFlags { flags: 0b1000 }; +pub const MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: MemoryPropertyFlags = + MemoryPropertyFlags { flags: 0b10000 }; +vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); +pub const MEMORY_HEAP_DEVICE_LOCAL_BIT: MemoryHeapFlags = MemoryHeapFlags { flags: 0b1 }; +vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); +pub const ACCESS_INDIRECT_COMMAND_READ_BIT: AccessFlags = AccessFlags { flags: 0b1 }; +pub const ACCESS_INDEX_READ_BIT: AccessFlags = AccessFlags { flags: 0b10 }; +pub const ACCESS_VERTEX_ATTRIBUTE_READ_BIT: AccessFlags = AccessFlags { flags: 0b100 }; +pub const ACCESS_UNIFORM_READ_BIT: AccessFlags = AccessFlags { flags: 0b1000 }; +pub const ACCESS_INPUT_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000 }; +pub const ACCESS_SHADER_READ_BIT: AccessFlags = AccessFlags { flags: 0b100000 }; +pub const ACCESS_SHADER_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b1000000 }; +pub const ACCESS_COLOR_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000000 }; +pub const ACCESS_COLOR_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b100000000 }; +pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { + flags: 0b1000000000, +}; +pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b10000000000, +}; +pub const ACCESS_TRANSFER_READ_BIT: AccessFlags = AccessFlags { + flags: 0b100000000000, +}; +pub const ACCESS_TRANSFER_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b1000000000000, +}; +pub const ACCESS_HOST_READ_BIT: AccessFlags = AccessFlags { + flags: 0b10000000000000, +}; +pub const ACCESS_HOST_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b100000000000000, +}; +pub const ACCESS_MEMORY_READ_BIT: AccessFlags = AccessFlags { + flags: 0b1000000000000000, +}; +pub const ACCESS_MEMORY_WRITE_BIT: AccessFlags = AccessFlags { + flags: 0b10000000000000000, +}; +vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); +pub const BUFFER_USAGE_TRANSFER_SRC_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b1 }; +pub const BUFFER_USAGE_TRANSFER_DST_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b10 }; +pub const BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: BufferUsageFlags = + BufferUsageFlags { flags: 0b100 }; +pub const BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: BufferUsageFlags = + BufferUsageFlags { flags: 0b1000 }; +pub const BUFFER_USAGE_UNIFORM_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b10000 }; +pub const BUFFER_USAGE_STORAGE_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b100000 }; +pub const BUFFER_USAGE_INDEX_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b1000000 }; +pub const BUFFER_USAGE_VERTEX_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b10000000 }; +pub const BUFFER_USAGE_INDIRECT_BUFFER_BIT: BufferUsageFlags = + BufferUsageFlags { flags: 0b100000000 }; +vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); +pub const BUFFER_CREATE_SPARSE_BINDING_BIT: BufferCreateFlags = BufferCreateFlags { flags: 0b1 }; +pub const BUFFER_CREATE_SPARSE_RESIDENCY_BIT: BufferCreateFlags = BufferCreateFlags { flags: 0b10 }; +pub const BUFFER_CREATE_SPARSE_ALIASED_BIT: BufferCreateFlags = BufferCreateFlags { flags: 0b100 }; +vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); +pub const SHADER_STAGE_VERTEX_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b1 }; +pub const SHADER_STAGE_TESSELLATION_CONTROL_BIT: ShaderStageFlags = + ShaderStageFlags { flags: 0b10 }; +pub const SHADER_STAGE_TESSELLATION_EVALUATION_BIT: ShaderStageFlags = + ShaderStageFlags { flags: 0b100 }; +pub const SHADER_STAGE_GEOMETRY_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b1000 }; +pub const SHADER_STAGE_FRAGMENT_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b10000 }; +pub const SHADER_STAGE_COMPUTE_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b100000 }; +pub const SHADER_STAGE_ALL_GRAPHICS: ShaderStageFlags = ShaderStageFlags { flags: 0x0000001F }; +pub const SHADER_STAGE_ALL: ShaderStageFlags = ShaderStageFlags { flags: 0x7FFFFFFF }; +vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); +pub const IMAGE_USAGE_TRANSFER_SRC_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b1 }; +pub const IMAGE_USAGE_TRANSFER_DST_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b10 }; +pub const IMAGE_USAGE_SAMPLED_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b100 }; +pub const IMAGE_USAGE_STORAGE_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b1000 }; +pub const IMAGE_USAGE_COLOR_ATTACHMENT_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b10000 }; +pub const IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: ImageUsageFlags = + ImageUsageFlags { flags: 0b100000 }; +pub const IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: ImageUsageFlags = + ImageUsageFlags { flags: 0b1000000 }; +pub const IMAGE_USAGE_INPUT_ATTACHMENT_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b10000000 }; +vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); +pub const IMAGE_CREATE_SPARSE_BINDING_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b1 }; +pub const IMAGE_CREATE_SPARSE_RESIDENCY_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b10 }; +pub const IMAGE_CREATE_SPARSE_ALIASED_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b100 }; +pub const IMAGE_CREATE_MUTABLE_FORMAT_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b1000 }; +pub const IMAGE_CREATE_CUBE_COMPATIBLE_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b10000 }; +vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); +pub const PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: PipelineCreateFlags = + PipelineCreateFlags { flags: 0b1 }; +pub const PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: PipelineCreateFlags = + PipelineCreateFlags { flags: 0b10 }; +pub const PIPELINE_CREATE_DERIVATIVE_BIT: PipelineCreateFlags = + PipelineCreateFlags { flags: 0b100 }; +vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); +pub const COLOR_COMPONENT_R_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b1 }; +pub const COLOR_COMPONENT_G_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b10 }; +pub const COLOR_COMPONENT_B_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b100 }; +pub const COLOR_COMPONENT_A_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b1000 }; +vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); +pub const FENCE_CREATE_SIGNALED_BIT: FenceCreateFlags = FenceCreateFlags { flags: 0b1 }; +vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); +pub const FORMAT_FEATURE_SAMPLED_IMAGE_BIT: FormatFeatureFlags = FormatFeatureFlags { flags: 0b1 }; +pub const FORMAT_FEATURE_STORAGE_IMAGE_BIT: FormatFeatureFlags = FormatFeatureFlags { flags: 0b10 }; +pub const FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: FormatFeatureFlags = + FormatFeatureFlags { flags: 0b100 }; +pub const FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: FormatFeatureFlags = + FormatFeatureFlags { flags: 0b1000 }; +pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: FormatFeatureFlags = + FormatFeatureFlags { flags: 0b10000 }; +pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: FormatFeatureFlags = + FormatFeatureFlags { flags: 0b100000 }; +pub const FORMAT_FEATURE_VERTEX_BUFFER_BIT: FormatFeatureFlags = + FormatFeatureFlags { flags: 0b1000000 }; +pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: FormatFeatureFlags = + FormatFeatureFlags { flags: 0b10000000 }; +pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: FormatFeatureFlags = + FormatFeatureFlags { flags: 0b100000000 }; +pub const FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: FormatFeatureFlags = FormatFeatureFlags { + flags: 0b1000000000, +}; +pub const FORMAT_FEATURE_BLIT_SRC_BIT: FormatFeatureFlags = FormatFeatureFlags { + flags: 0b10000000000, +}; +pub const FORMAT_FEATURE_BLIT_DST_BIT: FormatFeatureFlags = FormatFeatureFlags { + flags: 0b100000000000, +}; +pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: FormatFeatureFlags = FormatFeatureFlags { + flags: 0b1000000000000, +}; +vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); +pub const QUERY_CONTROL_PRECISE_BIT: QueryControlFlags = QueryControlFlags { flags: 0b1 }; +vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); +pub const QUERY_RESULT_64_BIT: QueryResultFlags = QueryResultFlags { flags: 0b1 }; +pub const QUERY_RESULT_WAIT_BIT: QueryResultFlags = QueryResultFlags { flags: 0b10 }; +pub const QUERY_RESULT_WITH_AVAILABILITY_BIT: QueryResultFlags = QueryResultFlags { flags: 0b100 }; +pub const QUERY_RESULT_PARTIAL_BIT: QueryResultFlags = QueryResultFlags { flags: 0b1000 }; +vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); +pub const COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: CommandBufferUsageFlags = + CommandBufferUsageFlags { flags: 0b1 }; +pub const COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: CommandBufferUsageFlags = + CommandBufferUsageFlags { flags: 0b10 }; +pub const COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: CommandBufferUsageFlags = + CommandBufferUsageFlags { flags: 0b100 }; +vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); +pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b1 }; +pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b10 }; +pub const QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b100 }; +pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b1000 }; +pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b10000 }; +pub const QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b100000 }; +pub const QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b1000000 }; +pub const QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { flags: 0b10000000 }; +pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: + QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b100000000 }; +pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: + QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { + flags: 0b1000000000, +}; +pub const QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = + QueryPipelineStatisticFlags { + flags: 0b10000000000, + }; +vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); +pub const IMAGE_ASPECT_COLOR_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b1 }; +pub const IMAGE_ASPECT_DEPTH_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b10 }; +pub const IMAGE_ASPECT_STENCIL_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b100 }; +pub const IMAGE_ASPECT_METADATA_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b1000 }; +vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); +pub const SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: SparseImageFormatFlags = + SparseImageFormatFlags { flags: 0b1 }; +pub const SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: SparseImageFormatFlags = + SparseImageFormatFlags { flags: 0b10 }; +pub const SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: SparseImageFormatFlags = + SparseImageFormatFlags { flags: 0b100 }; +vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); +pub const SPARSE_MEMORY_BIND_METADATA_BIT: SparseMemoryBindFlags = + SparseMemoryBindFlags { flags: 0b1 }; +vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); +pub const PIPELINE_STAGE_TOP_OF_PIPE_BIT: PipelineStageFlags = PipelineStageFlags { flags: 0b1 }; +pub const PIPELINE_STAGE_DRAW_INDIRECT_BIT: PipelineStageFlags = PipelineStageFlags { flags: 0b10 }; +pub const PIPELINE_STAGE_VERTEX_INPUT_BIT: PipelineStageFlags = PipelineStageFlags { flags: 0b100 }; +pub const PIPELINE_STAGE_VERTEX_SHADER_BIT: PipelineStageFlags = + PipelineStageFlags { flags: 0b1000 }; +pub const PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: PipelineStageFlags = + PipelineStageFlags { flags: 0b10000 }; +pub const PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: PipelineStageFlags = + PipelineStageFlags { flags: 0b100000 }; +pub const PIPELINE_STAGE_GEOMETRY_SHADER_BIT: PipelineStageFlags = + PipelineStageFlags { flags: 0b1000000 }; +pub const PIPELINE_STAGE_FRAGMENT_SHADER_BIT: PipelineStageFlags = + PipelineStageFlags { flags: 0b10000000 }; +pub const PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: PipelineStageFlags = + PipelineStageFlags { flags: 0b100000000 }; +pub const PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b1000000000, +}; +pub const PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b10000000000, +}; +pub const PIPELINE_STAGE_COMPUTE_SHADER_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b100000000000, +}; +pub const PIPELINE_STAGE_TRANSFER_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b1000000000000, +}; +pub const PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b10000000000000, +}; +pub const PIPELINE_STAGE_HOST_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b100000000000000, +}; +pub const PIPELINE_STAGE_ALL_GRAPHICS_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b1000000000000000, +}; +pub const PIPELINE_STAGE_ALL_COMMANDS_BIT: PipelineStageFlags = PipelineStageFlags { + flags: 0b10000000000000000, +}; +vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); +pub const COMMAND_POOL_CREATE_TRANSIENT_BIT: CommandPoolCreateFlags = + CommandPoolCreateFlags { flags: 0b1 }; +pub const COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: CommandPoolCreateFlags = + CommandPoolCreateFlags { flags: 0b10 }; +vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); +pub const COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: CommandPoolResetFlags = + CommandPoolResetFlags { flags: 0b1 }; +vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); +pub const COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: CommandBufferResetFlags = + CommandBufferResetFlags { flags: 0b1 }; +vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); +pub const SAMPLE_COUNT_1_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1 }; +pub const SAMPLE_COUNT_2_BIT: SampleCountFlags = SampleCountFlags { flags: 0b10 }; +pub const SAMPLE_COUNT_4_BIT: SampleCountFlags = SampleCountFlags { flags: 0b100 }; +pub const SAMPLE_COUNT_8_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1000 }; +pub const SAMPLE_COUNT_16_BIT: SampleCountFlags = SampleCountFlags { flags: 0b10000 }; +pub const SAMPLE_COUNT_32_BIT: SampleCountFlags = SampleCountFlags { flags: 0b100000 }; +pub const SAMPLE_COUNT_64_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1000000 }; +vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); +pub const ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: AttachmentDescriptionFlags = + AttachmentDescriptionFlags { flags: 0b1 }; +vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); +pub const STENCIL_FACE_FRONT_BIT: StencilFaceFlags = StencilFaceFlags { flags: 0b1 }; +pub const STENCIL_FACE_BACK_BIT: StencilFaceFlags = StencilFaceFlags { flags: 0b10 }; +pub const STENCIL_FRONT_AND_BACK: StencilFaceFlags = StencilFaceFlags { flags: 0x00000003 }; +vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); +pub const DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: DescriptorPoolCreateFlags = + DescriptorPoolCreateFlags { flags: 0b1 }; +vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); +pub const DEPENDENCY_BY_REGION_BIT: DependencyFlags = DependencyFlags { flags: 0b1 }; +vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); +pub const DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: DisplayPlaneAlphaFlagsKHR = + DisplayPlaneAlphaFlagsKHR { flags: 0b1 }; +pub const DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = + DisplayPlaneAlphaFlagsKHR { flags: 0b10 }; +pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = + DisplayPlaneAlphaFlagsKHR { flags: 0b100 }; +pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: DisplayPlaneAlphaFlagsKHR = + DisplayPlaneAlphaFlagsKHR { flags: 0b1000 }; +vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); +pub const COMPOSITE_ALPHA_OPAQUE_BIT_KHR: CompositeAlphaFlagsKHR = + CompositeAlphaFlagsKHR { flags: 0b1 }; +pub const COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: CompositeAlphaFlagsKHR = + CompositeAlphaFlagsKHR { flags: 0b10 }; +pub const COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: CompositeAlphaFlagsKHR = + CompositeAlphaFlagsKHR { flags: 0b100 }; +pub const COMPOSITE_ALPHA_INHERIT_BIT_KHR: CompositeAlphaFlagsKHR = + CompositeAlphaFlagsKHR { flags: 0b1000 }; +vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); +pub const SURFACE_TRANSFORM_IDENTITY_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b1 }; +pub const SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b10 }; +pub const SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b100 }; +pub const SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b1000 }; +pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b10000 }; +pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b100000 }; +pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b1000000 }; +pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b10000000 }; +pub const SURFACE_TRANSFORM_INHERIT_BIT_KHR: SurfaceTransformFlagsKHR = + SurfaceTransformFlagsKHR { flags: 0b100000000 }; +vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); +pub const DEBUG_REPORT_INFORMATION_BIT_EXT: DebugReportFlagsEXT = + DebugReportFlagsEXT { flags: 0b1 }; +pub const DEBUG_REPORT_WARNING_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT { flags: 0b10 }; +pub const DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: DebugReportFlagsEXT = + DebugReportFlagsEXT { flags: 0b100 }; +pub const DEBUG_REPORT_ERROR_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT { flags: 0b1000 }; +pub const DEBUG_REPORT_DEBUG_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT { flags: 0b10000 }; +vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); +pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV: ExternalMemoryHandleTypeFlagsNV = + ExternalMemoryHandleTypeFlagsNV { flags: 0b1 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV: ExternalMemoryHandleTypeFlagsNV = + ExternalMemoryHandleTypeFlagsNV { flags: 0b10 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV: ExternalMemoryHandleTypeFlagsNV = + ExternalMemoryHandleTypeFlagsNV { flags: 0b100 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV: ExternalMemoryHandleTypeFlagsNV = + ExternalMemoryHandleTypeFlagsNV { flags: 0b1000 }; +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); +pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV: ExternalMemoryFeatureFlagsNV = + ExternalMemoryFeatureFlagsNV { flags: 0b1 }; +pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV: ExternalMemoryFeatureFlagsNV = + ExternalMemoryFeatureFlagsNV { flags: 0b10 }; +pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV: ExternalMemoryFeatureFlagsNV = + ExternalMemoryFeatureFlagsNV { flags: 0b100 }; +vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); +pub const SUBGROUP_FEATURE_BASIC_BIT: SubgroupFeatureFlags = SubgroupFeatureFlags { flags: 0b1 }; +pub const SUBGROUP_FEATURE_VOTE_BIT: SubgroupFeatureFlags = SubgroupFeatureFlags { flags: 0b10 }; +pub const SUBGROUP_FEATURE_ARITHMETIC_BIT: SubgroupFeatureFlags = + SubgroupFeatureFlags { flags: 0b100 }; +pub const SUBGROUP_FEATURE_BALLOT_BIT: SubgroupFeatureFlags = + SubgroupFeatureFlags { flags: 0b1000 }; +pub const SUBGROUP_FEATURE_SHUFFLE_BIT: SubgroupFeatureFlags = + SubgroupFeatureFlags { flags: 0b10000 }; +pub const SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: SubgroupFeatureFlags = + SubgroupFeatureFlags { flags: 0b100000 }; +pub const SUBGROUP_FEATURE_CLUSTERED_BIT: SubgroupFeatureFlags = + SubgroupFeatureFlags { flags: 0b1000000 }; +pub const SUBGROUP_FEATURE_QUAD_BIT: SubgroupFeatureFlags = + SubgroupFeatureFlags { flags: 0b10000000 }; +vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); +pub const INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX: + IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1 }; +pub const INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX: + IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b10 }; +pub const INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX: + IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b100 }; +pub const INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX: + IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1000 }; +vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); +pub const OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX: ObjectEntryUsageFlagsNVX = + ObjectEntryUsageFlagsNVX { flags: 0b1 }; +pub const OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX: ObjectEntryUsageFlagsNVX = + ObjectEntryUsageFlagsNVX { flags: 0b10 }; +vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); +vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); +pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: ExternalMemoryHandleTypeFlags = + ExternalMemoryHandleTypeFlags { flags: 0b1 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: ExternalMemoryHandleTypeFlags = + ExternalMemoryHandleTypeFlags { flags: 0b10 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: ExternalMemoryHandleTypeFlags = + ExternalMemoryHandleTypeFlags { flags: 0b100 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT: ExternalMemoryHandleTypeFlags = + ExternalMemoryHandleTypeFlags { flags: 0b1000 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT: ExternalMemoryHandleTypeFlags = + ExternalMemoryHandleTypeFlags { flags: 0b10000 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT: ExternalMemoryHandleTypeFlags = + ExternalMemoryHandleTypeFlags { flags: 0b100000 }; +pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT: ExternalMemoryHandleTypeFlags = + ExternalMemoryHandleTypeFlags { flags: 0b1000000 }; +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); +pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT: ExternalMemoryFeatureFlags = + ExternalMemoryFeatureFlags { flags: 0b1 }; +pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT: ExternalMemoryFeatureFlags = + ExternalMemoryFeatureFlags { flags: 0b10 }; +pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT: ExternalMemoryFeatureFlags = + ExternalMemoryFeatureFlags { flags: 0b100 }; +vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); +pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: ExternalSemaphoreHandleTypeFlags = + ExternalSemaphoreHandleTypeFlags { flags: 0b1 }; +pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT: ExternalSemaphoreHandleTypeFlags = + ExternalSemaphoreHandleTypeFlags { flags: 0b10 }; +pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: ExternalSemaphoreHandleTypeFlags = + ExternalSemaphoreHandleTypeFlags { flags: 0b100 }; +pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT: ExternalSemaphoreHandleTypeFlags = + ExternalSemaphoreHandleTypeFlags { flags: 0b1000 }; +pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: ExternalSemaphoreHandleTypeFlags = + ExternalSemaphoreHandleTypeFlags { flags: 0b10000 }; +vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); +pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT: ExternalSemaphoreFeatureFlags = + ExternalSemaphoreFeatureFlags { flags: 0b1 }; +pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT: ExternalSemaphoreFeatureFlags = + ExternalSemaphoreFeatureFlags { flags: 0b10 }; +vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); +pub const SEMAPHORE_IMPORT_TEMPORARY_BIT: SemaphoreImportFlags = + SemaphoreImportFlags { flags: 0b1 }; +vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); +pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: ExternalFenceHandleTypeFlags = + ExternalFenceHandleTypeFlags { flags: 0b1 }; +pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT: ExternalFenceHandleTypeFlags = + ExternalFenceHandleTypeFlags { flags: 0b10 }; +pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: ExternalFenceHandleTypeFlags = + ExternalFenceHandleTypeFlags { flags: 0b100 }; +pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: ExternalFenceHandleTypeFlags = + ExternalFenceHandleTypeFlags { flags: 0b1000 }; +vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); +pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT: ExternalFenceFeatureFlags = + ExternalFenceFeatureFlags { flags: 0b1 }; +pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT: ExternalFenceFeatureFlags = + ExternalFenceFeatureFlags { flags: 0b10 }; +vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); +pub const FENCE_IMPORT_TEMPORARY_BIT: FenceImportFlags = FenceImportFlags { flags: 0b1 }; +vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); +pub const SURFACE_COUNTER_VBLANK_EXT: SurfaceCounterFlagsEXT = + SurfaceCounterFlagsEXT { flags: 0b1 }; +vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); +pub const PEER_MEMORY_FEATURE_COPY_SRC_BIT: PeerMemoryFeatureFlags = + PeerMemoryFeatureFlags { flags: 0b1 }; +pub const PEER_MEMORY_FEATURE_COPY_DST_BIT: PeerMemoryFeatureFlags = + PeerMemoryFeatureFlags { flags: 0b10 }; +pub const PEER_MEMORY_FEATURE_GENERIC_SRC_BIT: PeerMemoryFeatureFlags = + PeerMemoryFeatureFlags { flags: 0b100 }; +pub const PEER_MEMORY_FEATURE_GENERIC_DST_BIT: PeerMemoryFeatureFlags = + PeerMemoryFeatureFlags { flags: 0b1000 }; +vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); +pub const MEMORY_ALLOCATE_DEVICE_MASK_BIT: MemoryAllocateFlags = MemoryAllocateFlags { flags: 0b1 }; +vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); +pub const DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR: DeviceGroupPresentModeFlagsKHR = + DeviceGroupPresentModeFlagsKHR { flags: 0b1 }; +pub const DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR: DeviceGroupPresentModeFlagsKHR = + DeviceGroupPresentModeFlagsKHR { flags: 0b10 }; +pub const DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR: DeviceGroupPresentModeFlagsKHR = + DeviceGroupPresentModeFlagsKHR { flags: 0b100 }; +pub const DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR: DeviceGroupPresentModeFlagsKHR = + DeviceGroupPresentModeFlagsKHR { flags: 0b1000 }; +vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); +vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); +vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); +pub const DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = + DebugUtilsMessageSeverityFlagsEXT { flags: 0b1 }; +pub const DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = + DebugUtilsMessageSeverityFlagsEXT { flags: 0b10000 }; +pub const DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = + DebugUtilsMessageSeverityFlagsEXT { flags: 0b100000000 }; +pub const DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = + DebugUtilsMessageSeverityFlagsEXT { + flags: 0b1000000000000, + }; +vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); +pub const DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: DebugUtilsMessageTypeFlagsEXT = + DebugUtilsMessageTypeFlagsEXT { flags: 0b1 }; +pub const DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: DebugUtilsMessageTypeFlagsEXT = + DebugUtilsMessageTypeFlagsEXT { flags: 0b10 }; +pub const DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: DebugUtilsMessageTypeFlagsEXT = + DebugUtilsMessageTypeFlagsEXT { flags: 0b100 }; +vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); +pub const DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT: DescriptorBindingFlagsEXT = + DescriptorBindingFlagsEXT { flags: 0b1 }; +pub const DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: DescriptorBindingFlagsEXT = + DescriptorBindingFlagsEXT { flags: 0b10 }; +pub const DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT: DescriptorBindingFlagsEXT = + DescriptorBindingFlagsEXT { flags: 0b100 }; +pub const DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: DescriptorBindingFlagsEXT = + DescriptorBindingFlagsEXT { flags: 0b1000 }; +vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); +pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; +pub const VK_UUID_SIZE: usize = 16; +pub const VK_LUID_SIZE: usize = 8; +pub const VK_MAX_EXTENSION_NAME_SIZE: usize = 256; +pub const VK_MAX_DESCRIPTION_SIZE: usize = 256; +pub const VK_MAX_MEMORY_TYPES: usize = 32; +pub const VK_MAX_MEMORY_HEAPS: usize = 16; +pub const VK_LOD_CLAMP_NONE: f32 = 1000.00; +pub const VK_REMAINING_MIP_LEVELS: u32 = !0; +pub const VK_REMAINING_ARRAY_LAYERS: u32 = !0; +pub const VK_WHOLE_SIZE: u64 = !0; +pub const VK_ATTACHMENT_UNUSED: u32 = !0; +pub const VK_TRUE: usize = 1; +pub const VK_FALSE: usize = 0; +pub const VK_QUEUE_FAMILY_IGNORED: u32 = !0; +pub const VK_QUEUE_FAMILY_EXTERNAL: u32 = !0 - 1; +pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = !0 - 2; +pub const VK_SUBPASS_EXTERNAL: u32 = !0; +pub const VK_MAX_DEVICE_GROUP_SIZE: usize = 32; +pub struct KhrSurfaceFn { + destroy_surface_khr: extern "system" fn( + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + get_physical_device_surface_support_khr: extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + surface: SurfaceKHR, + p_supported: *const Bool32, + ) -> Result, + get_physical_device_surface_capabilities_khr: + extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_capabilities: *mut SurfaceCapabilitiesKHR, - ) -> Result; - - "vkGetPhysicalDeviceSurfaceFormatsKHR", get_physical_device_surface_formats_khr( + p_surface_capabilities: *const SurfaceCapabilitiesKHR, + ) -> Result, + get_physical_device_surface_formats_khr: + extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_format_count: *mut uint32_t, - p_surface_formats: *mut SurfaceFormatKHR, - ) -> Result; - - "vkGetPhysicalDeviceSurfacePresentModesKHR", get_physical_device_surface_present_modes_khr( + p_surface_format_count: *const uint32_t, + p_surface_formats: *const SurfaceFormatKHR, + ) -> Result, + get_physical_device_surface_present_modes_khr: + extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_present_mode_count: *mut uint32_t, - p_present_modes: *mut PresentModeKHR, - ) -> Result; + p_present_mode_count: *const uint32_t, + p_present_modes: *const PresentModeKHR, + ) -> Result, +} +unsafe impl Send for KhrSurfaceFn {} +unsafe impl Sync for KhrSurfaceFn {} +impl ::std::clone::Clone for KhrSurfaceFn { + fn clone(&self) -> Self { + KhrSurfaceFn { + destroy_surface_khr: self.destroy_surface_khr, + get_physical_device_surface_support_khr: self.get_physical_device_surface_support_khr, + get_physical_device_surface_capabilities_khr: self + .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_formats_khr: self.get_physical_device_surface_formats_khr, + get_physical_device_surface_present_modes_khr: self + .get_physical_device_surface_present_modes_khr, + } } - vk_functions!{ - XlibSurfaceFn, - "vkCreateXlibSurfaceKHR", create_xlib_surface_khr( - instance: Instance, - p_create_info: *const XlibSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - - "vkGetPhysicalDeviceXlibPresentationSupportKHR", get_physical_device_xlib_presentation_support_khr( +} +impl KhrSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSurfaceFn { + destroy_surface_khr: unsafe { + let raw_name = stringify!(vkDestroySurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_formats_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn destroy_surface_khr( + &self, + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_surface_khr)(instance, surface, p_allocator) + } + pub unsafe fn get_physical_device_surface_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + surface: SurfaceKHR, + p_supported: *const Bool32, + ) -> Result { + (self.get_physical_device_surface_support_khr)( + physical_device, + queue_family_index, + surface, + p_supported, + ) + } + pub unsafe fn get_physical_device_surface_capabilities_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *const SurfaceCapabilitiesKHR, + ) -> Result { + (self.get_physical_device_surface_capabilities_khr)( + physical_device, + surface, + p_surface_capabilities, + ) + } + pub unsafe fn get_physical_device_surface_formats_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_format_count: *const uint32_t, + p_surface_formats: *const SurfaceFormatKHR, + ) -> Result { + (self.get_physical_device_surface_formats_khr)( + physical_device, + surface, + p_surface_format_count, + p_surface_formats, + ) + } + pub unsafe fn get_physical_device_surface_present_modes_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_present_mode_count: *const uint32_t, + p_present_modes: *const PresentModeKHR, + ) -> Result { + (self.get_physical_device_surface_present_modes_khr)( + physical_device, + surface, + p_present_mode_count, + p_present_modes, + ) + } +} +pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *const SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *const uint32_t , p_swapchain_images : *const Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : uint64_t , semaphore : Semaphore , fence : Fence , p_image_index : *const uint32_t , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } +unsafe impl Send for KhrSwapchainFn {} +unsafe impl Sync for KhrSwapchainFn {} +impl ::std::clone::Clone for KhrSwapchainFn { + fn clone(&self) -> Self { + KhrSwapchainFn { + create_swapchain_khr: self.create_swapchain_khr, + destroy_swapchain_khr: self.destroy_swapchain_khr, + get_swapchain_images_khr: self.get_swapchain_images_khr, + acquire_next_image_khr: self.acquire_next_image_khr, + queue_present_khr: self.queue_present_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, + acquire_next_image2_khr: self.acquire_next_image2_khr, + } + } +} +impl KhrSwapchainFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSwapchainFn { + create_swapchain_khr: unsafe { + let raw_name = stringify!(vkCreateSwapchainKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_swapchain_khr: unsafe { + let raw_name = stringify!(vkDestroySwapchainKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_swapchain_images_khr: unsafe { + let raw_name = stringify!(vkGetSwapchainImagesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImageKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_present_khr: unsafe { + let raw_name = stringify!(vkQueuePresentKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_present_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_present_rectangles_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image2_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_swapchain_khr( + &self, + device: Device, + p_create_info: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchain: *const SwapchainKHR, + ) -> Result { + (self.create_swapchain_khr)(device, p_create_info, p_allocator, p_swapchain) + } + pub unsafe fn destroy_swapchain_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_swapchain_khr)(device, swapchain, p_allocator) + } + pub unsafe fn get_swapchain_images_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + p_swapchain_image_count: *const uint32_t, + p_swapchain_images: *const Image, + ) -> Result { + (self.get_swapchain_images_khr)( + device, + swapchain, + p_swapchain_image_count, + p_swapchain_images, + ) + } + pub unsafe fn acquire_next_image_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + timeout: uint64_t, + semaphore: Semaphore, + fence: Fence, + p_image_index: *const uint32_t, + ) -> Result { + (self.acquire_next_image_khr)(device, swapchain, timeout, semaphore, fence, p_image_index) + } + pub unsafe fn queue_present_khr( + &self, + queue: Queue, + p_present_info: *const PresentInfoKHR, + ) -> Result { + (self.queue_present_khr)(queue, p_present_info) + } + pub unsafe fn get_device_group_present_capabilities_khr( + &self, + device: Device, + p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + (self.get_device_group_present_capabilities_khr)( + device, + p_device_group_present_capabilities, + ) + } + pub unsafe fn get_device_group_surface_present_modes_khr( + &self, + device: Device, + surface: SurfaceKHR, + p_modes: *const DeviceGroupPresentModeFlagsKHR, + ) -> Result { + (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) + } + pub unsafe fn get_physical_device_present_rectangles_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *const uint32_t, + p_rects: *const Rect2D, + ) -> Result { + (self.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + p_rect_count, + p_rects, + ) + } + pub unsafe fn acquire_next_image2_khr( + &self, + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *const uint32_t, + ) -> Result { + (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) + } +} +pub struct KhrDisplayFn { + get_physical_device_display_properties_khr: + extern "system" fn( physical_device: PhysicalDevice, - queue_family_index: uint32_t, - dpy: *mut Display, - visual_id: VisualID, - ) -> Bool32; - } - vk_functions!{ - DebugMarkerFn, - "vkDebugMarkerSetObjectNameEXT", debug_marker_set_object_name_ext( - device: Device, - p_name_info: *const DebugMarkerObjectNameInfoEXT, - ) -> Result; - "vkCmdDebugMarkerBeginEXT", cmd_debug_marker_begin_ext( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> (); - "vkCmdDebugMarkerEndEXT", cmd_debug_marker_end_ext( - command_buffer: CommandBuffer, - ) -> (); - "vkCmdDebugMarkerInsertEXT", cmd_debug_marker_insert_ext( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> (); - } - vk_functions!{ - DebugReportFn, - "vkCreateDebugReportCallbackEXT", create_debug_report_callback_ext( - instance: Instance, - p_create_info: *const DebugReportCallbackCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_callback: *mut DebugReportCallbackEXT, - ) -> Result; - - "vkDestroyDebugReportCallbackEXT", destroy_debug_report_callback_ext( - instance: Instance, - callback: DebugReportCallbackEXT, - p_allocator: *const AllocationCallbacks, - ) -> (); - - "vkDebugReportMessageEXT", debug_report_message_ext( - instance: Instance, - flags: DebugReportFlagsEXT, - object_type: DebugReportObjectTypeEXT, - object: uint64_t, - location: size_t, - message_code: int32_t, - p_layer_prefix: *const c_char, - p_message: *const c_char, - ) -> (); - } - vk_functions!{ - Win32SurfaceFn, - "vkCreateWin32SurfaceKHR", create_win32_surface_khr( - instance: Instance, - p_create_info: *const Win32SurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - - "vkGetPhysicalDeviceWin32PresentationSupportKHR", get_physical_device_win32_presentation_support_khr( + p_property_count: *const uint32_t, + p_properties: *const DisplayPropertiesKHR, + ) -> Result, + get_physical_device_display_plane_properties_khr: + extern "system" fn( physical_device: PhysicalDevice, - queue_family_index: uint32_t, - ) -> Bool32; - } - vk_functions!{ - MirSurfaceFn, - "vkCreateMirSurfaceKHR", create_mir_surface_khr( - instance: Instance, - p_create_info: *const MirSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - - "vkGetPhysicalDeviceMirPresentationSupportKHR", get_physical_device_mir_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - connection: *mut MirConnection, - ) -> Bool32; - } - vk_functions!{ - XcbSurfaceFn, - "vkCreateXcbSurfaceKHR", create_xcb_surface_khr( - instance: Instance, - p_create_info: *const XcbSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - - "vkGetPhysicalDeviceXcbPresentationSupportKHR", get_physical_device_xcb_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - connection: *mut xcb_connection_t, - visual_id: xcb_visualid_t, - ) -> Bool32; - } - vk_functions!{ - AndroidSurfaceFn, - "vkCreateAndroidSurfaceKHR", create_android_surface_khr( - instance: Instance, - p_create_info: *const AndroidSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - } - vk_functions!{ - WaylandSurfaceFn, - "vkCreateWaylandSurfaceKHR", create_wayland_surface_khr( - instance: Instance, - p_create_info: *const WaylandSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - - "vkGetPhysicalDeviceWaylandPresentationSupportKHR", get_physical_device_wayland_presentation_support_khr( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - display: *mut wl_display, - ) -> Bool32; - } - vk_functions!{ - DisplayFn, - "vkGetPhysicalDeviceDisplayPropertiesKHR", get_physical_device_display_properties_khr( - physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, - p_properties: *mut DisplayPropertiesKHR, - ) -> Result; - - "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", get_physical_device_display_plane_properties_khr( - physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, - p_properties: *mut DisplayPlanePropertiesKHR, - ) -> Result; - - "vkGetDisplayPlaneSupportedDisplaysKHR", get_display_plane_supported_displays_khr( - physical_device: PhysicalDevice, - plane_index: uint32_t, - p_display_count: *mut uint32_t, - p_displays: *mut DisplayKHR, - ) -> Result; - - "vkGetDisplayModePropertiesKHR", get_display_mode_properties_khr( + p_property_count: *const uint32_t, + p_properties: *const DisplayPlanePropertiesKHR, + ) -> Result, + get_display_plane_supported_displays_khr: extern "system" fn( + physical_device: PhysicalDevice, + plane_index: uint32_t, + p_display_count: *const uint32_t, + p_displays: *const DisplayKHR, + ) -> Result, + get_display_mode_properties_khr: + extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *mut uint32_t, - p_properties: *mut DisplayModePropertiesKHR, - ) -> Result; - - "vkCreateDisplayModeKHR", create_display_mode_khr( - physical_device: PhysicalDevice, - display: DisplayKHR, - p_create_info: *const DisplayModeCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_mode: *mut DisplayModeKHR, - ) -> Result; - - "vkGetDisplayPlaneCapabilitiesKHR", get_display_plane_capabilities_khr( + p_property_count: *const uint32_t, + p_properties: *const DisplayModePropertiesKHR, + ) -> Result, + create_display_mode_khr: extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *const DisplayModeKHR, + ) -> Result, + get_display_plane_capabilities_khr: + extern "system" fn( physical_device: PhysicalDevice, mode: DisplayModeKHR, plane_index: uint32_t, - p_capabilities: *mut DisplayPlaneCapabilitiesKHR, - ) -> Result; - - "vkCreateDisplayPlaneSurfaceKHR", create_display_plane_surface_khr( + p_capabilities: *const DisplayPlaneCapabilitiesKHR, + ) -> Result, + create_display_plane_surface_khr: + extern "system" fn( instance: Instance, p_create_info: *const DisplaySurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - } - - vk_functions!{ - IOSSurfaceFn, - "vkCreateIOSSurfaceMVK", create_ios_surface_mvk( - instance: Instance, - p_create_info: *const IOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; - } - - vk_functions!{ - MacOSSurfaceFn, - "vkCreateMacOSSurfaceMVK", create_macos_surface_mvk( - instance: Instance, - p_create_info: *const MacOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result; + p_surface: *const SurfaceKHR, + ) -> Result, +} +unsafe impl Send for KhrDisplayFn {} +unsafe impl Sync for KhrDisplayFn {} +impl ::std::clone::Clone for KhrDisplayFn { + fn clone(&self) -> Self { + KhrDisplayFn { + get_physical_device_display_properties_khr: self + .get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: self + .get_physical_device_display_plane_properties_khr, + get_display_plane_supported_displays_khr: self.get_display_plane_supported_displays_khr, + get_display_mode_properties_khr: self.get_display_mode_properties_khr, + create_display_mode_khr: self.create_display_mode_khr, + get_display_plane_capabilities_khr: self.get_display_plane_capabilities_khr, + create_display_plane_surface_khr: self.create_display_plane_surface_khr, + } + } +} +impl KhrDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDisplayFn { + get_physical_device_display_properties_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_display_plane_properties_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_supported_displays_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_mode_properties_khr: unsafe { + let raw_name = stringify!(vkGetDisplayModePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_display_mode_khr: unsafe { + let raw_name = stringify!(vkCreateDisplayModeKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_display_plane_surface_khr: unsafe { + let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_display_properties_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayPropertiesKHR, + ) -> Result { + (self.get_physical_device_display_properties_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_physical_device_display_plane_properties_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayPlanePropertiesKHR, + ) -> Result { + (self.get_physical_device_display_plane_properties_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_plane_supported_displays_khr( + &self, + physical_device: PhysicalDevice, + plane_index: uint32_t, + p_display_count: *const uint32_t, + p_displays: *const DisplayKHR, + ) -> Result { + (self.get_display_plane_supported_displays_khr)( + physical_device, + plane_index, + p_display_count, + p_displays, + ) + } + pub unsafe fn get_display_mode_properties_khr( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *const uint32_t, + p_properties: *const DisplayModePropertiesKHR, + ) -> Result { + (self.get_display_mode_properties_khr)( + physical_device, + display, + p_property_count, + p_properties, + ) + } + pub unsafe fn create_display_mode_khr( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *const DisplayModeKHR, + ) -> Result { + (self.create_display_mode_khr)(physical_device, display, p_create_info, p_allocator, p_mode) + } + pub unsafe fn get_display_plane_capabilities_khr( + &self, + physical_device: PhysicalDevice, + mode: DisplayModeKHR, + plane_index: uint32_t, + p_capabilities: *const DisplayPlaneCapabilitiesKHR, + ) -> Result { + (self.get_display_plane_capabilities_khr)( + physical_device, + mode, + plane_index, + p_capabilities, + ) + } + pub unsafe fn create_display_plane_surface_khr( + &self, + instance: Instance, + p_create_info: *const DisplaySurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_display_plane_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } +} +pub struct KhrDisplaySwapchainFn { + create_shared_swapchains_khr: extern "system" fn( + device: Device, + swapchain_count: uint32_t, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *const SwapchainKHR, + ) -> Result, +} +unsafe impl Send for KhrDisplaySwapchainFn {} +unsafe impl Sync for KhrDisplaySwapchainFn {} +impl ::std::clone::Clone for KhrDisplaySwapchainFn { + fn clone(&self) -> Self { + KhrDisplaySwapchainFn { + create_shared_swapchains_khr: self.create_shared_swapchains_khr, + } + } +} +impl KhrDisplaySwapchainFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDisplaySwapchainFn { + create_shared_swapchains_khr: unsafe { + let raw_name = stringify!(vkCreateSharedSwapchainsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_shared_swapchains_khr( + &self, + device: Device, + swapchain_count: uint32_t, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *const SwapchainKHR, + ) -> Result { + (self.create_shared_swapchains_khr)( + device, + swapchain_count, + p_create_infos, + p_allocator, + p_swapchains, + ) + } +} +pub struct KhrXlibSurfaceFn { + create_xlib_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_xlib_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + dpy: *const Display, + visual_id: VisualID, + ) -> Bool32, +} +unsafe impl Send for KhrXlibSurfaceFn {} +unsafe impl Sync for KhrXlibSurfaceFn {} +impl ::std::clone::Clone for KhrXlibSurfaceFn { + fn clone(&self) -> Self { + KhrXlibSurfaceFn { + create_xlib_surface_khr: self.create_xlib_surface_khr, + get_physical_device_xlib_presentation_support_khr: self + .get_physical_device_xlib_presentation_support_khr, + } + } +} +impl KhrXlibSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrXlibSurfaceFn { + create_xlib_surface_khr: unsafe { + let raw_name = stringify!(vkCreateXlibSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_xlib_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_xlib_surface_khr( + &self, + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_xlib_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_xlib_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + dpy: *const Display, + visual_id: VisualID, + ) -> Bool32 { + (self.get_physical_device_xlib_presentation_support_khr)( + physical_device, + queue_family_index, + dpy, + visual_id, + ) + } +} +pub struct KhrXcbSurfaceFn { + create_xcb_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_xcb_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *const xcb_connection_t, + visual_id: xcb_visualid_t, + ) -> Bool32, +} +unsafe impl Send for KhrXcbSurfaceFn {} +unsafe impl Sync for KhrXcbSurfaceFn {} +impl ::std::clone::Clone for KhrXcbSurfaceFn { + fn clone(&self) -> Self { + KhrXcbSurfaceFn { + create_xcb_surface_khr: self.create_xcb_surface_khr, + get_physical_device_xcb_presentation_support_khr: self + .get_physical_device_xcb_presentation_support_khr, + } + } +} +impl KhrXcbSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrXcbSurfaceFn { + create_xcb_surface_khr: unsafe { + let raw_name = stringify!(vkCreateXcbSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_xcb_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_xcb_surface_khr( + &self, + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_xcb_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_xcb_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *const xcb_connection_t, + visual_id: xcb_visualid_t, + ) -> Bool32 { + (self.get_physical_device_xcb_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + visual_id, + ) + } +} +pub struct KhrWaylandSurfaceFn { + create_wayland_surface_khr: + extern "system" fn( + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_wayland_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + display: *const wl_display, + ) -> Bool32, +} +unsafe impl Send for KhrWaylandSurfaceFn {} +unsafe impl Sync for KhrWaylandSurfaceFn {} +impl ::std::clone::Clone for KhrWaylandSurfaceFn { + fn clone(&self) -> Self { + KhrWaylandSurfaceFn { + create_wayland_surface_khr: self.create_wayland_surface_khr, + get_physical_device_wayland_presentation_support_khr: self + .get_physical_device_wayland_presentation_support_khr, + } + } +} +impl KhrWaylandSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWaylandSurfaceFn { + create_wayland_surface_khr: unsafe { + let raw_name = stringify!(vkCreateWaylandSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_wayland_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_wayland_surface_khr( + &self, + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_wayland_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_wayland_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + display: *const wl_display, + ) -> Bool32 { + (self.get_physical_device_wayland_presentation_support_khr)( + physical_device, + queue_family_index, + display, + ) + } +} +pub struct KhrMirSurfaceFn { + create_mir_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_mir_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *const MirConnection, + ) -> Bool32, +} +unsafe impl Send for KhrMirSurfaceFn {} +unsafe impl Sync for KhrMirSurfaceFn {} +impl ::std::clone::Clone for KhrMirSurfaceFn { + fn clone(&self) -> Self { + KhrMirSurfaceFn { + create_mir_surface_khr: self.create_mir_surface_khr, + get_physical_device_mir_presentation_support_khr: self + .get_physical_device_mir_presentation_support_khr, + } + } +} +impl KhrMirSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMirSurfaceFn { + create_mir_surface_khr: unsafe { + let raw_name = stringify!(vkCreateMirSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_mir_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_mir_surface_khr( + &self, + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_mir_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_mir_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *const MirConnection, + ) -> Bool32 { + (self.get_physical_device_mir_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + ) + } +} +pub struct KhrAndroidSurfaceFn { + create_android_surface_khr: + extern "system" fn( + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, +} +unsafe impl Send for KhrAndroidSurfaceFn {} +unsafe impl Sync for KhrAndroidSurfaceFn {} +impl ::std::clone::Clone for KhrAndroidSurfaceFn { + fn clone(&self) -> Self { + KhrAndroidSurfaceFn { + create_android_surface_khr: self.create_android_surface_khr, + } + } +} +impl KhrAndroidSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrAndroidSurfaceFn { + create_android_surface_khr: unsafe { + let raw_name = stringify!(vkCreateAndroidSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_android_surface_khr( + &self, + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_android_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } +} +pub struct KhrWin32SurfaceFn { + create_win32_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_win32_presentation_support_khr: + extern "system" fn(physical_device: PhysicalDevice, queue_family_index: uint32_t) -> Bool32, +} +unsafe impl Send for KhrWin32SurfaceFn {} +unsafe impl Sync for KhrWin32SurfaceFn {} +impl ::std::clone::Clone for KhrWin32SurfaceFn { + fn clone(&self) -> Self { + KhrWin32SurfaceFn { + create_win32_surface_khr: self.create_win32_surface_khr, + get_physical_device_win32_presentation_support_khr: self + .get_physical_device_win32_presentation_support_khr, + } + } +} +impl KhrWin32SurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWin32SurfaceFn { + create_win32_surface_khr: unsafe { + let raw_name = stringify!(vkCreateWin32SurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_win32_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_win32_surface_khr( + &self, + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_win32_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_win32_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + ) -> Bool32 { + (self.get_physical_device_win32_presentation_support_khr)( + physical_device, + queue_family_index, + ) + } +} +pub struct AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: extern "system" fn( + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *const c_int, + ) -> Result, + acquire_image_android: extern "system" fn( + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, + ) -> Result, + queue_signal_release_image_android: extern "system" fn( + queue: Queue, + wait_semaphore_count: uint32_t, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *const c_int, + ) -> Result, +} +unsafe impl Send for AndroidNativeBufferFn {} +unsafe impl Sync for AndroidNativeBufferFn {} +impl ::std::clone::Clone for AndroidNativeBufferFn { + fn clone(&self) -> Self { + AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: self.get_swapchain_gralloc_usage_android, + acquire_image_android: self.acquire_image_android, + queue_signal_release_image_android: self.queue_signal_release_image_android, + } + } +} +impl AndroidNativeBufferFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: unsafe { + let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_image_android: unsafe { + let raw_name = stringify!(vkAcquireImageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_signal_release_image_android: unsafe { + let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_swapchain_gralloc_usage_android( + &self, + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *const c_int, + ) -> Result { + (self.get_swapchain_gralloc_usage_android)(device, format, image_usage, gralloc_usage) + } + pub unsafe fn acquire_image_android( + &self, + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, + ) -> Result { + (self.acquire_image_android)(device, image, native_fence_fd, semaphore, fence) + } + pub unsafe fn queue_signal_release_image_android( + &self, + queue: Queue, + wait_semaphore_count: uint32_t, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *const c_int, + ) -> Result { + (self.queue_signal_release_image_android)( + queue, + wait_semaphore_count, + p_wait_semaphores, + image, + p_native_fence_fd, + ) + } +} +pub struct ExtDebugReportFn { + create_debug_report_callback_ext: + extern "system" fn( + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *const DebugReportCallbackEXT, + ) -> Result, + destroy_debug_report_callback_ext: extern "system" fn( + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + debug_report_message_ext: extern "system" fn( + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: uint64_t, + location: size_t, + message_code: int32_t, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> c_void, +} +unsafe impl Send for ExtDebugReportFn {} +unsafe impl Sync for ExtDebugReportFn {} +impl ::std::clone::Clone for ExtDebugReportFn { + fn clone(&self) -> Self { + ExtDebugReportFn { + create_debug_report_callback_ext: self.create_debug_report_callback_ext, + destroy_debug_report_callback_ext: self.destroy_debug_report_callback_ext, + debug_report_message_ext: self.debug_report_message_ext, + } + } +} +impl ExtDebugReportFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugReportFn { + create_debug_report_callback_ext: unsafe { + let raw_name = stringify!(vkCreateDebugReportCallbackEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_debug_report_callback_ext: unsafe { + let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + debug_report_message_ext: unsafe { + let raw_name = stringify!(vkDebugReportMessageEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_debug_report_callback_ext( + &self, + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *const DebugReportCallbackEXT, + ) -> Result { + (self.create_debug_report_callback_ext)(instance, p_create_info, p_allocator, p_callback) + } + pub unsafe fn destroy_debug_report_callback_ext( + &self, + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_debug_report_callback_ext)(instance, callback, p_allocator) + } + pub unsafe fn debug_report_message_ext( + &self, + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: uint64_t, + location: size_t, + message_code: int32_t, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> c_void { + (self.debug_report_message_ext)( + instance, + flags, + object_type, + object, + location, + message_code, + p_layer_prefix, + p_message, + ) + } +} +pub struct ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: + extern "system" fn(device: Device, p_tag_info: *const DebugMarkerObjectTagInfoEXT) + -> Result, + debug_marker_set_object_name_ext: + extern "system" fn(device: Device, p_name_info: *const DebugMarkerObjectNameInfoEXT) + -> Result, + cmd_debug_marker_begin_ext: extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void, + cmd_debug_marker_end_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, + cmd_debug_marker_insert_ext: extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void, +} +unsafe impl Send for ExtDebugMarkerFn {} +unsafe impl Sync for ExtDebugMarkerFn {} +impl ::std::clone::Clone for ExtDebugMarkerFn { + fn clone(&self) -> Self { + ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: self.debug_marker_set_object_tag_ext, + debug_marker_set_object_name_ext: self.debug_marker_set_object_name_ext, + cmd_debug_marker_begin_ext: self.cmd_debug_marker_begin_ext, + cmd_debug_marker_end_ext: self.cmd_debug_marker_end_ext, + cmd_debug_marker_insert_ext: self.cmd_debug_marker_insert_ext, + } + } +} +impl ExtDebugMarkerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: unsafe { + let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + debug_marker_set_object_name_ext: unsafe { + let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_begin_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_end_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerEndEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_insert_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn debug_marker_set_object_tag_ext( + &self, + device: Device, + p_tag_info: *const DebugMarkerObjectTagInfoEXT, + ) -> Result { + (self.debug_marker_set_object_tag_ext)(device, p_tag_info) + } + pub unsafe fn debug_marker_set_object_name_ext( + &self, + device: Device, + p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result { + (self.debug_marker_set_object_name_ext)(device, p_name_info) + } + pub unsafe fn cmd_debug_marker_begin_ext( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + (self.cmd_debug_marker_begin_ext)(command_buffer, p_marker_info) + } + pub unsafe fn cmd_debug_marker_end_ext(&self, command_buffer: CommandBuffer) -> c_void { + (self.cmd_debug_marker_end_ext)(command_buffer) + } + pub unsafe fn cmd_debug_marker_insert_ext( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + (self.cmd_debug_marker_insert_ext)(command_buffer, p_marker_info) + } +} +pub struct AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + cmd_draw_indexed_indirect_count_amd: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, +} +unsafe impl Send for AmdDrawIndirectCountFn {} +unsafe impl Sync for AmdDrawIndirectCountFn {} +impl ::std::clone::Clone for AmdDrawIndirectCountFn { + fn clone(&self) -> Self { + AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: self.cmd_draw_indirect_count_amd, + cmd_draw_indexed_indirect_count_amd: self.cmd_draw_indexed_indirect_count_amd, + } + } +} +impl AmdDrawIndirectCountFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: unsafe { + let raw_name = stringify!(vkCmdDrawIndirectCountAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed_indirect_count_amd: unsafe { + let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_draw_indirect_count_amd( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indirect_count_amd)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + pub unsafe fn cmd_draw_indexed_indirect_count_amd( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indexed_indirect_count_amd)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } +} +pub struct AmdShaderInfoFn { + get_shader_info_amd: extern "system" fn( + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *const size_t, + p_info: *const c_void, + ) -> Result, +} +unsafe impl Send for AmdShaderInfoFn {} +unsafe impl Sync for AmdShaderInfoFn {} +impl ::std::clone::Clone for AmdShaderInfoFn { + fn clone(&self) -> Self { + AmdShaderInfoFn { + get_shader_info_amd: self.get_shader_info_amd, + } + } +} +impl AmdShaderInfoFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderInfoFn { + get_shader_info_amd: unsafe { + let raw_name = stringify!(vkGetShaderInfoAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_shader_info_amd( + &self, + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *const size_t, + p_info: *const c_void, + ) -> Result { + (self.get_shader_info_amd)( + device, + pipeline, + shader_stage, + info_type, + p_info_size, + p_info, + ) + } +} +pub struct NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv : extern "system" fn ( physical_device : PhysicalDevice , format : Format , ty : ImageType , tiling : ImageTiling , usage : ImageUsageFlags , flags : ImageCreateFlags , external_handle_type : ExternalMemoryHandleTypeFlagsNV , p_external_image_format_properties : *const ExternalImageFormatPropertiesNV , ) -> Result , } +unsafe impl Send for NvExternalMemoryCapabilitiesFn {} +unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} +impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { + fn clone(&self) -> Self { + NvExternalMemoryCapabilitiesFn { + get_physical_device_external_image_format_properties_nv: self + .get_physical_device_external_image_format_properties_nv, + } + } +} +impl NvExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryCapabilitiesFn { + get_physical_device_external_image_format_properties_nv: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_external_image_format_properties_nv( + &self, + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + external_handle_type: ExternalMemoryHandleTypeFlagsNV, + p_external_image_format_properties: *const ExternalImageFormatPropertiesNV, + ) -> Result { + (self.get_physical_device_external_image_format_properties_nv)( + physical_device, + format, + ty, + tiling, + usage, + flags, + external_handle_type, + p_external_image_format_properties, + ) + } +} +pub struct NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: extern "system" fn( + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *const HANDLE, + ) -> Result, +} +unsafe impl Send for NvExternalMemoryWin32Fn {} +unsafe impl Sync for NvExternalMemoryWin32Fn {} +impl ::std::clone::Clone for NvExternalMemoryWin32Fn { + fn clone(&self) -> Self { + NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: self.get_memory_win32_handle_nv, + } + } +} +impl NvExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandleNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_win32_handle_nv( + &self, + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *const HANDLE, + ) -> Result { + (self.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle) + } +} +pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } +unsafe impl Send for KhrDeviceGroupFn {} +unsafe impl Sync for KhrDeviceGroupFn {} +impl ::std::clone::Clone for KhrDeviceGroupFn { + fn clone(&self) -> Self { + KhrDeviceGroupFn { + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, + acquire_next_image2_khr: self.acquire_next_image2_khr, + } + } +} +impl KhrDeviceGroupFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDeviceGroupFn { + get_device_group_present_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_present_rectangles_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image2_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_device_group_present_capabilities_khr( + &self, + device: Device, + p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + (self.get_device_group_present_capabilities_khr)( + device, + p_device_group_present_capabilities, + ) + } + pub unsafe fn get_device_group_surface_present_modes_khr( + &self, + device: Device, + surface: SurfaceKHR, + p_modes: *const DeviceGroupPresentModeFlagsKHR, + ) -> Result { + (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) + } + pub unsafe fn get_physical_device_present_rectangles_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *const uint32_t, + p_rects: *const Rect2D, + ) -> Result { + (self.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + p_rect_count, + p_rects, + ) + } + pub unsafe fn acquire_next_image2_khr( + &self, + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *const uint32_t, + ) -> Result { + (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) + } +} +pub struct NnViSurfaceFn { + create_vi_surface_nn: extern "system" fn( + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, +} +unsafe impl Send for NnViSurfaceFn {} +unsafe impl Sync for NnViSurfaceFn {} +impl ::std::clone::Clone for NnViSurfaceFn { + fn clone(&self) -> Self { + NnViSurfaceFn { + create_vi_surface_nn: self.create_vi_surface_nn, + } + } +} +impl NnViSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NnViSurfaceFn { + create_vi_surface_nn: unsafe { + let raw_name = stringify!(vkCreateViSurfaceNN); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_vi_surface_nn( + &self, + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_vi_surface_nn)(instance, p_create_info, p_allocator, p_surface) + } +} +pub struct KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: + extern "system" fn( + device: Device, + p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + p_handle: *const HANDLE, + ) -> Result, + get_memory_win32_handle_properties_khr: + extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + handle: HANDLE, + p_memory_win32_handle_properties: *const MemoryWin32HandlePropertiesKHR, + ) -> Result, +} +unsafe impl Send for KhrExternalMemoryWin32Fn {} +unsafe impl Sync for KhrExternalMemoryWin32Fn {} +impl ::std::clone::Clone for KhrExternalMemoryWin32Fn { + fn clone(&self) -> Self { + KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: self.get_memory_win32_handle_khr, + get_memory_win32_handle_properties_khr: self.get_memory_win32_handle_properties_khr, + } + } +} +impl KhrExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_win32_handle_properties_khr: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_win32_handle_khr( + &self, + device: Device, + p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + p_handle: *const HANDLE, + ) -> Result { + (self.get_memory_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } + pub unsafe fn get_memory_win32_handle_properties_khr( + &self, + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + handle: HANDLE, + p_memory_win32_handle_properties: *const MemoryWin32HandlePropertiesKHR, + ) -> Result { + (self.get_memory_win32_handle_properties_khr)( + device, + handle_type, + handle, + p_memory_win32_handle_properties, + ) + } +} +pub struct KhrExternalMemoryFdFn { + get_memory_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result, + get_memory_fd_properties_khr: + extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + fd: c_int, + p_memory_fd_properties: *const MemoryFdPropertiesKHR, + ) -> Result, +} +unsafe impl Send for KhrExternalMemoryFdFn {} +unsafe impl Sync for KhrExternalMemoryFdFn {} +impl ::std::clone::Clone for KhrExternalMemoryFdFn { + fn clone(&self) -> Self { + KhrExternalMemoryFdFn { + get_memory_fd_khr: self.get_memory_fd_khr, + get_memory_fd_properties_khr: self.get_memory_fd_properties_khr, + } + } +} +impl KhrExternalMemoryFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryFdFn { + get_memory_fd_khr: unsafe { + let raw_name = stringify!(vkGetMemoryFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_fd_properties_khr: unsafe { + let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_fd_khr( + &self, + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result { + (self.get_memory_fd_khr)(device, p_get_fd_info, p_fd) + } + pub unsafe fn get_memory_fd_properties_khr( + &self, + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + fd: c_int, + p_memory_fd_properties: *const MemoryFdPropertiesKHR, + ) -> Result { + (self.get_memory_fd_properties_khr)(device, handle_type, fd, p_memory_fd_properties) + } +} +pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , } +unsafe impl Send for KhrExternalSemaphoreWin32Fn {} +unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} +impl ::std::clone::Clone for KhrExternalSemaphoreWin32Fn { + fn clone(&self) -> Self { + KhrExternalSemaphoreWin32Fn { + import_semaphore_win32_handle_khr: self.import_semaphore_win32_handle_khr, + get_semaphore_win32_handle_khr: self.get_semaphore_win32_handle_khr, + } + } +} +impl KhrExternalSemaphoreWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreWin32Fn { + import_semaphore_win32_handle_khr: unsafe { + let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_semaphore_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_semaphore_win32_handle_khr( + &self, + device: Device, + p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, + ) -> Result { + (self.import_semaphore_win32_handle_khr)(device, p_import_semaphore_win32_handle_info) + } + pub unsafe fn get_semaphore_win32_handle_khr( + &self, + device: Device, + p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + p_handle: *const HANDLE, + ) -> Result { + (self.get_semaphore_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } +} +pub struct KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: + extern "system" fn( + device: Device, + p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result, + get_semaphore_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result, +} +unsafe impl Send for KhrExternalSemaphoreFdFn {} +unsafe impl Sync for KhrExternalSemaphoreFdFn {} +impl ::std::clone::Clone for KhrExternalSemaphoreFdFn { + fn clone(&self) -> Self { + KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: self.import_semaphore_fd_khr, + get_semaphore_fd_khr: self.get_semaphore_fd_khr, + } + } +} +impl KhrExternalSemaphoreFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: unsafe { + let raw_name = stringify!(vkImportSemaphoreFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_semaphore_fd_khr: unsafe { + let raw_name = stringify!(vkGetSemaphoreFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_semaphore_fd_khr( + &self, + device: Device, + p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result { + (self.import_semaphore_fd_khr)(device, p_import_semaphore_fd_info) + } + pub unsafe fn get_semaphore_fd_khr( + &self, + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result { + (self.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd) + } +} +pub struct KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: uint32_t, + descriptor_write_count: uint32_t, + p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void, + cmd_push_descriptor_set_with_template_khr: + extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void, +} +unsafe impl Send for KhrPushDescriptorFn {} +unsafe impl Sync for KhrPushDescriptorFn {} +impl ::std::clone::Clone for KhrPushDescriptorFn { + fn clone(&self) -> Self { + KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, + } + } +} +impl KhrPushDescriptorFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_push_descriptor_set_with_template_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_push_descriptor_set_khr( + &self, + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: uint32_t, + descriptor_write_count: uint32_t, + p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void { + (self.cmd_push_descriptor_set_khr)( + command_buffer, + pipeline_bind_point, + layout, + set, + descriptor_write_count, + p_descriptor_writes, + ) + } + pub unsafe fn cmd_push_descriptor_set_with_template_khr( + &self, + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void { + (self.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ) + } +} +pub struct KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: + extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void, +} +unsafe impl Send for KhrDescriptorUpdateTemplateFn {} +unsafe impl Sync for KhrDescriptorUpdateTemplateFn {} +impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { + fn clone(&self) -> Self { + KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, + } + } +} +impl KhrDescriptorUpdateTemplateFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_push_descriptor_set_with_template_khr( + &self, + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void { + (self.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ) + } +} +pub struct NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: + extern "system" fn( + command_buffer: CommandBuffer, + p_process_commands_info: *const CmdProcessCommandsInfoNVX, + ) -> c_void, + cmd_reserve_space_for_commands_nvx: + extern "system" fn( + command_buffer: CommandBuffer, + p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, + ) -> c_void, + create_indirect_commands_layout_nvx: + extern "system" fn( + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *const IndirectCommandsLayoutNVX, + ) -> Result, + destroy_indirect_commands_layout_nvx: + extern "system" fn( + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_object_table_nvx: extern "system" fn( + device: Device, + p_create_info: *const ObjectTableCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_object_table: *const ObjectTableNVX, + ) -> Result, + destroy_object_table_nvx: extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + register_objects_nvx: extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + pp_object_table_entries: *const ObjectTableEntryNVX, + p_object_indices: *const uint32_t, + ) -> Result, + unregister_objects_nvx: extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + p_object_entry_types: *const ObjectEntryTypeNVX, + p_object_indices: *const uint32_t, + ) -> Result, + get_physical_device_generated_commands_properties_nvx: + extern "system" fn( + physical_device: PhysicalDevice, + p_features: *const DeviceGeneratedCommandsFeaturesNVX, + p_limits: *const DeviceGeneratedCommandsLimitsNVX, + ) -> c_void, +} +unsafe impl Send for NvxDeviceGeneratedCommandsFn {} +unsafe impl Sync for NvxDeviceGeneratedCommandsFn {} +impl ::std::clone::Clone for NvxDeviceGeneratedCommandsFn { + fn clone(&self) -> Self { + NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: self.cmd_process_commands_nvx, + cmd_reserve_space_for_commands_nvx: self.cmd_reserve_space_for_commands_nvx, + create_indirect_commands_layout_nvx: self.create_indirect_commands_layout_nvx, + destroy_indirect_commands_layout_nvx: self.destroy_indirect_commands_layout_nvx, + create_object_table_nvx: self.create_object_table_nvx, + destroy_object_table_nvx: self.destroy_object_table_nvx, + register_objects_nvx: self.register_objects_nvx, + unregister_objects_nvx: self.unregister_objects_nvx, + get_physical_device_generated_commands_properties_nvx: self + .get_physical_device_generated_commands_properties_nvx, + } + } +} +impl NvxDeviceGeneratedCommandsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: unsafe { + let raw_name = stringify!(vkCmdProcessCommandsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_reserve_space_for_commands_nvx: unsafe { + let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_indirect_commands_layout_nvx: unsafe { + let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_indirect_commands_layout_nvx: unsafe { + let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_object_table_nvx: unsafe { + let raw_name = stringify!(vkCreateObjectTableNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_object_table_nvx: unsafe { + let raw_name = stringify!(vkDestroyObjectTableNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_objects_nvx: unsafe { + let raw_name = stringify!(vkRegisterObjectsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + unregister_objects_nvx: unsafe { + let raw_name = stringify!(vkUnregisterObjectsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_generated_commands_properties_nvx: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_process_commands_nvx( + &self, + command_buffer: CommandBuffer, + p_process_commands_info: *const CmdProcessCommandsInfoNVX, + ) -> c_void { + (self.cmd_process_commands_nvx)(command_buffer, p_process_commands_info) + } + pub unsafe fn cmd_reserve_space_for_commands_nvx( + &self, + command_buffer: CommandBuffer, + p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, + ) -> c_void { + (self.cmd_reserve_space_for_commands_nvx)(command_buffer, p_reserve_space_info) + } + pub unsafe fn create_indirect_commands_layout_nvx( + &self, + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *const IndirectCommandsLayoutNVX, + ) -> Result { + (self.create_indirect_commands_layout_nvx)( + device, + p_create_info, + p_allocator, + p_indirect_commands_layout, + ) + } + pub unsafe fn destroy_indirect_commands_layout_nvx( + &self, + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_indirect_commands_layout_nvx)(device, indirect_commands_layout, p_allocator) + } + pub unsafe fn create_object_table_nvx( + &self, + device: Device, + p_create_info: *const ObjectTableCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_object_table: *const ObjectTableNVX, + ) -> Result { + (self.create_object_table_nvx)(device, p_create_info, p_allocator, p_object_table) + } + pub unsafe fn destroy_object_table_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_object_table_nvx)(device, object_table, p_allocator) + } + pub unsafe fn register_objects_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + pp_object_table_entries: *const ObjectTableEntryNVX, + p_object_indices: *const uint32_t, + ) -> Result { + (self.register_objects_nvx)( + device, + object_table, + object_count, + pp_object_table_entries, + p_object_indices, + ) + } + pub unsafe fn unregister_objects_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + p_object_entry_types: *const ObjectEntryTypeNVX, + p_object_indices: *const uint32_t, + ) -> Result { + (self.unregister_objects_nvx)( + device, + object_table, + object_count, + p_object_entry_types, + p_object_indices, + ) + } + pub unsafe fn get_physical_device_generated_commands_properties_nvx( + &self, + physical_device: PhysicalDevice, + p_features: *const DeviceGeneratedCommandsFeaturesNVX, + p_limits: *const DeviceGeneratedCommandsLimitsNVX, + ) -> c_void { + (self.get_physical_device_generated_commands_properties_nvx)( + physical_device, + p_features, + p_limits, + ) + } +} +pub struct NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: + extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: uint32_t, + viewport_count: uint32_t, + p_viewport_w_scalings: *const ViewportWScalingNV, + ) -> c_void, +} +unsafe impl Send for NvClipSpaceWScalingFn {} +unsafe impl Sync for NvClipSpaceWScalingFn {} +impl ::std::clone::Clone for NvClipSpaceWScalingFn { + fn clone(&self) -> Self { + NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: self.cmd_set_viewport_w_scaling_nv, + } + } +} +impl NvClipSpaceWScalingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: unsafe { + let raw_name = stringify!(vkCmdSetViewportWScalingNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_set_viewport_w_scaling_nv( + &self, + command_buffer: CommandBuffer, + first_viewport: uint32_t, + viewport_count: uint32_t, + p_viewport_w_scalings: *const ViewportWScalingNV, + ) -> c_void { + (self.cmd_set_viewport_w_scaling_nv)( + command_buffer, + first_viewport, + viewport_count, + p_viewport_w_scalings, + ) + } +} +pub struct ExtDirectModeDisplayFn { + release_display_ext: + extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result, +} +unsafe impl Send for ExtDirectModeDisplayFn {} +unsafe impl Sync for ExtDirectModeDisplayFn {} +impl ::std::clone::Clone for ExtDirectModeDisplayFn { + fn clone(&self) -> Self { + ExtDirectModeDisplayFn { + release_display_ext: self.release_display_ext, + } + } +} +impl ExtDirectModeDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDirectModeDisplayFn { + release_display_ext: unsafe { + let raw_name = stringify!(vkReleaseDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn release_display_ext( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + ) -> Result { + (self.release_display_ext)(physical_device, display) + } +} +pub struct ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: extern "system" fn( + physical_device: PhysicalDevice, + dpy: *const Display, + display: DisplayKHR, + ) -> Result, + get_rand_r_output_display_ext: extern "system" fn( + physical_device: PhysicalDevice, + dpy: *const Display, + rr_output: RROutput, + p_display: *const DisplayKHR, + ) -> Result, +} +unsafe impl Send for ExtAcquireXlibDisplayFn {} +unsafe impl Sync for ExtAcquireXlibDisplayFn {} +impl ::std::clone::Clone for ExtAcquireXlibDisplayFn { + fn clone(&self) -> Self { + ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: self.acquire_xlib_display_ext, + get_rand_r_output_display_ext: self.get_rand_r_output_display_ext, + } + } +} +impl ExtAcquireXlibDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: unsafe { + let raw_name = stringify!(vkAcquireXlibDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_rand_r_output_display_ext: unsafe { + let raw_name = stringify!(vkGetRandROutputDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn acquire_xlib_display_ext( + &self, + physical_device: PhysicalDevice, + dpy: *const Display, + display: DisplayKHR, + ) -> Result { + (self.acquire_xlib_display_ext)(physical_device, dpy, display) + } + pub unsafe fn get_rand_r_output_display_ext( + &self, + physical_device: PhysicalDevice, + dpy: *const Display, + rr_output: RROutput, + p_display: *const DisplayKHR, + ) -> Result { + (self.get_rand_r_output_display_ext)(physical_device, dpy, rr_output, p_display) + } +} +pub struct ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: + extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *const SurfaceCapabilities2EXT, + ) -> Result, +} +unsafe impl Send for ExtDisplaySurfaceCounterFn {} +unsafe impl Sync for ExtDisplaySurfaceCounterFn {} +impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { + fn clone(&self) -> Self { + ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: self + .get_physical_device_surface_capabilities2_ext, + } + } +} +impl ExtDisplaySurfaceCounterFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_surface_capabilities2_ext( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *const SurfaceCapabilities2EXT, + ) -> Result { + (self.get_physical_device_surface_capabilities2_ext)( + physical_device, + surface, + p_surface_capabilities, + ) + } +} +pub struct ExtDisplayControlFn { + display_power_control_ext: extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result, + register_device_event_ext: extern "system" fn( + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result, + register_display_event_ext: + extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_event_info: *const DisplayEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result, + get_swapchain_counter_ext: extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *const uint64_t, + ) -> Result, +} +unsafe impl Send for ExtDisplayControlFn {} +unsafe impl Sync for ExtDisplayControlFn {} +impl ::std::clone::Clone for ExtDisplayControlFn { + fn clone(&self) -> Self { + ExtDisplayControlFn { + display_power_control_ext: self.display_power_control_ext, + register_device_event_ext: self.register_device_event_ext, + register_display_event_ext: self.register_display_event_ext, + get_swapchain_counter_ext: self.get_swapchain_counter_ext, + } + } +} +impl ExtDisplayControlFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDisplayControlFn { + display_power_control_ext: unsafe { + let raw_name = stringify!(vkDisplayPowerControlEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_device_event_ext: unsafe { + let raw_name = stringify!(vkRegisterDeviceEventEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_display_event_ext: unsafe { + let raw_name = stringify!(vkRegisterDisplayEventEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_swapchain_counter_ext: unsafe { + let raw_name = stringify!(vkGetSwapchainCounterEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn display_power_control_ext( + &self, + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result { + (self.display_power_control_ext)(device, display, p_display_power_info) + } + pub unsafe fn register_device_event_ext( + &self, + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result { + (self.register_device_event_ext)(device, p_device_event_info, p_allocator, p_fence) + } + pub unsafe fn register_display_event_ext( + &self, + device: Device, + display: DisplayKHR, + p_display_event_info: *const DisplayEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result { + (self.register_display_event_ext)( + device, + display, + p_display_event_info, + p_allocator, + p_fence, + ) + } + pub unsafe fn get_swapchain_counter_ext( + &self, + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *const uint64_t, + ) -> Result { + (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value) + } +} +pub struct GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: + extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_display_timing_properties: *const RefreshCycleDurationGOOGLE, + ) -> Result, + get_past_presentation_timing_google: + extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_presentation_timing_count: *const uint32_t, + p_presentation_timings: *const PastPresentationTimingGOOGLE, + ) -> Result, +} +unsafe impl Send for GoogleDisplayTimingFn {} +unsafe impl Sync for GoogleDisplayTimingFn {} +impl ::std::clone::Clone for GoogleDisplayTimingFn { + fn clone(&self) -> Self { + GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: self.get_refresh_cycle_duration_google, + get_past_presentation_timing_google: self.get_past_presentation_timing_google, + } + } +} +impl GoogleDisplayTimingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: unsafe { + let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_past_presentation_timing_google: unsafe { + let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_refresh_cycle_duration_google( + &self, + device: Device, + swapchain: SwapchainKHR, + p_display_timing_properties: *const RefreshCycleDurationGOOGLE, + ) -> Result { + (self.get_refresh_cycle_duration_google)(device, swapchain, p_display_timing_properties) + } + pub unsafe fn get_past_presentation_timing_google( + &self, + device: Device, + swapchain: SwapchainKHR, + p_presentation_timing_count: *const uint32_t, + p_presentation_timings: *const PastPresentationTimingGOOGLE, + ) -> Result { + (self.get_past_presentation_timing_google)( + device, + swapchain, + p_presentation_timing_count, + p_presentation_timings, + ) + } +} +pub struct ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: extern "system" fn( + command_buffer: CommandBuffer, + first_discard_rectangle: uint32_t, + discard_rectangle_count: uint32_t, + p_discard_rectangles: *const Rect2D, + ) -> c_void, +} +unsafe impl Send for ExtDiscardRectanglesFn {} +unsafe impl Sync for ExtDiscardRectanglesFn {} +impl ::std::clone::Clone for ExtDiscardRectanglesFn { + fn clone(&self) -> Self { + ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: self.cmd_set_discard_rectangle_ext, + } + } +} +impl ExtDiscardRectanglesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: unsafe { + let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_set_discard_rectangle_ext( + &self, + command_buffer: CommandBuffer, + first_discard_rectangle: uint32_t, + discard_rectangle_count: uint32_t, + p_discard_rectangles: *const Rect2D, + ) -> c_void { + (self.cmd_set_discard_rectangle_ext)( + command_buffer, + first_discard_rectangle, + discard_rectangle_count, + p_discard_rectangles, + ) + } +} +pub struct ExtHdrMetadataFn { + set_hdr_metadata_ext: extern "system" fn( + device: Device, + swapchain_count: uint32_t, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, + ) -> c_void, +} +unsafe impl Send for ExtHdrMetadataFn {} +unsafe impl Sync for ExtHdrMetadataFn {} +impl ::std::clone::Clone for ExtHdrMetadataFn { + fn clone(&self) -> Self { + ExtHdrMetadataFn { + set_hdr_metadata_ext: self.set_hdr_metadata_ext, + } + } +} +impl ExtHdrMetadataFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtHdrMetadataFn { + set_hdr_metadata_ext: unsafe { + let raw_name = stringify!(vkSetHdrMetadataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn set_hdr_metadata_ext( + &self, + device: Device, + swapchain_count: uint32_t, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, + ) -> c_void { + (self.set_hdr_metadata_ext)(device, swapchain_count, p_swapchains, p_metadata) + } +} +pub struct KhrSharedPresentableImageFn { + get_swapchain_status_khr: extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, +} +unsafe impl Send for KhrSharedPresentableImageFn {} +unsafe impl Sync for KhrSharedPresentableImageFn {} +impl ::std::clone::Clone for KhrSharedPresentableImageFn { + fn clone(&self) -> Self { + KhrSharedPresentableImageFn { + get_swapchain_status_khr: self.get_swapchain_status_khr, + } + } +} +impl KhrSharedPresentableImageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSharedPresentableImageFn { + get_swapchain_status_khr: unsafe { + let raw_name = stringify!(vkGetSwapchainStatusKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_swapchain_status_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + ) -> Result { + (self.get_swapchain_status_khr)(device, swapchain) + } +} +pub struct KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: + extern "system" fn( + device: Device, + p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, + ) -> Result, + get_fence_win32_handle_khr: + extern "system" fn( + device: Device, + p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + p_handle: *const HANDLE, + ) -> Result, +} +unsafe impl Send for KhrExternalFenceWin32Fn {} +unsafe impl Sync for KhrExternalFenceWin32Fn {} +impl ::std::clone::Clone for KhrExternalFenceWin32Fn { + fn clone(&self) -> Self { + KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: self.import_fence_win32_handle_khr, + get_fence_win32_handle_khr: self.get_fence_win32_handle_khr, + } + } +} +impl KhrExternalFenceWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: unsafe { + let raw_name = stringify!(vkImportFenceWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_fence_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetFenceWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_fence_win32_handle_khr( + &self, + device: Device, + p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, + ) -> Result { + (self.import_fence_win32_handle_khr)(device, p_import_fence_win32_handle_info) + } + pub unsafe fn get_fence_win32_handle_khr( + &self, + device: Device, + p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + p_handle: *const HANDLE, + ) -> Result { + (self.get_fence_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } +} +pub struct KhrExternalFenceFdFn { + import_fence_fd_khr: + extern "system" fn(device: Device, p_import_fence_fd_info: *const ImportFenceFdInfoKHR) + -> Result, + get_fence_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result, +} +unsafe impl Send for KhrExternalFenceFdFn {} +unsafe impl Sync for KhrExternalFenceFdFn {} +impl ::std::clone::Clone for KhrExternalFenceFdFn { + fn clone(&self) -> Self { + KhrExternalFenceFdFn { + import_fence_fd_khr: self.import_fence_fd_khr, + get_fence_fd_khr: self.get_fence_fd_khr, + } + } +} +impl KhrExternalFenceFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceFdFn { + import_fence_fd_khr: unsafe { + let raw_name = stringify!(vkImportFenceFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_fence_fd_khr: unsafe { + let raw_name = stringify!(vkGetFenceFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_fence_fd_khr( + &self, + device: Device, + p_import_fence_fd_info: *const ImportFenceFdInfoKHR, + ) -> Result { + (self.import_fence_fd_khr)(device, p_import_fence_fd_info) + } + pub unsafe fn get_fence_fd_khr( + &self, + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result { + (self.get_fence_fd_khr)(device, p_get_fd_info, p_fd) + } +} +pub struct KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_capabilities: *const SurfaceCapabilities2KHR, + ) -> Result, + get_physical_device_surface_formats2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_format_count: *const uint32_t, + p_surface_formats: *const SurfaceFormat2KHR, + ) -> Result, +} +unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} +unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {} +impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { + fn clone(&self) -> Self { + KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: self + .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_formats2_khr: self.get_physical_device_surface_formats2_khr, + } + } +} +impl KhrGetSurfaceCapabilities2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_formats2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_surface_capabilities2_khr( + &self, + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_capabilities: *const SurfaceCapabilities2KHR, + ) -> Result { + (self.get_physical_device_surface_capabilities2_khr)( + physical_device, + p_surface_info, + p_surface_capabilities, + ) + } + pub unsafe fn get_physical_device_surface_formats2_khr( + &self, + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_format_count: *const uint32_t, + p_surface_formats: *const SurfaceFormat2KHR, + ) -> Result { + (self.get_physical_device_surface_formats2_khr)( + physical_device, + p_surface_info, + p_surface_format_count, + p_surface_formats, + ) + } +} +pub struct KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayProperties2KHR, + ) -> Result, + get_physical_device_display_plane_properties2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayPlaneProperties2KHR, + ) -> Result, + get_display_mode_properties2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *const uint32_t, + p_properties: *const DisplayModeProperties2KHR, + ) -> Result, + get_display_plane_capabilities2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_display_plane_info: *const DisplayPlaneInfo2KHR, + p_capabilities: *const DisplayPlaneCapabilities2KHR, + ) -> Result, +} +unsafe impl Send for KhrGetDisplayProperties2Fn {} +unsafe impl Sync for KhrGetDisplayProperties2Fn {} +impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { + fn clone(&self) -> Self { + KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: self + .get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: self + .get_physical_device_display_plane_properties2_khr, + get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, + get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, + } + } +} +impl KhrGetDisplayProperties2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_display_plane_properties2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_mode_properties2_khr: unsafe { + let raw_name = stringify!(vkGetDisplayModeProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_capabilities2_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_display_properties2_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayProperties2KHR, + ) -> Result { + (self.get_physical_device_display_properties2_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_physical_device_display_plane_properties2_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayPlaneProperties2KHR, + ) -> Result { + (self.get_physical_device_display_plane_properties2_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_mode_properties2_khr( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *const uint32_t, + p_properties: *const DisplayModeProperties2KHR, + ) -> Result { + (self.get_display_mode_properties2_khr)( + physical_device, + display, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_plane_capabilities2_khr( + &self, + physical_device: PhysicalDevice, + p_display_plane_info: *const DisplayPlaneInfo2KHR, + p_capabilities: *const DisplayPlaneCapabilities2KHR, + ) -> Result { + (self.get_display_plane_capabilities2_khr)( + physical_device, + p_display_plane_info, + p_capabilities, + ) + } +} +pub struct MvkIosSurfaceFn { + create_ios_surface_mvk: extern "system" fn( + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, +} +unsafe impl Send for MvkIosSurfaceFn {} +unsafe impl Sync for MvkIosSurfaceFn {} +impl ::std::clone::Clone for MvkIosSurfaceFn { + fn clone(&self) -> Self { + MvkIosSurfaceFn { + create_ios_surface_mvk: self.create_ios_surface_mvk, + } + } +} +impl MvkIosSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkIosSurfaceFn { + create_ios_surface_mvk: unsafe { + let raw_name = stringify!(vkCreateIOSSurfaceMVK); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_ios_surface_mvk( + &self, + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_ios_surface_mvk)(instance, p_create_info, p_allocator, p_surface) + } +} +pub struct MvkMacosSurfaceFn { + create_mac_os_surface_mvk: extern "system" fn( + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, +} +unsafe impl Send for MvkMacosSurfaceFn {} +unsafe impl Sync for MvkMacosSurfaceFn {} +impl ::std::clone::Clone for MvkMacosSurfaceFn { + fn clone(&self) -> Self { + MvkMacosSurfaceFn { + create_mac_os_surface_mvk: self.create_mac_os_surface_mvk, + } + } +} +impl MvkMacosSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkMacosSurfaceFn { + create_mac_os_surface_mvk: unsafe { + let raw_name = stringify!(vkCreateMacOSSurfaceMVK); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_mac_os_surface_mvk( + &self, + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_mac_os_surface_mvk)(instance, p_create_info, p_allocator, p_surface) + } +} +pub struct ExtDebugUtilsFn { + set_debug_utils_object_name_ext: + extern "system" fn(device: Device, p_name_info: *const DebugUtilsObjectNameInfoEXT) + -> Result, + set_debug_utils_object_tag_ext: + extern "system" fn(device: Device, p_tag_info: *const DebugUtilsObjectTagInfoEXT) -> Result, + queue_begin_debug_utils_label_ext: + extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, + queue_end_debug_utils_label_ext: extern "system" fn(queue: Queue) -> c_void, + queue_insert_debug_utils_label_ext: + extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, + cmd_begin_debug_utils_label_ext: + extern "system" fn(command_buffer: CommandBuffer, p_label_info: *const DebugUtilsLabelEXT) + -> c_void, + cmd_end_debug_utils_label_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, + cmd_insert_debug_utils_label_ext: + extern "system" fn(command_buffer: CommandBuffer, p_label_info: *const DebugUtilsLabelEXT) + -> c_void, + create_debug_utils_messenger_ext: + extern "system" fn( + instance: Instance, + p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_messenger: *const DebugUtilsMessengerEXT, + ) -> Result, + destroy_debug_utils_messenger_ext: extern "system" fn( + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + submit_debug_utils_message_ext: + extern "system" fn( + instance: Instance, + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) -> c_void, +} +unsafe impl Send for ExtDebugUtilsFn {} +unsafe impl Sync for ExtDebugUtilsFn {} +impl ::std::clone::Clone for ExtDebugUtilsFn { + fn clone(&self) -> Self { + ExtDebugUtilsFn { + set_debug_utils_object_name_ext: self.set_debug_utils_object_name_ext, + set_debug_utils_object_tag_ext: self.set_debug_utils_object_tag_ext, + queue_begin_debug_utils_label_ext: self.queue_begin_debug_utils_label_ext, + queue_end_debug_utils_label_ext: self.queue_end_debug_utils_label_ext, + queue_insert_debug_utils_label_ext: self.queue_insert_debug_utils_label_ext, + cmd_begin_debug_utils_label_ext: self.cmd_begin_debug_utils_label_ext, + cmd_end_debug_utils_label_ext: self.cmd_end_debug_utils_label_ext, + cmd_insert_debug_utils_label_ext: self.cmd_insert_debug_utils_label_ext, + create_debug_utils_messenger_ext: self.create_debug_utils_messenger_ext, + destroy_debug_utils_messenger_ext: self.destroy_debug_utils_messenger_ext, + submit_debug_utils_message_ext: self.submit_debug_utils_message_ext, + } + } +} +impl ExtDebugUtilsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugUtilsFn { + set_debug_utils_object_name_ext: unsafe { + let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + set_debug_utils_object_tag_ext: unsafe { + let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_begin_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_end_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_insert_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_begin_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_end_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_insert_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_debug_utils_messenger_ext: unsafe { + let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_debug_utils_messenger_ext: unsafe { + let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + submit_debug_utils_message_ext: unsafe { + let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn set_debug_utils_object_name_ext( + &self, + device: Device, + p_name_info: *const DebugUtilsObjectNameInfoEXT, + ) -> Result { + (self.set_debug_utils_object_name_ext)(device, p_name_info) + } + pub unsafe fn set_debug_utils_object_tag_ext( + &self, + device: Device, + p_tag_info: *const DebugUtilsObjectTagInfoEXT, + ) -> Result { + (self.set_debug_utils_object_tag_ext)(device, p_tag_info) + } + pub unsafe fn queue_begin_debug_utils_label_ext( + &self, + queue: Queue, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.queue_begin_debug_utils_label_ext)(queue, p_label_info) + } + pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: Queue) -> c_void { + (self.queue_end_debug_utils_label_ext)(queue) + } + pub unsafe fn queue_insert_debug_utils_label_ext( + &self, + queue: Queue, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.queue_insert_debug_utils_label_ext)(queue, p_label_info) + } + pub unsafe fn cmd_begin_debug_utils_label_ext( + &self, + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.cmd_begin_debug_utils_label_ext)(command_buffer, p_label_info) + } + pub unsafe fn cmd_end_debug_utils_label_ext(&self, command_buffer: CommandBuffer) -> c_void { + (self.cmd_end_debug_utils_label_ext)(command_buffer) + } + pub unsafe fn cmd_insert_debug_utils_label_ext( + &self, + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.cmd_insert_debug_utils_label_ext)(command_buffer, p_label_info) + } + pub unsafe fn create_debug_utils_messenger_ext( + &self, + instance: Instance, + p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_messenger: *const DebugUtilsMessengerEXT, + ) -> Result { + (self.create_debug_utils_messenger_ext)(instance, p_create_info, p_allocator, p_messenger) + } + pub unsafe fn destroy_debug_utils_messenger_ext( + &self, + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_debug_utils_messenger_ext)(instance, messenger, p_allocator) + } + pub unsafe fn submit_debug_utils_message_ext( + &self, + instance: Instance, + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) -> c_void { + (self.submit_debug_utils_message_ext)( + instance, + message_severity, + message_types, + p_callback_data, + ) + } +} +pub struct AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: + extern "system" fn( + device: Device, + buffer: *const AHardwareBuffer, + p_properties: *const AndroidHardwareBufferPropertiesANDROID, + ) -> Result, + get_memory_android_hardware_buffer_android: + extern "system" fn( + device: Device, + p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + p_buffer: *mut *mut AHardwareBuffer, + ) -> Result, +} +unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {} +unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {} +impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { + fn clone(&self) -> Self { + AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: self + .get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: self + .get_memory_android_hardware_buffer_android, + } + } +} +impl AndroidExternalMemoryAndroidHardwareBufferFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: unsafe { + let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_android_hardware_buffer_android: unsafe { + let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_android_hardware_buffer_properties_android( + &self, + device: Device, + buffer: *const AHardwareBuffer, + p_properties: *const AndroidHardwareBufferPropertiesANDROID, + ) -> Result { + (self.get_android_hardware_buffer_properties_android)(device, buffer, p_properties) + } + pub unsafe fn get_memory_android_hardware_buffer_android( + &self, + device: Device, + p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + p_buffer: *mut *mut AHardwareBuffer, + ) -> Result { + (self.get_memory_android_hardware_buffer_android)(device, p_info, p_buffer) + } +} +pub struct ExtSampleLocationsFn { + cmd_set_sample_locations_ext: + extern "system" fn( + command_buffer: CommandBuffer, + p_sample_locations_info: *const SampleLocationsInfoEXT, + ) -> c_void, + get_physical_device_multisample_properties_ext: + extern "system" fn( + physical_device: PhysicalDevice, + samples: SampleCountFlags, + p_multisample_properties: *const MultisamplePropertiesEXT, + ) -> c_void, +} +unsafe impl Send for ExtSampleLocationsFn {} +unsafe impl Sync for ExtSampleLocationsFn {} +impl ::std::clone::Clone for ExtSampleLocationsFn { + fn clone(&self) -> Self { + ExtSampleLocationsFn { + cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, + get_physical_device_multisample_properties_ext: self + .get_physical_device_multisample_properties_ext, + } + } +} +impl ExtSampleLocationsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtSampleLocationsFn { + cmd_set_sample_locations_ext: unsafe { + let raw_name = stringify!(vkCmdSetSampleLocationsEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_multisample_properties_ext: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_set_sample_locations_ext( + &self, + command_buffer: CommandBuffer, + p_sample_locations_info: *const SampleLocationsInfoEXT, + ) -> c_void { + (self.cmd_set_sample_locations_ext)(command_buffer, p_sample_locations_info) + } + pub unsafe fn get_physical_device_multisample_properties_ext( + &self, + physical_device: PhysicalDevice, + samples: SampleCountFlags, + p_multisample_properties: *const MultisamplePropertiesEXT, + ) -> c_void { + (self.get_physical_device_multisample_properties_ext)( + physical_device, + samples, + p_multisample_properties, + ) + } +} +pub struct ExtValidationCacheFn { + create_validation_cache_ext: + extern "system" fn( + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *const ValidationCacheEXT, + ) -> Result, + destroy_validation_cache_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + merge_validation_caches_ext: extern "system" fn( + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: uint32_t, + p_src_caches: *const ValidationCacheEXT, + ) -> Result, + get_validation_cache_data_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *const size_t, + p_data: *const c_void, + ) -> Result, +} +unsafe impl Send for ExtValidationCacheFn {} +unsafe impl Sync for ExtValidationCacheFn {} +impl ::std::clone::Clone for ExtValidationCacheFn { + fn clone(&self) -> Self { + ExtValidationCacheFn { + create_validation_cache_ext: self.create_validation_cache_ext, + destroy_validation_cache_ext: self.destroy_validation_cache_ext, + merge_validation_caches_ext: self.merge_validation_caches_ext, + get_validation_cache_data_ext: self.get_validation_cache_data_ext, + } + } +} +impl ExtValidationCacheFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtValidationCacheFn { + create_validation_cache_ext: unsafe { + let raw_name = stringify!(vkCreateValidationCacheEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_validation_cache_ext: unsafe { + let raw_name = stringify!(vkDestroyValidationCacheEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + merge_validation_caches_ext: unsafe { + let raw_name = stringify!(vkMergeValidationCachesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_validation_cache_data_ext: unsafe { + let raw_name = stringify!(vkGetValidationCacheDataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_validation_cache_ext( + &self, + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *const ValidationCacheEXT, + ) -> Result { + (self.create_validation_cache_ext)(device, p_create_info, p_allocator, p_validation_cache) + } + pub unsafe fn destroy_validation_cache_ext( + &self, + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator) + } + pub unsafe fn merge_validation_caches_ext( + &self, + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: uint32_t, + p_src_caches: *const ValidationCacheEXT, + ) -> Result { + (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) + } + pub unsafe fn get_validation_cache_data_ext( + &self, + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *const size_t, + p_data: *const c_void, + ) -> Result { + (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) + } +} +pub struct KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + cmd_draw_indexed_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, +} +unsafe impl Send for KhrDrawIndirectCountFn {} +unsafe impl Sync for KhrDrawIndirectCountFn {} +impl ::std::clone::Clone for KhrDrawIndirectCountFn { + fn clone(&self) -> Self { + KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: self.cmd_draw_indirect_count_khr, + cmd_draw_indexed_indirect_count_khr: self.cmd_draw_indexed_indirect_count_khr, + } + } +} +impl KhrDrawIndirectCountFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: unsafe { + let raw_name = stringify!(vkCmdDrawIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed_indirect_count_khr: unsafe { + let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_draw_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + pub unsafe fn cmd_draw_indexed_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indexed_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } +} +pub struct ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: + extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *const MemoryHostPointerPropertiesEXT, + ) -> Result, +} +unsafe impl Send for ExtExternalMemoryHostFn {} +unsafe impl Sync for ExtExternalMemoryHostFn {} +impl ::std::clone::Clone for ExtExternalMemoryHostFn { + fn clone(&self) -> Self { + ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: self.get_memory_host_pointer_properties_ext, + } + } +} +impl ExtExternalMemoryHostFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: unsafe { + let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_host_pointer_properties_ext( + &self, + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *const MemoryHostPointerPropertiesEXT, + ) -> Result { + (self.get_memory_host_pointer_properties_ext)( + device, + handle_type, + p_host_pointer, + p_memory_host_pointer_properties, + ) + } +} +pub struct AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: uint32_t, + ) -> c_void, +} +unsafe impl Send for AmdBufferMarkerFn {} +unsafe impl Sync for AmdBufferMarkerFn {} +impl ::std::clone::Clone for AmdBufferMarkerFn { + fn clone(&self) -> Self { + AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: self.cmd_write_buffer_marker_amd, + } + } +} +impl AmdBufferMarkerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: unsafe { + let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_write_buffer_marker_amd( + &self, + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: uint32_t, + ) -> c_void { + (self.cmd_write_buffer_marker_amd)( + command_buffer, + pipeline_stage, + dst_buffer, + dst_offset, + marker, + ) } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 37a9e31..e8165d6 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -282,6 +282,41 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { } } } + +pub fn platform_specific_types() -> Tokens { + quote! { + pub type RROutput = c_ulong; + pub type VisualID = c_uint; + pub type Display = *const c_void; + pub type Window = c_ulong; + #[allow(non_camel_case_types)] + pub type xcb_connection_t = *const c_void; + #[allow(non_camel_case_types)] + pub type xcb_window_t = u32; + #[allow(non_camel_case_types)] + pub type xcb_visualid_t = *const c_void; + pub type MirConnection = *const c_void; + pub type MirSurface = *const c_void; + pub type HINSTANCE = *const c_void; + pub type HWND = *const c_void; + #[allow(non_camel_case_types)] + pub type wl_display = *const c_void; + #[allow(non_camel_case_types)] + pub type wl_surface = *const c_void; + pub type HANDLE = *mut c_void; + pub type DWORD = c_ulong; + pub type WCHAR = wchar_t; + pub type LPCWSTR = *const WCHAR; + + // FIXME: Platform specific types that should come from a library + // typedefs are only here so that the code compiles for now + #[allow(non_camel_case_types)] + pub type SECURITY_ATTRIBUTES = (); + // Opage types + pub type ANativeWindow = c_void; + pub type AHardwareBuffer = c_void; + } +} #[derive(Debug, Copy, Clone)] pub enum ConstVal { U32(u32), @@ -392,16 +427,23 @@ pub trait FeatureExt { } impl FeatureExt for vkxml::Feature { fn version_string(&self) -> String { - let version = format!("{:.10}", self.version); - let first_0 = version.find("0").expect("should have at least one 0"); - // + 1 is correct here because we always have 10 zeroes. - let (version, _) = version.split_at(first_0 + 1); + let mut version = format!("{}", self.version); + if version.len() == 1 { + version = format!("{}_0", version) + } version.replace(".", "_") } } +#[derive(Debug, Copy, Clone)] +pub enum FunctionType { + Static, + Entry, + Instance, + Device, +} pub trait CommandExt { /// Returns the ident in snake_case and without the 'vk' prefix. - fn is_device_command(&self) -> bool; + fn function_type(&self) -> FunctionType; /// /// Returns true if the command is a device level command. This is indicated by /// the type of the first parameter. @@ -413,15 +455,31 @@ impl CommandExt for vkxml::Command { Ident::from(self.name[2..].to_snake_case().as_str()) } - fn is_device_command(&self) -> bool { - self.param + fn function_type(&self) -> FunctionType { + let is_first_param_device = self + .param .iter() .nth(0) .map(|field| match field.basetype.as_str() { "VkDevice" | "VkCommandBuffer" | "VkQueue" => true, _ => false, }) - .unwrap_or(false) + .unwrap_or(false); + match self.name.as_str() { + "vkGetInstanceProcAddr" => FunctionType::Static, + "vkCreateInstance" + | "vkEnumerateInstanceLayerProperties" + | "vkEnumerateInstanceExtensionProperties" => FunctionType::Entry, + // This is actually not a device level function + "vkGetDeviceProcAddr" => FunctionType::Instance, + _ => { + if is_first_param_device { + FunctionType::Device + } else { + FunctionType::Instance + } + } + } } } @@ -441,8 +499,8 @@ pub trait ToTokens { impl ToTokens for vkxml::ReferenceType { fn to_tokens(&self) -> Tokens { let ptr_name = match self { - vkxml::ReferenceType::Pointer => "*mut", - vkxml::ReferenceType::PointerToPointer => "*mut", + vkxml::ReferenceType::Pointer => "*const", + vkxml::ReferenceType::PointerToPointer => "*mut *mut", vkxml::ReferenceType::PointerToConstPointer => "*const", }; let ident = Term::intern(ptr_name); @@ -453,9 +511,6 @@ impl ToTokens for vkxml::ReferenceType { } fn name_to_tokens(type_name: &str) -> Tokens { let new_name = match type_name { - "HANDLE" => "*const c_void", - "LPCWSTR" => "*const wchar_t", - "DWORD" => "c_uint", "int" => "c_int", "void" => "c_void", "char" => "c_char", @@ -478,7 +533,6 @@ fn name_to_tokens(type_name: &str) -> Tokens { fn to_type_tokens(type_name: &str, reference: Option<&vkxml::ReferenceType>) -> Tokens { let new_name = name_to_tokens(type_name); let ptr_name = reference.map(|r| r.to_tokens()).unwrap_or(quote!{}); - // let ty: syn::Type = syn::parse_str(&format!("{} {}", ptr_name, new_name)).expect("parse field"); quote!{#ptr_name #new_name} } @@ -497,7 +551,8 @@ impl FieldExt for vkxml::Field { fn type_tokens(&self) -> Tokens { let ty = name_to_tokens(&self.basetype); - let pointer = self.reference + let pointer = self + .reference .as_ref() .map(|r| r.to_tokens()) .unwrap_or(quote!{}); @@ -506,7 +561,8 @@ impl FieldExt for vkxml::Field { }; let array = self.array.as_ref().and_then(|arraytype| match arraytype { vkxml::ArrayType::Static => { - let size = self.size + let size = self + .size .as_ref() .or(self.size_enumref.as_ref()) .expect("Should have size"); @@ -539,7 +595,8 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo .map(|cmd| { let fn_name_raw = cmd.name.as_str(); let fn_name_snake = cmd.command_ident(); - let params: Vec<_> = cmd.param + let params: Vec<_> = cmd + .param .iter() .map(|field| { let name = field.param_ident(); @@ -598,36 +655,34 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo } } impl #ident { - pub fn load(mut f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> ::std::result::Result> where F: FnMut(&::std::ffi::CStr) -> *const c_void { - use std::ffi::CString; - use std::mem; - let mut err_str = Vec::new(); + let mut _err_str = Vec::new(); let s = #ident { #( #names_ref: unsafe { let raw_name = stringify!(#raw_names_ref); - let cname = CString::new(raw_name).unwrap(); - let val = f(&cname); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); if val.is_null(){ - err_str.push(raw_name); + _err_str.push(raw_name); } - mem::transmute(val) + ::std::mem::transmute(val) }, )* }; - if err_str.is_empty() { + if _err_str.is_empty() { Ok(s) } else{ - Err(err_str) + Err(_err_str) } } #( - pub fn #names_ref(&self, #expanded_params_ref) -> #return_types_ref { + pub unsafe fn #names_ref(&self, #expanded_params_ref) -> #return_types_ref { (self.#names_left)(#(#param_names_ref,)*) } )* @@ -702,9 +757,11 @@ pub fn to_variant_ident(enum_name: &str, variant_name: &str) -> Ident { }) .nth(0); - let name_without_tag = tag.map(|t| enum_name.replace(t, "")) + let name_without_tag = tag + .map(|t| enum_name.replace(t, "")) .unwrap_or(enum_name.into()); - let variant_without_tag = tag.map(|t| variant_name.replace(t, "")) + let variant_without_tag = tag + .map(|t| variant_name.replace(t, "")) .unwrap_or(variant_name.into()); let camel_case_name_enum = &name_without_tag.to_camel_case(); let name = variant_without_tag.to_camel_case()[2..].replace(camel_case_name_enum, ""); @@ -753,7 +810,6 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { return None; } }; - let variant_ident = Ident::from(variant_name); Some(quote!{ pub const #variant_ident: #ident = #ident { flags: #value }; @@ -857,21 +913,38 @@ pub fn generate_result(name: &str, _enum: &vkxml::Enumeration) -> Tokens { pub trait StructExt {} pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { let name = to_type_tokens(&_struct.name, None); - let params = _struct - .elements - .iter() - .filter_map(|elem| match *elem { - vkxml::StructElement::Member(ref field) => Some(field), - _ => None, - }) - .map(|field| { - let param_ident = field.param_ident(); - let param_ty_tokens = field.type_tokens(); - quote!{pub #param_ident: #param_ty_tokens} - }); + let members = _struct.elements.iter().filter_map(|elem| match *elem { + vkxml::StructElement::Member(ref field) => Some(field), + _ => None, + }); + + let params = members.clone().map(|field| { + let param_ident = field.param_ident(); + let param_ty_tokens = field.type_tokens(); + quote!{pub #param_ident: #param_ty_tokens} + }); + + let contains_pfn = members.clone().any(|field| { + field + .name + .as_ref() + .map(|n| n.contains("pfn")) + .unwrap_or(false) + }); + + let derive = if contains_pfn { + quote!{ + #[derive(Copy, Clone)] + } + } else { + // FIXME: Properly derive Debug + quote!{ + #[derive(Copy, Clone)] + } + }; quote!{ - #[derive(Copy, Clone)] #[repr(C)] + #derive pub struct #name { #(#params,)* } @@ -901,10 +974,10 @@ pub fn generate_handle(handle: &vkxml::Handle) -> Option { Some(tokens) } fn generate_funcptr(fnptr: &vkxml::FunctionPointer) -> Tokens { - println!("{:#?}", fnptr); let name = Ident::from(fnptr.name.as_str()); let ret_ty_tokens = fnptr.return_type.type_tokens(); quote!{ + #[allow(non_camel_case_types)] pub type #name = unsafe extern "system" fn() -> #ret_ty_tokens; } } @@ -937,8 +1010,8 @@ pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Option None, } } -pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Tokens { - let (device_commands, instance_commands) = feature +pub fn generate_feature(feature: &vkxml::Feature, commands: &CommandMap) -> quote::Tokens { + let (static_commands, entry_commands, device_commands, instance_commands) = feature .elements .iter() .flat_map(|feature| { @@ -960,16 +1033,36 @@ pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> qu } }) .filter_map(|cmd_ref| commands.get(&cmd_ref.name)) - .fold((Vec::new(), Vec::new()), |mut acc, &cmd_ref| { - if cmd_ref.is_device_command() { - acc.0.push(cmd_ref); - } else { - acc.1.push(cmd_ref); - }; - acc - }); - let name = Ident::from("Test"); + .fold( + (Vec::new(), Vec::new(), Vec::new(), Vec::new()), + |mut acc, &cmd_ref| { + match cmd_ref.function_type() { + FunctionType::Static => { + acc.0.push(cmd_ref); + } + FunctionType::Entry => { + acc.1.push(cmd_ref); + } + FunctionType::Device => { + acc.2.push(cmd_ref); + } + FunctionType::Instance => { + acc.3.push(cmd_ref); + } + } + acc + }, + ); let version = feature.version_string(); + let static_fn = if feature.version == 1.0 { + generate_function_pointers(Ident::from("StaticFn"), &static_commands) + } else { + quote!{} + }; + let entry = generate_function_pointers( + Ident::from(format!("EntryFnV{}", version).as_str()), + &entry_commands, + ); let instance = generate_function_pointers( Ident::from(format!("InstanceFnV{}", version).as_str()), &instance_commands, @@ -979,6 +1072,8 @@ pub fn generate_core_spec(feature: &vkxml::Feature, commands: &CommandMap) -> qu &device_commands, ); quote! { + #static_fn + #entry #instance #device } @@ -997,7 +1092,8 @@ pub fn write_source_code(spec: &vkxml::Registry) { use std::fs::File; use std::io::Write; println!("{:#?}", spec); - let commands: HashMap = spec.elements + let commands: HashMap = spec + .elements .iter() .filter_map(|elem| match elem { &vkxml::RegistryElement::Commands(ref cmds) => Some(cmds), @@ -1006,7 +1102,8 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) .collect(); - let features: Vec<&vkxml::Feature> = spec.elements + let features: Vec<&vkxml::Feature> = spec + .elements .iter() .filter_map(|elem| match elem { &vkxml::RegistryElement::Features(ref features) => Some(features), @@ -1015,7 +1112,8 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|features| features.elements.iter().map(|feature| feature)) .collect(); - let extensions: Vec<&vkxml::Extension> = spec.elements + let extensions: Vec<&vkxml::Extension> = spec + .elements .iter() .filter_map(|elem| match elem { &vkxml::RegistryElement::Extensions(ref extensions) => Some(extensions), @@ -1024,7 +1122,8 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|extensions| extensions.elements.iter().map(|extension| extension)) .collect(); - let definitions: Vec<&vkxml::DefinitionsElement> = spec.elements + let definitions: Vec<&vkxml::DefinitionsElement> = spec + .elements .iter() .filter_map(|elem| match elem { &vkxml::RegistryElement::Definitions(ref definitions) => Some(definitions), @@ -1033,7 +1132,8 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|definitions| definitions.elements.iter().map(|definition| definition)) .collect(); - let enums: Vec<&vkxml::Enumeration> = spec.elements + let enums: Vec<&vkxml::Enumeration> = spec + .elements .iter() .filter_map(|elem| match elem { &vkxml::RegistryElement::Enums(ref enums) => Some(enums), @@ -1047,7 +1147,8 @@ pub fn write_source_code(spec: &vkxml::Registry) { }) .collect(); - let constants: Vec<&vkxml::Constant> = spec.elements + let constants: Vec<&vkxml::Constant> = spec + .elements .iter() .filter_map(|elem| match elem { &vkxml::RegistryElement::Constants(ref constants) => Some(constants), @@ -1074,7 +1175,7 @@ pub fn write_source_code(spec: &vkxml::Registry) { let feature_code: Vec<_> = features .iter() - .map(|feature| generate_core_spec(feature, &commands)) + .map(|feature| generate_feature(feature, &commands)) .collect(); let extension_code: Vec<_> = extensions @@ -1089,18 +1190,19 @@ pub fn write_source_code(spec: &vkxml::Registry) { let bitflags_macro = vk_bitflags_wrapped_macro(); let handle_nondispatchable_macro = handle_nondispatchable_macro(); let define_handle_macro = define_handle_macro(); + let platform_specific_types = platform_specific_types(); let source_code = quote!{ - use libc::*; - // #bitflags_macro - // #handle_nondispatchable_macro - // #define_handle_macro - // #(#feature_code)* - // #(#extension_code)* - // #(#definition_code)* - // #(#enum_code)* - // #(#bitflags_code)* + pub use libc::*; + #platform_specific_types + #bitflags_macro + #handle_nondispatchable_macro + #define_handle_macro + #(#feature_code)* + #(#definition_code)* + #(#enum_code)* + #(#bitflags_code)* #(#constants_code)* + #(#extension_code)* }; - println!("{:?}", cexpr("(~0UL)")); write!(&mut file, "{}", source_code); } From fb13cc402e60142ebc57f4662b489f07981ca8df Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 7 Jul 2018 14:49:17 +0200 Subject: [PATCH 017/122] Add extension structure type constants to StructureType --- ash/src/vk.rs | 24 ++++++++++ generator/Cargo.toml | 1 + generator/src/lib.rs | 112 ++++++++++++++++++++++++++++++++++++------- 3 files changed, 121 insertions(+), 16 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index f971367..b535d2e 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,4 +1,28 @@ pub use libc::*; +#[macro_export] +macro_rules! vk_make_version { + ($major:expr, $minor:expr, $patch:expr) => { + (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 + }; +} +#[macro_export] +macro_rules! vk_version_major { + ($major:expr) => { + ($major as uint32_t) >> 22 + }; +} +#[macro_export] +macro_rules! vk_version_minor { + ($minor:expr) => { + (($minor as uint32_t) >> 12) & 0x3ff + }; +} +#[macro_export] +macro_rules! vk_version_patch { + ($minor:expr) => { + ($minor as uint32_t) & 0xfff + }; +} pub type RROutput = c_ulong; pub type VisualID = c_uint; pub type Display = *const c_void; diff --git a/generator/Cargo.toml b/generator/Cargo.toml index dc33c66..1b3acb4 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -10,6 +10,7 @@ vkxml = {git = "https://github.com/terrybrashaw/vkxml"} nom = "4.0" heck = "0.3" proc-macro2 = "0.2" +itertools = "0.7" [dependencies.quote] version = "0.4.2" diff --git a/generator/src/lib.rs b/generator/src/lib.rs index e8165d6..cd111c7 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -8,11 +8,13 @@ extern crate heck; extern crate proc_macro2; #[macro_use] extern crate quote; +extern crate itertools; extern crate syn; pub extern crate vk_parse; pub extern crate vkxml; use heck::{CamelCase, ShoutySnakeCase, SnakeCase}; +use itertools::Itertools; use proc_macro2::{Term, TokenTree}; use quote::Tokens; use std::collections::HashMap; @@ -135,6 +137,37 @@ pub fn handle_nondispatchable_macro() -> Tokens { } } } +pub fn vk_version_macros() -> Tokens { + quote!{ + #[macro_export] + macro_rules! vk_make_version { + ($major:expr, $minor:expr, $patch:expr) => { + (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 + }; + } + + #[macro_export] + macro_rules! vk_version_major { + ($major:expr) => { + ($major as uint32_t) >> 22 + }; + } + + #[macro_export] + macro_rules! vk_version_minor { + ($minor:expr) => { + (($minor as uint32_t) >> 12) & 0x3ff + }; + } + + #[macro_export] + macro_rules! vk_version_patch { + ($minor:expr) => { + ($minor as uint32_t) & 0xfff + }; + } + } +} pub fn vk_bitflags_wrapped_macro() -> Tokens { quote!{ macro_rules! vk_bitflags_wrapped { @@ -697,15 +730,15 @@ pub fn generate_extension(extension: &vkxml::Extension, commands: &CommandMap) - if let &vkxml::ExtensionElement::Require(ref spec) = extension { spec.elements .iter() - .filter_map(|extension_spec| { - if let &vkxml::ExtensionSpecificationElement::CommandReference( - ref cmd_ref, - ) = extension_spec - { + .filter_map(|extension_spec| match extension_spec { + vkxml::ExtensionSpecificationElement::CommandReference(ref cmd_ref) => { Some(cmd_ref) - } else { + } + vkxml::ExtensionSpecificationElement::DefinitionReference(ref field) => { + println!("EXT {:?}", field); None } + _ => None, }) .collect() } else { @@ -778,7 +811,10 @@ pub enum EnumType { Enum(Tokens), } -pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { +pub fn generate_enum( + _enum: &vkxml::Enumeration, + create_info_constants: &[&vkxml::Constant], +) -> EnumType { let name = &_enum.name[2..]; let _name = name.replace("FlagBits", "Flags"); if name.contains("Bit") { @@ -822,6 +858,7 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { EnumType::Bitflags(q) } else { let q = match _name.as_str() { + "StructureType" => generate_structure_type(&_name, _enum, create_info_constants), "Result" => generate_result(&_name, _enum), _ => { let ident = Ident::from(_name.as_str()); @@ -854,6 +891,38 @@ pub fn generate_enum(_enum: &vkxml::Enumeration) -> EnumType { EnumType::Enum(q) } } +pub fn generate_structure_type( + name: &str, + _enum: &vkxml::Enumeration, + create_info_constants: &[&vkxml::Constant], +) -> Tokens { + let ident = Ident::from(name); + let constants: Vec<_> = _enum + .elements + .iter() + .filter_map(|elem| match elem { + vkxml::EnumerationElement::Enum(constant) => Some(constant), + _ => None, + }) + .collect(); + let variants = constants + .iter() + .chain(create_info_constants.into_iter()) + .map(|constant| { + let value_tokens = Constant::from_constant(constant).to_tokens(); + let variant_ident = to_variant_ident(&name, &constant.name); + quote!{ + #variant_ident = #value_tokens + } + }); + quote!{ + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + #[repr(C)] + pub enum #ident { + #(#variants,)* + } + } +} pub fn generate_result(name: &str, _enum: &vkxml::Enumeration) -> Tokens { let ident = Ident::from(name); let variants = _enum.elements.iter().filter_map(|elem| { @@ -1157,16 +1226,29 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|constants| constants.elements.iter()) .collect(); - let (enum_code, bitflags_code) = enums.into_iter().map(generate_enum).fold( - (Vec::new(), Vec::new()), - |mut acc, elem| { + let (create_info_constants, constants): (Vec<_>, Vec<_>) = + constants.iter().partition_map(|&c| { + if c.name.contains("CreateInfo") { + itertools::Either::Left(c) + } else { + itertools::Either::Right(c) + } + }); + + let (enum_code, bitflags_code) = enums + .into_iter() + .map(|e| generate_enum(e, &create_info_constants)) + .fold((Vec::new(), Vec::new()), |mut acc, elem| { match elem { EnumType::Enum(token) => acc.0.push(token), EnumType::Bitflags(token) => acc.1.push(token), }; acc - }, - ); + }); + let constants_code: Vec<_> = constants + .iter() + .map(|constant| generate_constant(constant)) + .collect(); let definition_code: Vec<_> = definitions .into_iter() @@ -1182,17 +1264,15 @@ pub fn write_source_code(spec: &vkxml::Registry) { .iter() .map(|ext| generate_extension(ext, &commands)) .collect(); - let constants_code: Vec<_> = constants - .iter() - .map(|constant| generate_constant(constant)) - .collect(); let mut file = File::create("../ash/src/vk_test.rs").expect("vk"); let bitflags_macro = vk_bitflags_wrapped_macro(); let handle_nondispatchable_macro = handle_nondispatchable_macro(); let define_handle_macro = define_handle_macro(); + let version_macros = vk_version_macros(); let platform_specific_types = platform_specific_types(); let source_code = quote!{ pub use libc::*; + #version_macros #platform_specific_types #bitflags_macro #handle_nondispatchable_macro From 72f1cdf6ad4df352471ed34d173cc4f3b57c2d39 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 9 Jul 2018 08:49:28 +0200 Subject: [PATCH 018/122] Transform Bitflags and Enums to constants --- generator/src/lib.rs | 142 +++++++++++++++++++++++-------------------- 1 file changed, 75 insertions(+), 67 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index cd111c7..7f516f3 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -20,6 +20,10 @@ use quote::Tokens; use std::collections::HashMap; use syn::Ident; +pub struct Foo; +impl Foo { + const FOO: u32 = 1; +} #[derive(Copy, Clone, Debug)] pub enum CType { USize, @@ -734,8 +738,12 @@ pub fn generate_extension(extension: &vkxml::Extension, commands: &CommandMap) - vkxml::ExtensionSpecificationElement::CommandReference(ref cmd_ref) => { Some(cmd_ref) } - vkxml::ExtensionSpecificationElement::DefinitionReference(ref field) => { - println!("EXT {:?}", field); + vkxml::ExtensionSpecificationElement::Constant(ref field) => { + //println!("EXT {:?}", field); + None + } + vkxml::ExtensionSpecificationElement::Enum(ref field) => { + //println!("Enum {:?}", field); None } _ => None, @@ -778,6 +786,7 @@ pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { vk_bitflags_wrapped!(#ident, 0b0, Flags); }) } + pub fn to_variant_ident(enum_name: &str, variant_name: &str) -> Ident { let tag = ["AMD", "NN", "KHR", "NV", "EXT", "NVX", "KHX"] .iter() @@ -794,7 +803,7 @@ pub fn to_variant_ident(enum_name: &str, variant_name: &str) -> Ident { .map(|t| enum_name.replace(t, "")) .unwrap_or(enum_name.into()); let variant_without_tag = tag - .map(|t| variant_name.replace(t, "")) + .map(|t| variant_name.replace(&format!("_{}", t), "")) .unwrap_or(variant_name.into()); let camel_case_name_enum = &name_without_tag.to_camel_case(); let name = variant_without_tag.to_camel_case()[2..].replace(camel_case_name_enum, ""); @@ -817,6 +826,35 @@ pub fn generate_enum( ) -> EnumType { let name = &_enum.name[2..]; let _name = name.replace("FlagBits", "Flags"); + let ident = Ident::from(_name.as_str()); + let variants = _enum.elements.iter().filter_map(|elem| { + let (variant_name, value) = match *elem { + vkxml::EnumerationElement::Enum(ref constant) => { + let c = Constant::from_constant(constant); + (constant.name.as_str(), c.to_tokens()) + } + _ => { + return None; + } + }; + + let _name = _name.split("Flags").nth(0).expect("split"); + let struct_name = _name.to_shouty_snake_case(); + println!("{}", struct_name); + let new_variant_name = variant_name.replace(&struct_name, "").replace("VK", ""); + let new_variant_name = new_variant_name.trim_matches('_'); + let is_digit = new_variant_name + .chars() + .nth(0) + .map(|c| c.is_digit(10)) + .unwrap_or(false); + let variant_ident = if is_digit { + Ident::from(format!("TYPE_{}", new_variant_name).as_str()) + } else { + Ident::from(new_variant_name) + }; + Some((variant_ident, value)) + }).collect_vec(); if name.contains("Bit") { let ident = Ident::from(_name.as_str()); let all_bits = _enum @@ -832,58 +870,36 @@ pub fn generate_enum( .fold(0, |acc, next| acc | next.bits()); let all_bits_term = Term::intern(&format!("0b{:b}", all_bits)); - let variants = _enum.elements.iter().filter_map(|elem| { - let (variant_name, value) = match *elem { - vkxml::EnumerationElement::Enum(ref constant) => { - let variant_name = &constant.name[3..]; - let c = Constant::from_constant(constant); - if c.value().map(|v| v.bits() == 0).unwrap_or(false) { - return None; - } - (variant_name, c.to_tokens()) - } - _ => { - return None; - } - }; - let variant_ident = Ident::from(variant_name); - Some(quote!{ - pub const #variant_ident: #ident = #ident { flags: #value }; - }) + let variants = variants.iter().map(|(variant_ident, value)|{ + quote!{ + pub const #variant_ident: Self = #ident { flags: #value } + } }); let q = quote!{ - #(#variants)* vk_bitflags_wrapped!(#ident, #all_bits_term, Flags); + impl #ident { + #(#variants;)* + } }; EnumType::Bitflags(q) } else { + let variants = variants.iter().map(|(variant_ident, value)|{ + quote!{ + pub const #variant_ident: Self = #ident(#value) + } + }); let q = match _name.as_str() { - "StructureType" => generate_structure_type(&_name, _enum, create_info_constants), - "Result" => generate_result(&_name, _enum), + //"StructureType" => generate_structure_type(&_name, _enum, create_info_constants), + //"Result" => generate_result(&_name, _enum), _ => { - let ident = Ident::from(_name.as_str()); - let variants = _enum.elements.iter().filter_map(|elem| { - let (variant_name, value) = match *elem { - vkxml::EnumerationElement::Enum(ref constant) => { - let c = Constant::from_constant(constant); - //println!("value {:?}", c.value()); - (constant.name.as_str(), c.to_tokens()) - } - _ => { - return None; - } - }; - - let variant_ident = to_variant_ident(&_name, variant_name); - Some(quote!{ - #variant_ident = #value - }) - }); quote!{ #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] - pub enum #ident { - #(#variants,)* + pub struct #ident(pub i32); + impl #ident { + #( + #variants; + )* } } } @@ -891,6 +907,7 @@ pub fn generate_enum( EnumType::Enum(q) } } + pub fn generate_structure_type( name: &str, _enum: &vkxml::Enumeration, @@ -1226,25 +1243,16 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|constants| constants.elements.iter()) .collect(); - let (create_info_constants, constants): (Vec<_>, Vec<_>) = - constants.iter().partition_map(|&c| { - if c.name.contains("CreateInfo") { - itertools::Either::Left(c) - } else { - itertools::Either::Right(c) - } - }); - - let (enum_code, bitflags_code) = enums - .into_iter() - .map(|e| generate_enum(e, &create_info_constants)) - .fold((Vec::new(), Vec::new()), |mut acc, elem| { + let (enum_code, bitflags_code) = enums.into_iter().map(|e| generate_enum(e, &[])).fold( + (Vec::new(), Vec::new()), + |mut acc, elem| { match elem { EnumType::Enum(token) => acc.0.push(token), EnumType::Bitflags(token) => acc.1.push(token), }; acc - }); + }, + ); let constants_code: Vec<_> = constants .iter() .map(|constant| generate_constant(constant)) @@ -1264,7 +1272,7 @@ pub fn write_source_code(spec: &vkxml::Registry) { .iter() .map(|ext| generate_extension(ext, &commands)) .collect(); - let mut file = File::create("../ash/src/vk_test.rs").expect("vk"); + let mut file = File::create("../ash/src/vk.rs").expect("vk"); let bitflags_macro = vk_bitflags_wrapped_macro(); let handle_nondispatchable_macro = handle_nondispatchable_macro(); let define_handle_macro = define_handle_macro(); @@ -1272,17 +1280,17 @@ pub fn write_source_code(spec: &vkxml::Registry) { let platform_specific_types = platform_specific_types(); let source_code = quote!{ pub use libc::*; - #version_macros - #platform_specific_types + // #version_macros + // #platform_specific_types #bitflags_macro - #handle_nondispatchable_macro - #define_handle_macro - #(#feature_code)* - #(#definition_code)* + // #handle_nondispatchable_macro + // #define_handle_macro + // #(#feature_code)* + // #(#definition_code)* #(#enum_code)* #(#bitflags_code)* - #(#constants_code)* - #(#extension_code)* + // #(#constants_code)* + // #(#extension_code)* }; write!(&mut file, "{}", source_code); } From 325246c0261783dfadfdee8b89559e264fcf48a4 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 9 Jul 2018 09:23:21 +0200 Subject: [PATCH 019/122] Rename Result::Success to Result::SUCCESS --- ash/src/device.rs | 76 ++++++++++++------------- ash/src/entry.rs | 6 +- ash/src/extensions/android_surface.rs | 2 +- ash/src/extensions/debug_marker.rs | 2 +- ash/src/extensions/debug_report.rs | 2 +- ash/src/extensions/display_swapchain.rs | 2 +- ash/src/extensions/ios_surface.rs | 2 +- ash/src/extensions/macos_surface.rs | 2 +- ash/src/extensions/mir_surface.rs | 2 +- ash/src/extensions/surface.rs | 6 +- ash/src/extensions/swapchain.rs | 8 +-- ash/src/extensions/wayland_surface.rs | 2 +- ash/src/extensions/win32_surface.rs | 2 +- ash/src/extensions/xcb_surface.rs | 2 +- ash/src/extensions/xlib_surface.rs | 2 +- ash/src/instance.rs | 8 +-- 16 files changed, 63 insertions(+), 63 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index 490a68f..7e77314 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -247,7 +247,7 @@ pub trait DeviceV1_0 { &mut sampler, ); match err_code { - vk::Result::Success => Ok(sampler), + vk::Result::SUCCESS => Ok(sampler), _ => Err(err_code), } } @@ -407,7 +407,7 @@ pub trait DeviceV1_0 { desc_set.set_len(create_info.descriptor_set_count as usize); match err_code { - vk::Result::Success => Ok(desc_set), + vk::Result::SUCCESS => Ok(desc_set), _ => Err(err_code), } } @@ -425,7 +425,7 @@ pub trait DeviceV1_0 { &mut layout, ); match err_code { - vk::Result::Success => Ok(layout), + vk::Result::SUCCESS => Ok(layout), _ => Err(err_code), } } @@ -434,7 +434,7 @@ pub trait DeviceV1_0 { unsafe { let err_code = self.fp_v1_0().device_wait_idle(self.handle()); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -453,7 +453,7 @@ pub trait DeviceV1_0 { &mut pool, ); match err_code { - vk::Result::Success => Ok(pool), + vk::Result::SUCCESS => Ok(pool), _ => Err(err_code), } } @@ -467,7 +467,7 @@ pub trait DeviceV1_0 { .fp_v1_0() .reset_descriptor_pool(self.handle(), pool, flags); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -481,7 +481,7 @@ pub trait DeviceV1_0 { .fp_v1_0() .reset_command_pool(self.handle(), command_pool, flags); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -493,7 +493,7 @@ pub trait DeviceV1_0 { ) -> VkResult<()> { let err_code = self.fp_v1_0().reset_command_buffer(command_buffer, flags); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -505,7 +505,7 @@ pub trait DeviceV1_0 { fences.as_ptr(), ); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -881,7 +881,7 @@ pub trait DeviceV1_0 { ); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -942,7 +942,7 @@ pub trait DeviceV1_0 { &mut semaphore, ); match err_code { - vk::Result::Success => Ok(semaphore), + vk::Result::SUCCESS => Ok(semaphore), _ => Err(err_code), } } @@ -964,7 +964,7 @@ pub trait DeviceV1_0 { ); pipelines.set_len(create_infos.len()); match err_code { - vk::Result::Success => Ok(pipelines), + vk::Result::SUCCESS => Ok(pipelines), _ => Err((pipelines, err_code)), } } @@ -986,7 +986,7 @@ pub trait DeviceV1_0 { ); pipelines.set_len(create_infos.len()); match err_code { - vk::Result::Success => Ok(pipelines), + vk::Result::SUCCESS => Ok(pipelines), _ => Err((pipelines, err_code)), } } @@ -1004,7 +1004,7 @@ pub trait DeviceV1_0 { &mut buffer, ); match err_code { - vk::Result::Success => Ok(buffer), + vk::Result::SUCCESS => Ok(buffer), _ => Err(err_code), } } @@ -1022,7 +1022,7 @@ pub trait DeviceV1_0 { &mut pipeline_layout, ); match err_code { - vk::Result::Success => Ok(pipeline_layout), + vk::Result::SUCCESS => Ok(pipeline_layout), _ => Err(err_code), } } @@ -1041,7 +1041,7 @@ pub trait DeviceV1_0 { ); match err_code { - vk::Result::Success => Ok(pipeline_cache), + vk::Result::SUCCESS => Ok(pipeline_cache), _ => Err(err_code), } } @@ -1058,7 +1058,7 @@ pub trait DeviceV1_0 { self.fp_v1_0() .map_memory(self.handle(), memory, offset, size, flags, &mut data); match err_code { - vk::Result::Success => Ok(data), + vk::Result::SUCCESS => Ok(data), _ => Err(err_code), } } @@ -1077,7 +1077,7 @@ pub trait DeviceV1_0 { ranges.as_ptr(), ); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1089,7 +1089,7 @@ pub trait DeviceV1_0 { ranges.as_ptr(), ); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1107,7 +1107,7 @@ pub trait DeviceV1_0 { &mut framebuffer, ); match err_code { - vk::Result::Success => Ok(framebuffer), + vk::Result::SUCCESS => Ok(framebuffer), _ => Err(err_code), } } @@ -1160,7 +1160,7 @@ pub trait DeviceV1_0 { &mut renderpass, ); match err_code { - vk::Result::Success => Ok(renderpass), + vk::Result::SUCCESS => Ok(renderpass), _ => Err(err_code), } } @@ -1174,7 +1174,7 @@ pub trait DeviceV1_0 { .fp_v1_0() .begin_command_buffer(command_buffer, create_info); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1182,7 +1182,7 @@ pub trait DeviceV1_0 { unsafe fn end_command_buffer(&self, command_buffer: vk::CommandBuffer) -> VkResult<()> { let err_code = self.fp_v1_0().end_command_buffer(command_buffer); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1201,7 +1201,7 @@ pub trait DeviceV1_0 { timeout, ); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1209,7 +1209,7 @@ pub trait DeviceV1_0 { unsafe fn get_fence_status(&self, fence: vk::Fence) -> VkResult<()> { let err_code = self.fp_v1_0().get_fence_status(self.handle(), fence); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1217,7 +1217,7 @@ pub trait DeviceV1_0 { unsafe fn queue_wait_idle(&self, queue: vk::Queue) -> VkResult<()> { let err_code = self.fp_v1_0().queue_wait_idle(queue); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1235,7 +1235,7 @@ pub trait DeviceV1_0 { fence, ); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1253,7 +1253,7 @@ pub trait DeviceV1_0 { &mut buffer_view, ); match err_code { - vk::Result::Success => Ok(buffer_view), + vk::Result::SUCCESS => Ok(buffer_view), _ => Err(err_code), } } @@ -1283,7 +1283,7 @@ pub trait DeviceV1_0 { &mut image_view, ); match err_code { - vk::Result::Success => Ok(image_view), + vk::Result::SUCCESS => Ok(image_view), _ => Err(err_code), } } @@ -1300,7 +1300,7 @@ pub trait DeviceV1_0 { ); buffers.set_len(create_info.command_buffer_count as vk::size_t); match err_code { - vk::Result::Success => Ok(buffers), + vk::Result::SUCCESS => Ok(buffers), _ => Err(err_code), } } @@ -1318,7 +1318,7 @@ pub trait DeviceV1_0 { &mut pool, ); match err_code { - vk::Result::Success => Ok(pool), + vk::Result::SUCCESS => Ok(pool), _ => Err(err_code), } } @@ -1336,7 +1336,7 @@ pub trait DeviceV1_0 { &mut pool, ); match err_code { - vk::Result::Success => Ok(pool), + vk::Result::SUCCESS => Ok(pool), _ => Err(err_code), } } @@ -1354,7 +1354,7 @@ pub trait DeviceV1_0 { &mut image, ); match err_code { - vk::Result::Success => Ok(image), + vk::Result::SUCCESS => Ok(image), _ => Err(err_code), } } @@ -1407,7 +1407,7 @@ pub trait DeviceV1_0 { &mut memory, ); match err_code { - vk::Result::Success => Ok(memory), + vk::Result::SUCCESS => Ok(memory), _ => Err(err_code), } } @@ -1425,7 +1425,7 @@ pub trait DeviceV1_0 { &mut shader, ); match err_code { - vk::Result::Success => Ok(shader), + vk::Result::SUCCESS => Ok(shader), _ => Err(err_code), } } @@ -1443,7 +1443,7 @@ pub trait DeviceV1_0 { &mut fence, ); match err_code { - vk::Result::Success => Ok(fence), + vk::Result::SUCCESS => Ok(fence), _ => Err(err_code), } } @@ -1458,7 +1458,7 @@ pub trait DeviceV1_0 { self.fp_v1_0() .bind_buffer_memory(self.handle(), buffer, device_memory, offset); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -1473,7 +1473,7 @@ pub trait DeviceV1_0 { self.fp_v1_0() .bind_image_memory(self.handle(), image, device_memory, offset); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } diff --git a/ash/src/entry.rs b/ash/src/entry.rs index 586b74e..b4d0590 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -82,7 +82,7 @@ pub trait EntryV1_0 { allocation_callbacks.as_raw_ptr(), &mut instance, ); - if err_code != vk::Result::Success { + if err_code != vk::Result::SUCCESS { return Err(InstanceError::VkError(err_code)); } let instance_fp = @@ -103,7 +103,7 @@ pub trait EntryV1_0 { .enumerate_instance_layer_properties(&mut num, v.as_mut_ptr()); v.set_len(num as usize); match err_code { - vk::Result::Success => Ok(v), + vk::Result::SUCCESS => Ok(v), _ => Err(err_code), } } @@ -125,7 +125,7 @@ pub trait EntryV1_0 { ); data.set_len(num as usize); match err_code { - vk::Result::Success => Ok(data), + vk::Result::SUCCESS => Ok(data), _ => Err(err_code), } } diff --git a/ash/src/extensions/android_surface.rs b/ash/src/extensions/android_surface.rs index a56cf08..881a121 100644 --- a/ash/src/extensions/android_surface.rs +++ b/ash/src/extensions/android_surface.rs @@ -43,7 +43,7 @@ impl AndroidSurface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/extensions/debug_marker.rs b/ash/src/extensions/debug_marker.rs index 13a9d33..3240bba 100644 --- a/ash/src/extensions/debug_marker.rs +++ b/ash/src/extensions/debug_marker.rs @@ -36,7 +36,7 @@ impl DebugMarker { .debug_marker_fn .debug_marker_set_object_name_ext(device, name_info); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } diff --git a/ash/src/extensions/debug_report.rs b/ash/src/extensions/debug_report.rs index 335e248..35e00e5 100644 --- a/ash/src/extensions/debug_report.rs +++ b/ash/src/extensions/debug_report.rs @@ -55,7 +55,7 @@ impl DebugReport { &mut debug_cb, ); match err_code { - vk::Result::Success => Ok(debug_cb), + vk::Result::SUCCESS => Ok(debug_cb), _ => Err(err_code), } } diff --git a/ash/src/extensions/display_swapchain.rs b/ash/src/extensions/display_swapchain.rs index 1798f8d..d195e72 100644 --- a/ash/src/extensions/display_swapchain.rs +++ b/ash/src/extensions/display_swapchain.rs @@ -45,7 +45,7 @@ impl DisplaySwapchain { ); swapchains.set_len(create_infos.len()); match err_code { - vk::Result::Success => Ok(swapchains), + vk::Result::SUCCESS => Ok(swapchains), _ => Err(err_code), } } diff --git a/ash/src/extensions/ios_surface.rs b/ash/src/extensions/ios_surface.rs index 4a89c68..2e6715f 100644 --- a/ash/src/extensions/ios_surface.rs +++ b/ash/src/extensions/ios_surface.rs @@ -43,7 +43,7 @@ impl IOSSurface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/extensions/macos_surface.rs b/ash/src/extensions/macos_surface.rs index e9cb705..8248cb8 100644 --- a/ash/src/extensions/macos_surface.rs +++ b/ash/src/extensions/macos_surface.rs @@ -43,7 +43,7 @@ impl MacOSSurface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/extensions/mir_surface.rs b/ash/src/extensions/mir_surface.rs index 0281a5f..3f36a1e 100644 --- a/ash/src/extensions/mir_surface.rs +++ b/ash/src/extensions/mir_surface.rs @@ -43,7 +43,7 @@ impl MirSurface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/extensions/surface.rs b/ash/src/extensions/surface.rs index c8db6b6..22e8b23 100644 --- a/ash/src/extensions/surface.rs +++ b/ash/src/extensions/surface.rs @@ -73,7 +73,7 @@ impl Surface { ); v.set_len(count as usize); match err_code { - vk::Result::Success => Ok(v), + vk::Result::SUCCESS => Ok(v), _ => Err(err_code), } } @@ -94,7 +94,7 @@ impl Surface { &mut surface_capabilities, ); match err_code { - vk::Result::Success => Ok(surface_capabilities), + vk::Result::SUCCESS => Ok(surface_capabilities), _ => Err(err_code), } } @@ -122,7 +122,7 @@ impl Surface { ); v.set_len(count as usize); match err_code { - vk::Result::Success => Ok(v), + vk::Result::SUCCESS => Ok(v), _ => Err(err_code), } } diff --git a/ash/src/extensions/swapchain.rs b/ash/src/extensions/swapchain.rs index 7d120bd..2488d6e 100644 --- a/ash/src/extensions/swapchain.rs +++ b/ash/src/extensions/swapchain.rs @@ -60,7 +60,7 @@ impl Swapchain { &mut index, ); match err_code { - vk::Result::Success => Ok(index), + vk::Result::SUCCESS => Ok(index), _ => Err(err_code), } } @@ -78,7 +78,7 @@ impl Swapchain { &mut swapchain, ); match err_code { - vk::Result::Success => Ok(swapchain), + vk::Result::SUCCESS => Ok(swapchain), _ => Err(err_code), } } @@ -90,7 +90,7 @@ impl Swapchain { ) -> VkResult<()> { let err_code = self.swapchain_fn.queue_present_khr(queue, create_info); match err_code { - vk::Result::Success => Ok(()), + vk::Result::SUCCESS => Ok(()), _ => Err(err_code), } } @@ -117,7 +117,7 @@ impl Swapchain { ); v.set_len(count as vk::size_t); match err_code { - vk::Result::Success => Ok(v), + vk::Result::SUCCESS => Ok(v), _ => Err(err_code), } } diff --git a/ash/src/extensions/wayland_surface.rs b/ash/src/extensions/wayland_surface.rs index 6c96fcc..e98e173 100644 --- a/ash/src/extensions/wayland_surface.rs +++ b/ash/src/extensions/wayland_surface.rs @@ -43,7 +43,7 @@ impl WaylandSurface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/extensions/win32_surface.rs b/ash/src/extensions/win32_surface.rs index e24404f..365326d 100644 --- a/ash/src/extensions/win32_surface.rs +++ b/ash/src/extensions/win32_surface.rs @@ -43,7 +43,7 @@ impl Win32Surface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/extensions/xcb_surface.rs b/ash/src/extensions/xcb_surface.rs index e3906e3..2ff3f76 100644 --- a/ash/src/extensions/xcb_surface.rs +++ b/ash/src/extensions/xcb_surface.rs @@ -43,7 +43,7 @@ impl XcbSurface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/extensions/xlib_surface.rs b/ash/src/extensions/xlib_surface.rs index cc4c1da..1f89c1a 100644 --- a/ash/src/extensions/xlib_surface.rs +++ b/ash/src/extensions/xlib_surface.rs @@ -43,7 +43,7 @@ impl XlibSurface { &mut surface, ); match err_code { - vk::Result::Success => Ok(surface), + vk::Result::SUCCESS => Ok(surface), _ => Err(err_code), } } diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 53406b0..834835b 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -82,7 +82,7 @@ pub trait InstanceV1_0 { allocation_callbacks.as_raw_ptr(), &mut device, ); - if err_code != vk::Result::Success { + if err_code != vk::Result::SUCCESS { return Err(DeviceError::VkError(err_code)); } let device_fn = <::Fp as FunctionPointers>::DeviceFp::load( @@ -141,7 +141,7 @@ pub trait InstanceV1_0 { flags, &mut image_format_prop, ); - if err_code == vk::Result::Success { + if err_code == vk::Result::SUCCESS { Ok(image_format_prop) } else { Err(err_code) @@ -220,7 +220,7 @@ pub trait InstanceV1_0 { ); physical_devices.set_len(num as usize); match err_code { - vk::Result::Success => Ok(physical_devices), + vk::Result::SUCCESS => Ok(physical_devices), _ => Err(err_code), } } @@ -247,7 +247,7 @@ pub trait InstanceV1_0 { ); data.set_len(num as usize); match err_code { - vk::Result::Success => Ok(data), + vk::Result::SUCCESS => Ok(data), _ => Err(err_code), } } From f65c62dbaa14093d37137eb6e281c60c2de472b3 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 9 Jul 2018 09:23:53 +0200 Subject: [PATCH 020/122] Implement Error for the new Result --- ash/src/vk.rs | 2765 +++++++++++++++++++++++++----------------- generator/src/lib.rs | 189 ++- 2 files changed, 1747 insertions(+), 1207 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index b535d2e..2787c53 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -51,11 +51,6 @@ pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { ($name:ident, $all:expr, $flag_type:ty) => { - #[repr(C)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct $name { - flags: $flag_type, - } impl Default for $name { fn default() -> $name { $name { flags: 0 } @@ -4573,51 +4568,281 @@ pub type SampleMask = uint32_t; pub type Bool32 = uint32_t; pub type Flags = uint32_t; pub type DeviceSize = uint64_t; +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FramebufferCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueryPoolCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct RenderPassCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SamplerCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineLayoutCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineCacheCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineDepthStencilStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineDynamicStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineColorBlendStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineMultisampleStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineRasterizationStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineViewportStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineTessellationStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineInputAssemblyStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineVertexInputStateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineShaderStageCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct BufferViewCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct InstanceCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DeviceCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ImageViewCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SemaphoreCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ShaderModuleCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct EventCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MemoryMapFlags { + flags: Flags, +} vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorPoolResetFlags { + flags: Flags, +} vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorUpdateTemplateCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DisplayModeCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DisplaySurfaceCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct AndroidSurfaceCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MirSurfaceCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(MirSurfaceCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ViSurfaceCreateFlagsNN { + flags: Flags, +} vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct WaylandSurfaceCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Win32SurfaceCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct XlibSurfaceCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct XcbSurfaceCreateFlagsKHR { + flags: Flags, +} vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct IOSSurfaceCreateFlagsMVK { + flags: Flags, +} vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MacOSSurfaceCreateFlagsMVK { + flags: Flags, +} vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandPoolTrimFlags { + flags: Flags, +} vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineViewportSwizzleStateCreateFlagsNV { + flags: Flags, +} vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineDiscardRectangleStateCreateFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineCoverageToColorStateCreateFlagsNV { + flags: Flags, +} vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineCoverageModulationStateCreateFlagsNV { + flags: Flags, +} vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ValidationCacheCreateFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugUtilsMessengerCreateFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugUtilsMessengerCallbackDataFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags); +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineRasterizationConservativeStateCreateFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!( PipelineRasterizationConservativeStateCreateFlagsEXT, 0b0, @@ -7992,548 +8217,582 @@ pub struct ExternalFormatANDROID { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ImageLayout { - Undefined = 0, - General = 1, - ColorAttachmentOptimal = 2, - DepthStencilAttachmentOptimal = 3, - DepthStencilReadOnlyOptimal = 4, - ShaderReadOnlyOptimal = 5, - TransferSrcOptimal = 6, - TransferDstOptimal = 7, - Preinitialized = 8, +pub struct ImageLayout(pub i32); +impl ImageLayout { + pub const UNDEFINED: Self = ImageLayout(0); + pub const GENERAL: Self = ImageLayout(1); + pub const COLOR_ATTACHMENT_OPTIMAL: Self = ImageLayout(2); + pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(3); + pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(4); + pub const SHADER_READ_ONLY_OPTIMAL: Self = ImageLayout(5); + pub const TRANSFER_SRC_OPTIMAL: Self = ImageLayout(6); + pub const TRANSFER_DST_OPTIMAL: Self = ImageLayout(7); + pub const PREINITIALIZED: Self = ImageLayout(8); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum AttachmentLoadOp { - Load = 0, - Clear = 1, - DontCare = 2, +pub struct AttachmentLoadOp(pub i32); +impl AttachmentLoadOp { + pub const LOAD: Self = AttachmentLoadOp(0); + pub const CLEAR: Self = AttachmentLoadOp(1); + pub const DONT_CARE: Self = AttachmentLoadOp(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum AttachmentStoreOp { - Store = 0, - DontCare = 1, +pub struct AttachmentStoreOp(pub i32); +impl AttachmentStoreOp { + pub const STORE: Self = AttachmentStoreOp(0); + pub const DONT_CARE: Self = AttachmentStoreOp(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ImageType { - Type1d = 0, - Type2d = 1, - Type3d = 2, +pub struct ImageType(pub i32); +impl ImageType { + pub const TYPE_1D: Self = ImageType(0); + pub const TYPE_2D: Self = ImageType(1); + pub const TYPE_3D: Self = ImageType(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ImageTiling { - Optimal = 0, - Linear = 1, +pub struct ImageTiling(pub i32); +impl ImageTiling { + pub const OPTIMAL: Self = ImageTiling(0); + pub const LINEAR: Self = ImageTiling(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ImageViewType { - Type1d = 0, - Type2d = 1, - Type3d = 2, - Cube = 3, - Type1dArray = 4, - Type2dArray = 5, - CubeArray = 6, +pub struct ImageViewType(pub i32); +impl ImageViewType { + pub const TYPE_1D: Self = ImageViewType(0); + pub const TYPE_2D: Self = ImageViewType(1); + pub const TYPE_3D: Self = ImageViewType(2); + pub const CUBE: Self = ImageViewType(3); + pub const TYPE_1D_ARRAY: Self = ImageViewType(4); + pub const TYPE_2D_ARRAY: Self = ImageViewType(5); + pub const CUBE_ARRAY: Self = ImageViewType(6); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum CommandBufferLevel { - Primary = 0, - Secondary = 1, +pub struct CommandBufferLevel(pub i32); +impl CommandBufferLevel { + pub const PRIMARY: Self = CommandBufferLevel(0); + pub const SECONDARY: Self = CommandBufferLevel(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ComponentSwizzle { - Identity = 0, - Zero = 1, - One = 2, - R = 3, - G = 4, - B = 5, - A = 6, +pub struct ComponentSwizzle(pub i32); +impl ComponentSwizzle { + pub const IDENTITY: Self = ComponentSwizzle(0); + pub const ZERO: Self = ComponentSwizzle(1); + pub const ONE: Self = ComponentSwizzle(2); + pub const R: Self = ComponentSwizzle(3); + pub const G: Self = ComponentSwizzle(4); + pub const B: Self = ComponentSwizzle(5); + pub const A: Self = ComponentSwizzle(6); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DescriptorType { - Sampler = 0, - CombinedImageSampler = 1, - SampledImage = 2, - StorageImage = 3, - UniformTexelBuffer = 4, - StorageTexelBuffer = 5, - UniformBuffer = 6, - StorageBuffer = 7, - UniformBufferDynamic = 8, - StorageBufferDynamic = 9, - InputAttachment = 10, +pub struct DescriptorType(pub i32); +impl DescriptorType { + pub const SAMPLER: Self = DescriptorType(0); + pub const COMBINED_IMAGE_SAMPLER: Self = DescriptorType(1); + pub const SAMPLED_IMAGE: Self = DescriptorType(2); + pub const STORAGE_IMAGE: Self = DescriptorType(3); + pub const UNIFORM_TEXEL_BUFFER: Self = DescriptorType(4); + pub const STORAGE_TEXEL_BUFFER: Self = DescriptorType(5); + pub const UNIFORM_BUFFER: Self = DescriptorType(6); + pub const STORAGE_BUFFER: Self = DescriptorType(7); + pub const UNIFORM_BUFFER_DYNAMIC: Self = DescriptorType(8); + pub const STORAGE_BUFFER_DYNAMIC: Self = DescriptorType(9); + pub const INPUT_ATTACHMENT: Self = DescriptorType(10); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum QueryType { - Occlusion = 0, - PipelineStatistics = 1, - Timestamp = 2, +pub struct QueryType(pub i32); +impl QueryType { + pub const OCCLUSION: Self = QueryType(0); + pub const PIPELINE_STATISTICS: Self = QueryType(1); + pub const TIMESTAMP: Self = QueryType(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum BorderColor { - FloatTransparentBlack = 0, - IntTransparentBlack = 1, - FloatOpaqueBlack = 2, - IntOpaqueBlack = 3, - FloatOpaqueWhite = 4, - IntOpaqueWhite = 5, +pub struct BorderColor(pub i32); +impl BorderColor { + pub const FLOAT_TRANSPARENT_BLACK: Self = BorderColor(0); + pub const INT_TRANSPARENT_BLACK: Self = BorderColor(1); + pub const FLOAT_OPAQUE_BLACK: Self = BorderColor(2); + pub const INT_OPAQUE_BLACK: Self = BorderColor(3); + pub const FLOAT_OPAQUE_WHITE: Self = BorderColor(4); + pub const INT_OPAQUE_WHITE: Self = BorderColor(5); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum PipelineBindPoint { - Graphics = 0, - Compute = 1, +pub struct PipelineBindPoint(pub i32); +impl PipelineBindPoint { + pub const GRAPHICS: Self = PipelineBindPoint(0); + pub const COMPUTE: Self = PipelineBindPoint(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum PipelineCacheHeaderVersion { - One = 1, +pub struct PipelineCacheHeaderVersion(pub i32); +impl PipelineCacheHeaderVersion { + pub const ONE: Self = PipelineCacheHeaderVersion(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum PrimitiveTopology { - PointList = 0, - LineList = 1, - LineStrip = 2, - TriangleList = 3, - TriangleStrip = 4, - TriangleFan = 5, - LineListWithAdjacency = 6, - LineStripWithAdjacency = 7, - TriangleListWithAdjacency = 8, - TriangleStripWithAdjacency = 9, - PatchList = 10, +pub struct PrimitiveTopology(pub i32); +impl PrimitiveTopology { + pub const POINT_LIST: Self = PrimitiveTopology(0); + pub const LINE_LIST: Self = PrimitiveTopology(1); + pub const LINE_STRIP: Self = PrimitiveTopology(2); + pub const TRIANGLE_LIST: Self = PrimitiveTopology(3); + pub const TRIANGLE_STRIP: Self = PrimitiveTopology(4); + pub const TRIANGLE_FAN: Self = PrimitiveTopology(5); + pub const LINE_LIST_WITH_ADJACENCY: Self = PrimitiveTopology(6); + pub const LINE_STRIP_WITH_ADJACENCY: Self = PrimitiveTopology(7); + pub const TRIANGLE_LIST_WITH_ADJACENCY: Self = PrimitiveTopology(8); + pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = PrimitiveTopology(9); + pub const PATCH_LIST: Self = PrimitiveTopology(10); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SharingMode { - Exclusive = 0, - Concurrent = 1, +pub struct SharingMode(pub i32); +impl SharingMode { + pub const EXCLUSIVE: Self = SharingMode(0); + pub const CONCURRENT: Self = SharingMode(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum IndexType { - Uint16 = 0, - Uint32 = 1, +pub struct IndexType(pub i32); +impl IndexType { + pub const UINT16: Self = IndexType(0); + pub const UINT32: Self = IndexType(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum Filter { - Nearest = 0, - Linear = 1, +pub struct Filter(pub i32); +impl Filter { + pub const NEAREST: Self = Filter(0); + pub const LINEAR: Self = Filter(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SamplerMipmapMode { - Nearest = 0, - Linear = 1, +pub struct SamplerMipmapMode(pub i32); +impl SamplerMipmapMode { + pub const NEAREST: Self = SamplerMipmapMode(0); + pub const LINEAR: Self = SamplerMipmapMode(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SamplerAddressMode { - Repeat = 0, - MirroredRepeat = 1, - ClampToEdge = 2, - ClampToBorder = 3, +pub struct SamplerAddressMode(pub i32); +impl SamplerAddressMode { + pub const REPEAT: Self = SamplerAddressMode(0); + pub const MIRRORED_REPEAT: Self = SamplerAddressMode(1); + pub const CLAMP_TO_EDGE: Self = SamplerAddressMode(2); + pub const CLAMP_TO_BORDER: Self = SamplerAddressMode(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum CompareOp { - Never = 0, - Less = 1, - Equal = 2, - LessOrEqual = 3, - Greater = 4, - NotEqual = 5, - GreaterOrEqual = 6, - Always = 7, +pub struct CompareOp(pub i32); +impl CompareOp { + pub const NEVER: Self = CompareOp(0); + pub const LESS: Self = CompareOp(1); + pub const EQUAL: Self = CompareOp(2); + pub const LESS_OR_EQUAL: Self = CompareOp(3); + pub const GREATER: Self = CompareOp(4); + pub const NOT_EQUAL: Self = CompareOp(5); + pub const GREATER_OR_EQUAL: Self = CompareOp(6); + pub const ALWAYS: Self = CompareOp(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum PolygonMode { - Fill = 0, - Line = 1, - Point = 2, +pub struct PolygonMode(pub i32); +impl PolygonMode { + pub const FILL: Self = PolygonMode(0); + pub const LINE: Self = PolygonMode(1); + pub const POINT: Self = PolygonMode(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum FrontFace { - CounterClockwise = 0, - Clockwise = 1, +pub struct FrontFace(pub i32); +impl FrontFace { + pub const COUNTER_CLOCKWISE: Self = FrontFace(0); + pub const CLOCKWISE: Self = FrontFace(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum BlendFactor { - Zero = 0, - One = 1, - SrcColor = 2, - OneMinusSrcColor = 3, - DstColor = 4, - OneMinusDstColor = 5, - SrcAlpha = 6, - OneMinusSrcAlpha = 7, - DstAlpha = 8, - OneMinusDstAlpha = 9, - ConstantColor = 10, - OneMinusConstantColor = 11, - ConstantAlpha = 12, - OneMinusConstantAlpha = 13, - SrcAlphaSaturate = 14, - Src1Color = 15, - OneMinusSrc1Color = 16, - Src1Alpha = 17, - OneMinusSrc1Alpha = 18, +pub struct BlendFactor(pub i32); +impl BlendFactor { + pub const ZERO: Self = BlendFactor(0); + pub const ONE: Self = BlendFactor(1); + pub const SRC_COLOR: Self = BlendFactor(2); + pub const ONE_MINUS_SRC_COLOR: Self = BlendFactor(3); + pub const DST_COLOR: Self = BlendFactor(4); + pub const ONE_MINUS_DST_COLOR: Self = BlendFactor(5); + pub const SRC_ALPHA: Self = BlendFactor(6); + pub const ONE_MINUS_SRC_ALPHA: Self = BlendFactor(7); + pub const DST_ALPHA: Self = BlendFactor(8); + pub const ONE_MINUS_DST_ALPHA: Self = BlendFactor(9); + pub const CONSTANT_COLOR: Self = BlendFactor(10); + pub const ONE_MINUS_CONSTANT_COLOR: Self = BlendFactor(11); + pub const CONSTANT_ALPHA: Self = BlendFactor(12); + pub const ONE_MINUS_CONSTANT_ALPHA: Self = BlendFactor(13); + pub const SRC_ALPHA_SATURATE: Self = BlendFactor(14); + pub const SRC1_COLOR: Self = BlendFactor(15); + pub const ONE_MINUS_SRC1_COLOR: Self = BlendFactor(16); + pub const SRC1_ALPHA: Self = BlendFactor(17); + pub const ONE_MINUS_SRC1_ALPHA: Self = BlendFactor(18); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum BlendOp { - Add = 0, - Subtract = 1, - ReverseSubtract = 2, - Min = 3, - Max = 4, +pub struct BlendOp(pub i32); +impl BlendOp { + pub const ADD: Self = BlendOp(0); + pub const SUBTRACT: Self = BlendOp(1); + pub const REVERSE_SUBTRACT: Self = BlendOp(2); + pub const MIN: Self = BlendOp(3); + pub const MAX: Self = BlendOp(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum StencilOp { - Keep = 0, - Zero = 1, - Replace = 2, - IncrementAndClamp = 3, - DecrementAndClamp = 4, - Invert = 5, - IncrementAndWrap = 6, - DecrementAndWrap = 7, +pub struct StencilOp(pub i32); +impl StencilOp { + pub const KEEP: Self = StencilOp(0); + pub const ZERO: Self = StencilOp(1); + pub const REPLACE: Self = StencilOp(2); + pub const INCREMENT_AND_CLAMP: Self = StencilOp(3); + pub const DECREMENT_AND_CLAMP: Self = StencilOp(4); + pub const INVERT: Self = StencilOp(5); + pub const INCREMENT_AND_WRAP: Self = StencilOp(6); + pub const DECREMENT_AND_WRAP: Self = StencilOp(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum LogicOp { - Clear = 0, - And = 1, - AndReverse = 2, - Copy = 3, - AndInverted = 4, - NoOp = 5, - Xor = 6, - Or = 7, - Nor = 8, - Equivalent = 9, - Invert = 10, - OrReverse = 11, - CopyInverted = 12, - OrInverted = 13, - Nand = 14, - Set = 15, +pub struct LogicOp(pub i32); +impl LogicOp { + pub const CLEAR: Self = LogicOp(0); + pub const AND: Self = LogicOp(1); + pub const AND_REVERSE: Self = LogicOp(2); + pub const COPY: Self = LogicOp(3); + pub const AND_INVERTED: Self = LogicOp(4); + pub const NO_OP: Self = LogicOp(5); + pub const XOR: Self = LogicOp(6); + pub const OR: Self = LogicOp(7); + pub const NOR: Self = LogicOp(8); + pub const EQUIVALENT: Self = LogicOp(9); + pub const INVERT: Self = LogicOp(10); + pub const OR_REVERSE: Self = LogicOp(11); + pub const COPY_INVERTED: Self = LogicOp(12); + pub const OR_INVERTED: Self = LogicOp(13); + pub const NAND: Self = LogicOp(14); + pub const SET: Self = LogicOp(15); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum InternalAllocationType { - Executable = 0, +pub struct InternalAllocationType(pub i32); +impl InternalAllocationType { + pub const EXECUTABLE: Self = InternalAllocationType(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SystemAllocationScope { - Command = 0, - Object = 1, - Cache = 2, - Device = 3, - Instance = 4, +pub struct SystemAllocationScope(pub i32); +impl SystemAllocationScope { + pub const COMMAND: Self = SystemAllocationScope(0); + pub const OBJECT: Self = SystemAllocationScope(1); + pub const CACHE: Self = SystemAllocationScope(2); + pub const DEVICE: Self = SystemAllocationScope(3); + pub const INSTANCE: Self = SystemAllocationScope(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum PhysicalDeviceType { - Other = 0, - IntegratedGpu = 1, - DiscreteGpu = 2, - VirtualGpu = 3, - Cpu = 4, +pub struct PhysicalDeviceType(pub i32); +impl PhysicalDeviceType { + pub const OTHER: Self = PhysicalDeviceType(0); + pub const INTEGRATED_GPU: Self = PhysicalDeviceType(1); + pub const DISCRETE_GPU: Self = PhysicalDeviceType(2); + pub const VIRTUAL_GPU: Self = PhysicalDeviceType(3); + pub const CPU: Self = PhysicalDeviceType(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum VertexInputRate { - Vertex = 0, - Instance = 1, +pub struct VertexInputRate(pub i32); +impl VertexInputRate { + pub const VERTEX: Self = VertexInputRate(0); + pub const INSTANCE: Self = VertexInputRate(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum Format { - Undefined = 0, - R4g4UnormPack8 = 1, - R4g4b4a4UnormPack16 = 2, - B4g4r4a4UnormPack16 = 3, - R5g6b5UnormPack16 = 4, - B5g6r5UnormPack16 = 5, - R5g5b5a1UnormPack16 = 6, - B5g5r5a1UnormPack16 = 7, - A1r5g5b5UnormPack16 = 8, - R8Unorm = 9, - R8Snorm = 10, - R8Uscaled = 11, - R8Sscaled = 12, - R8Uint = 13, - R8Sint = 14, - R8Srgb = 15, - R8g8Unorm = 16, - R8g8Snorm = 17, - R8g8Uscaled = 18, - R8g8Sscaled = 19, - R8g8Uint = 20, - R8g8Sint = 21, - R8g8Srgb = 22, - R8g8b8Unorm = 23, - R8g8b8Snorm = 24, - R8g8b8Uscaled = 25, - R8g8b8Sscaled = 26, - R8g8b8Uint = 27, - R8g8b8Sint = 28, - R8g8b8Srgb = 29, - B8g8r8Unorm = 30, - B8g8r8Snorm = 31, - B8g8r8Uscaled = 32, - B8g8r8Sscaled = 33, - B8g8r8Uint = 34, - B8g8r8Sint = 35, - B8g8r8Srgb = 36, - R8g8b8a8Unorm = 37, - R8g8b8a8Snorm = 38, - R8g8b8a8Uscaled = 39, - R8g8b8a8Sscaled = 40, - R8g8b8a8Uint = 41, - R8g8b8a8Sint = 42, - R8g8b8a8Srgb = 43, - B8g8r8a8Unorm = 44, - B8g8r8a8Snorm = 45, - B8g8r8a8Uscaled = 46, - B8g8r8a8Sscaled = 47, - B8g8r8a8Uint = 48, - B8g8r8a8Sint = 49, - B8g8r8a8Srgb = 50, - A8b8g8r8UnormPack32 = 51, - A8b8g8r8SnormPack32 = 52, - A8b8g8r8UscaledPack32 = 53, - A8b8g8r8SscaledPack32 = 54, - A8b8g8r8UintPack32 = 55, - A8b8g8r8SintPack32 = 56, - A8b8g8r8SrgbPack32 = 57, - A2r10g10b10UnormPack32 = 58, - A2r10g10b10SnormPack32 = 59, - A2r10g10b10UscaledPack32 = 60, - A2r10g10b10SscaledPack32 = 61, - A2r10g10b10UintPack32 = 62, - A2r10g10b10SintPack32 = 63, - A2b10g10r10UnormPack32 = 64, - A2b10g10r10SnormPack32 = 65, - A2b10g10r10UscaledPack32 = 66, - A2b10g10r10SscaledPack32 = 67, - A2b10g10r10UintPack32 = 68, - A2b10g10r10SintPack32 = 69, - R16Unorm = 70, - R16Snorm = 71, - R16Uscaled = 72, - R16Sscaled = 73, - R16Uint = 74, - R16Sint = 75, - R16Sfloat = 76, - R16g16Unorm = 77, - R16g16Snorm = 78, - R16g16Uscaled = 79, - R16g16Sscaled = 80, - R16g16Uint = 81, - R16g16Sint = 82, - R16g16Sfloat = 83, - R16g16b16Unorm = 84, - R16g16b16Snorm = 85, - R16g16b16Uscaled = 86, - R16g16b16Sscaled = 87, - R16g16b16Uint = 88, - R16g16b16Sint = 89, - R16g16b16Sfloat = 90, - R16g16b16a16Unorm = 91, - R16g16b16a16Snorm = 92, - R16g16b16a16Uscaled = 93, - R16g16b16a16Sscaled = 94, - R16g16b16a16Uint = 95, - R16g16b16a16Sint = 96, - R16g16b16a16Sfloat = 97, - R32Uint = 98, - R32Sint = 99, - R32Sfloat = 100, - R32g32Uint = 101, - R32g32Sint = 102, - R32g32Sfloat = 103, - R32g32b32Uint = 104, - R32g32b32Sint = 105, - R32g32b32Sfloat = 106, - R32g32b32a32Uint = 107, - R32g32b32a32Sint = 108, - R32g32b32a32Sfloat = 109, - R64Uint = 110, - R64Sint = 111, - R64Sfloat = 112, - R64g64Uint = 113, - R64g64Sint = 114, - R64g64Sfloat = 115, - R64g64b64Uint = 116, - R64g64b64Sint = 117, - R64g64b64Sfloat = 118, - R64g64b64a64Uint = 119, - R64g64b64a64Sint = 120, - R64g64b64a64Sfloat = 121, - B10g11r11UfloatPack32 = 122, - E5b9g9r9UfloatPack32 = 123, - D16Unorm = 124, - X8D24UnormPack32 = 125, - D32Sfloat = 126, - S8Uint = 127, - D16UnormS8Uint = 128, - D24UnormS8Uint = 129, - D32SfloatS8Uint = 130, - Bc1RgbUnormBlock = 131, - Bc1RgbSrgbBlock = 132, - Bc1RgbaUnormBlock = 133, - Bc1RgbaSrgbBlock = 134, - Bc2UnormBlock = 135, - Bc2SrgbBlock = 136, - Bc3UnormBlock = 137, - Bc3SrgbBlock = 138, - Bc4UnormBlock = 139, - Bc4SnormBlock = 140, - Bc5UnormBlock = 141, - Bc5SnormBlock = 142, - Bc6hUfloatBlock = 143, - Bc6hSfloatBlock = 144, - Bc7UnormBlock = 145, - Bc7SrgbBlock = 146, - Etc2R8g8b8UnormBlock = 147, - Etc2R8g8b8SrgbBlock = 148, - Etc2R8g8b8a1UnormBlock = 149, - Etc2R8g8b8a1SrgbBlock = 150, - Etc2R8g8b8a8UnormBlock = 151, - Etc2R8g8b8a8SrgbBlock = 152, - EacR11UnormBlock = 153, - EacR11SnormBlock = 154, - EacR11g11UnormBlock = 155, - EacR11g11SnormBlock = 156, - Astc4x4UnormBlock = 157, - Astc4x4SrgbBlock = 158, - Astc5x4UnormBlock = 159, - Astc5x4SrgbBlock = 160, - Astc5x5UnormBlock = 161, - Astc5x5SrgbBlock = 162, - Astc6x5UnormBlock = 163, - Astc6x5SrgbBlock = 164, - Astc6x6UnormBlock = 165, - Astc6x6SrgbBlock = 166, - Astc8x5UnormBlock = 167, - Astc8x5SrgbBlock = 168, - Astc8x6UnormBlock = 169, - Astc8x6SrgbBlock = 170, - Astc8x8UnormBlock = 171, - Astc8x8SrgbBlock = 172, - Astc10x5UnormBlock = 173, - Astc10x5SrgbBlock = 174, - Astc10x6UnormBlock = 175, - Astc10x6SrgbBlock = 176, - Astc10x8UnormBlock = 177, - Astc10x8SrgbBlock = 178, - Astc10x10UnormBlock = 179, - Astc10x10SrgbBlock = 180, - Astc12x10UnormBlock = 181, - Astc12x10SrgbBlock = 182, - Astc12x12UnormBlock = 183, - Astc12x12SrgbBlock = 184, +pub struct Format(pub i32); +impl Format { + pub const UNDEFINED: Self = Format(0); + pub const R4G4_UNORM_PACK8: Self = Format(1); + pub const R4G4B4A4_UNORM_PACK16: Self = Format(2); + pub const B4G4R4A4_UNORM_PACK16: Self = Format(3); + pub const R5G6B5_UNORM_PACK16: Self = Format(4); + pub const B5G6R5_UNORM_PACK16: Self = Format(5); + pub const R5G5B5A1_UNORM_PACK16: Self = Format(6); + pub const B5G5R5A1_UNORM_PACK16: Self = Format(7); + pub const A1R5G5B5_UNORM_PACK16: Self = Format(8); + pub const R8_UNORM: Self = Format(9); + pub const R8_SNORM: Self = Format(10); + pub const R8_USCALED: Self = Format(11); + pub const R8_SSCALED: Self = Format(12); + pub const R8_UINT: Self = Format(13); + pub const R8_SINT: Self = Format(14); + pub const R8_SRGB: Self = Format(15); + pub const R8G8_UNORM: Self = Format(16); + pub const R8G8_SNORM: Self = Format(17); + pub const R8G8_USCALED: Self = Format(18); + pub const R8G8_SSCALED: Self = Format(19); + pub const R8G8_UINT: Self = Format(20); + pub const R8G8_SINT: Self = Format(21); + pub const R8G8_SRGB: Self = Format(22); + pub const R8G8B8_UNORM: Self = Format(23); + pub const R8G8B8_SNORM: Self = Format(24); + pub const R8G8B8_USCALED: Self = Format(25); + pub const R8G8B8_SSCALED: Self = Format(26); + pub const R8G8B8_UINT: Self = Format(27); + pub const R8G8B8_SINT: Self = Format(28); + pub const R8G8B8_SRGB: Self = Format(29); + pub const B8G8R8_UNORM: Self = Format(30); + pub const B8G8R8_SNORM: Self = Format(31); + pub const B8G8R8_USCALED: Self = Format(32); + pub const B8G8R8_SSCALED: Self = Format(33); + pub const B8G8R8_UINT: Self = Format(34); + pub const B8G8R8_SINT: Self = Format(35); + pub const B8G8R8_SRGB: Self = Format(36); + pub const R8G8B8A8_UNORM: Self = Format(37); + pub const R8G8B8A8_SNORM: Self = Format(38); + pub const R8G8B8A8_USCALED: Self = Format(39); + pub const R8G8B8A8_SSCALED: Self = Format(40); + pub const R8G8B8A8_UINT: Self = Format(41); + pub const R8G8B8A8_SINT: Self = Format(42); + pub const R8G8B8A8_SRGB: Self = Format(43); + pub const B8G8R8A8_UNORM: Self = Format(44); + pub const B8G8R8A8_SNORM: Self = Format(45); + pub const B8G8R8A8_USCALED: Self = Format(46); + pub const B8G8R8A8_SSCALED: Self = Format(47); + pub const B8G8R8A8_UINT: Self = Format(48); + pub const B8G8R8A8_SINT: Self = Format(49); + pub const B8G8R8A8_SRGB: Self = Format(50); + pub const A8B8G8R8_UNORM_PACK32: Self = Format(51); + pub const A8B8G8R8_SNORM_PACK32: Self = Format(52); + pub const A8B8G8R8_USCALED_PACK32: Self = Format(53); + pub const A8B8G8R8_SSCALED_PACK32: Self = Format(54); + pub const A8B8G8R8_UINT_PACK32: Self = Format(55); + pub const A8B8G8R8_SINT_PACK32: Self = Format(56); + pub const A8B8G8R8_SRGB_PACK32: Self = Format(57); + pub const A2R10G10B10_UNORM_PACK32: Self = Format(58); + pub const A2R10G10B10_SNORM_PACK32: Self = Format(59); + pub const A2R10G10B10_USCALED_PACK32: Self = Format(60); + pub const A2R10G10B10_SSCALED_PACK32: Self = Format(61); + pub const A2R10G10B10_UINT_PACK32: Self = Format(62); + pub const A2R10G10B10_SINT_PACK32: Self = Format(63); + pub const A2B10G10R10_UNORM_PACK32: Self = Format(64); + pub const A2B10G10R10_SNORM_PACK32: Self = Format(65); + pub const A2B10G10R10_USCALED_PACK32: Self = Format(66); + pub const A2B10G10R10_SSCALED_PACK32: Self = Format(67); + pub const A2B10G10R10_UINT_PACK32: Self = Format(68); + pub const A2B10G10R10_SINT_PACK32: Self = Format(69); + pub const R16_UNORM: Self = Format(70); + pub const R16_SNORM: Self = Format(71); + pub const R16_USCALED: Self = Format(72); + pub const R16_SSCALED: Self = Format(73); + pub const R16_UINT: Self = Format(74); + pub const R16_SINT: Self = Format(75); + pub const R16_SFLOAT: Self = Format(76); + pub const R16G16_UNORM: Self = Format(77); + pub const R16G16_SNORM: Self = Format(78); + pub const R16G16_USCALED: Self = Format(79); + pub const R16G16_SSCALED: Self = Format(80); + pub const R16G16_UINT: Self = Format(81); + pub const R16G16_SINT: Self = Format(82); + pub const R16G16_SFLOAT: Self = Format(83); + pub const R16G16B16_UNORM: Self = Format(84); + pub const R16G16B16_SNORM: Self = Format(85); + pub const R16G16B16_USCALED: Self = Format(86); + pub const R16G16B16_SSCALED: Self = Format(87); + pub const R16G16B16_UINT: Self = Format(88); + pub const R16G16B16_SINT: Self = Format(89); + pub const R16G16B16_SFLOAT: Self = Format(90); + pub const R16G16B16A16_UNORM: Self = Format(91); + pub const R16G16B16A16_SNORM: Self = Format(92); + pub const R16G16B16A16_USCALED: Self = Format(93); + pub const R16G16B16A16_SSCALED: Self = Format(94); + pub const R16G16B16A16_UINT: Self = Format(95); + pub const R16G16B16A16_SINT: Self = Format(96); + pub const R16G16B16A16_SFLOAT: Self = Format(97); + pub const R32_UINT: Self = Format(98); + pub const R32_SINT: Self = Format(99); + pub const R32_SFLOAT: Self = Format(100); + pub const R32G32_UINT: Self = Format(101); + pub const R32G32_SINT: Self = Format(102); + pub const R32G32_SFLOAT: Self = Format(103); + pub const R32G32B32_UINT: Self = Format(104); + pub const R32G32B32_SINT: Self = Format(105); + pub const R32G32B32_SFLOAT: Self = Format(106); + pub const R32G32B32A32_UINT: Self = Format(107); + pub const R32G32B32A32_SINT: Self = Format(108); + pub const R32G32B32A32_SFLOAT: Self = Format(109); + pub const R64_UINT: Self = Format(110); + pub const R64_SINT: Self = Format(111); + pub const R64_SFLOAT: Self = Format(112); + pub const R64G64_UINT: Self = Format(113); + pub const R64G64_SINT: Self = Format(114); + pub const R64G64_SFLOAT: Self = Format(115); + pub const R64G64B64_UINT: Self = Format(116); + pub const R64G64B64_SINT: Self = Format(117); + pub const R64G64B64_SFLOAT: Self = Format(118); + pub const R64G64B64A64_UINT: Self = Format(119); + pub const R64G64B64A64_SINT: Self = Format(120); + pub const R64G64B64A64_SFLOAT: Self = Format(121); + pub const B10G11R11_UFLOAT_PACK32: Self = Format(122); + pub const E5B9G9R9_UFLOAT_PACK32: Self = Format(123); + pub const D16_UNORM: Self = Format(124); + pub const X8_D24_UNORM_PACK32: Self = Format(125); + pub const D32_SFLOAT: Self = Format(126); + pub const S8_UINT: Self = Format(127); + pub const D16_UNORM_S8_UINT: Self = Format(128); + pub const D24_UNORM_S8_UINT: Self = Format(129); + pub const D32_SFLOAT_S8_UINT: Self = Format(130); + pub const BC1_RGB_UNORM_BLOCK: Self = Format(131); + pub const BC1_RGB_SRGB_BLOCK: Self = Format(132); + pub const BC1_RGBA_UNORM_BLOCK: Self = Format(133); + pub const BC1_RGBA_SRGB_BLOCK: Self = Format(134); + pub const BC2_UNORM_BLOCK: Self = Format(135); + pub const BC2_SRGB_BLOCK: Self = Format(136); + pub const BC3_UNORM_BLOCK: Self = Format(137); + pub const BC3_SRGB_BLOCK: Self = Format(138); + pub const BC4_UNORM_BLOCK: Self = Format(139); + pub const BC4_SNORM_BLOCK: Self = Format(140); + pub const BC5_UNORM_BLOCK: Self = Format(141); + pub const BC5_SNORM_BLOCK: Self = Format(142); + pub const BC6H_UFLOAT_BLOCK: Self = Format(143); + pub const BC6H_SFLOAT_BLOCK: Self = Format(144); + pub const BC7_UNORM_BLOCK: Self = Format(145); + pub const BC7_SRGB_BLOCK: Self = Format(146); + pub const ETC2_R8G8B8_UNORM_BLOCK: Self = Format(147); + pub const ETC2_R8G8B8_SRGB_BLOCK: Self = Format(148); + pub const ETC2_R8G8B8A1_UNORM_BLOCK: Self = Format(149); + pub const ETC2_R8G8B8A1_SRGB_BLOCK: Self = Format(150); + pub const ETC2_R8G8B8A8_UNORM_BLOCK: Self = Format(151); + pub const ETC2_R8G8B8A8_SRGB_BLOCK: Self = Format(152); + pub const EAC_R11_UNORM_BLOCK: Self = Format(153); + pub const EAC_R11_SNORM_BLOCK: Self = Format(154); + pub const EAC_R11G11_UNORM_BLOCK: Self = Format(155); + pub const EAC_R11G11_SNORM_BLOCK: Self = Format(156); + pub const ASTC_4X4_UNORM_BLOCK: Self = Format(157); + pub const ASTC_4X4_SRGB_BLOCK: Self = Format(158); + pub const ASTC_5X4_UNORM_BLOCK: Self = Format(159); + pub const ASTC_5X4_SRGB_BLOCK: Self = Format(160); + pub const ASTC_5X5_UNORM_BLOCK: Self = Format(161); + pub const ASTC_5X5_SRGB_BLOCK: Self = Format(162); + pub const ASTC_6X5_UNORM_BLOCK: Self = Format(163); + pub const ASTC_6X5_SRGB_BLOCK: Self = Format(164); + pub const ASTC_6X6_UNORM_BLOCK: Self = Format(165); + pub const ASTC_6X6_SRGB_BLOCK: Self = Format(166); + pub const ASTC_8X5_UNORM_BLOCK: Self = Format(167); + pub const ASTC_8X5_SRGB_BLOCK: Self = Format(168); + pub const ASTC_8X6_UNORM_BLOCK: Self = Format(169); + pub const ASTC_8X6_SRGB_BLOCK: Self = Format(170); + pub const ASTC_8X8_UNORM_BLOCK: Self = Format(171); + pub const ASTC_8X8_SRGB_BLOCK: Self = Format(172); + pub const ASTC_10X5_UNORM_BLOCK: Self = Format(173); + pub const ASTC_10X5_SRGB_BLOCK: Self = Format(174); + pub const ASTC_10X6_UNORM_BLOCK: Self = Format(175); + pub const ASTC_10X6_SRGB_BLOCK: Self = Format(176); + pub const ASTC_10X8_UNORM_BLOCK: Self = Format(177); + pub const ASTC_10X8_SRGB_BLOCK: Self = Format(178); + pub const ASTC_10X10_UNORM_BLOCK: Self = Format(179); + pub const ASTC_10X10_SRGB_BLOCK: Self = Format(180); + pub const ASTC_12X10_UNORM_BLOCK: Self = Format(181); + pub const ASTC_12X10_SRGB_BLOCK: Self = Format(182); + pub const ASTC_12X12_UNORM_BLOCK: Self = Format(183); + pub const ASTC_12X12_SRGB_BLOCK: Self = Format(184); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum StructureType { - ApplicationInfo = 0, - InstanceCreateInfo = 1, - DeviceQueueCreateInfo = 2, - DeviceCreateInfo = 3, - SubmitInfo = 4, - MemoryAllocateInfo = 5, - MappedMemoryRange = 6, - BindSparseInfo = 7, - FenceCreateInfo = 8, - SemaphoreCreateInfo = 9, - EventCreateInfo = 10, - QueryPoolCreateInfo = 11, - BufferCreateInfo = 12, - BufferViewCreateInfo = 13, - ImageCreateInfo = 14, - ImageViewCreateInfo = 15, - ShaderModuleCreateInfo = 16, - PipelineCacheCreateInfo = 17, - PipelineShaderStageCreateInfo = 18, - PipelineVertexInputStateCreateInfo = 19, - PipelineInputAssemblyStateCreateInfo = 20, - PipelineTessellationStateCreateInfo = 21, - PipelineViewportStateCreateInfo = 22, - PipelineRasterizationStateCreateInfo = 23, - PipelineMultisampleStateCreateInfo = 24, - PipelineDepthStencilStateCreateInfo = 25, - PipelineColorBlendStateCreateInfo = 26, - PipelineDynamicStateCreateInfo = 27, - GraphicsPipelineCreateInfo = 28, - ComputePipelineCreateInfo = 29, - PipelineLayoutCreateInfo = 30, - SamplerCreateInfo = 31, - DescriptorSetLayoutCreateInfo = 32, - DescriptorPoolCreateInfo = 33, - DescriptorSetAllocateInfo = 34, - WriteDescriptorSet = 35, - CopyDescriptorSet = 36, - FramebufferCreateInfo = 37, - RenderPassCreateInfo = 38, - CommandPoolCreateInfo = 39, - CommandBufferAllocateInfo = 40, - CommandBufferInheritanceInfo = 41, - CommandBufferBeginInfo = 42, - RenderPassBeginInfo = 43, - BufferMemoryBarrier = 44, - ImageMemoryBarrier = 45, - MemoryBarrier = 46, - LoaderInstanceCreateInfo = 47, - LoaderDeviceCreateInfo = 48, +pub struct StructureType(pub i32); +impl StructureType { + pub const APPLICATION_INFO: Self = StructureType(0); + pub const INSTANCE_CREATE_INFO: Self = StructureType(1); + pub const DEVICE_QUEUE_CREATE_INFO: Self = StructureType(2); + pub const DEVICE_CREATE_INFO: Self = StructureType(3); + pub const SUBMIT_INFO: Self = StructureType(4); + pub const MEMORY_ALLOCATE_INFO: Self = StructureType(5); + pub const MAPPED_MEMORY_RANGE: Self = StructureType(6); + pub const BIND_SPARSE_INFO: Self = StructureType(7); + pub const FENCE_CREATE_INFO: Self = StructureType(8); + pub const SEMAPHORE_CREATE_INFO: Self = StructureType(9); + pub const EVENT_CREATE_INFO: Self = StructureType(10); + pub const QUERY_POOL_CREATE_INFO: Self = StructureType(11); + pub const BUFFER_CREATE_INFO: Self = StructureType(12); + pub const BUFFER_VIEW_CREATE_INFO: Self = StructureType(13); + pub const IMAGE_CREATE_INFO: Self = StructureType(14); + pub const IMAGE_VIEW_CREATE_INFO: Self = StructureType(15); + pub const SHADER_MODULE_CREATE_INFO: Self = StructureType(16); + pub const PIPELINE_CACHE_CREATE_INFO: Self = StructureType(17); + pub const PIPELINE_SHADER_STAGE_CREATE_INFO: Self = StructureType(18); + pub const PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: Self = StructureType(19); + pub const PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: Self = StructureType(20); + pub const PIPELINE_TESSELLATION_STATE_CREATE_INFO: Self = StructureType(21); + pub const PIPELINE_VIEWPORT_STATE_CREATE_INFO: Self = StructureType(22); + pub const PIPELINE_RASTERIZATION_STATE_CREATE_INFO: Self = StructureType(23); + pub const PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: Self = StructureType(24); + pub const PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: Self = StructureType(25); + pub const PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: Self = StructureType(26); + pub const PIPELINE_DYNAMIC_STATE_CREATE_INFO: Self = StructureType(27); + pub const GRAPHICS_PIPELINE_CREATE_INFO: Self = StructureType(28); + pub const COMPUTE_PIPELINE_CREATE_INFO: Self = StructureType(29); + pub const PIPELINE_LAYOUT_CREATE_INFO: Self = StructureType(30); + pub const SAMPLER_CREATE_INFO: Self = StructureType(31); + pub const DESCRIPTOR_SET_LAYOUT_CREATE_INFO: Self = StructureType(32); + pub const DESCRIPTOR_POOL_CREATE_INFO: Self = StructureType(33); + pub const DESCRIPTOR_SET_ALLOCATE_INFO: Self = StructureType(34); + pub const WRITE_DESCRIPTOR_SET: Self = StructureType(35); + pub const COPY_DESCRIPTOR_SET: Self = StructureType(36); + pub const FRAMEBUFFER_CREATE_INFO: Self = StructureType(37); + pub const RENDER_PASS_CREATE_INFO: Self = StructureType(38); + pub const COMMAND_POOL_CREATE_INFO: Self = StructureType(39); + pub const COMMAND_BUFFER_ALLOCATE_INFO: Self = StructureType(40); + pub const COMMAND_BUFFER_INHERITANCE_INFO: Self = StructureType(41); + pub const COMMAND_BUFFER_BEGIN_INFO: Self = StructureType(42); + pub const RENDER_PASS_BEGIN_INFO: Self = StructureType(43); + pub const BUFFER_MEMORY_BARRIER: Self = StructureType(44); + pub const IMAGE_MEMORY_BARRIER: Self = StructureType(45); + pub const MEMORY_BARRIER: Self = StructureType(46); + pub const LOADER_INSTANCE_CREATE_INFO: Self = StructureType(47); + pub const LOADER_DEVICE_CREATE_INFO: Self = StructureType(48); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SubpassContents { - Inline = 0, - SecondaryCommandBuffers = 1, +pub struct SubpassContents(pub i32); +impl SubpassContents { + pub const INLINE: Self = SubpassContents(0); + pub const SECONDARY_COMMAND_BUFFERS: Self = SubpassContents(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum Result { - Success = 0, - NotReady = 1, - Timeout = 2, - EventSet = 3, - EventReset = 4, - Incomplete = 5, - ErrorOutOfHostMemory = -1, - ErrorOutOfDeviceMemory = -2, - ErrorInitializationFailed = -3, - ErrorDeviceLost = -4, - ErrorMemoryMapFailed = -5, - ErrorLayerNotPresent = -6, - ErrorExtensionNotPresent = -7, - ErrorFeatureNotPresent = -8, - ErrorIncompatibleDriver = -9, - ErrorTooManyObjects = -10, - ErrorFormatNotSupported = -11, - ErrorFragmentedPool = -12, +pub struct Result(pub i32); +impl Result { + pub const SUCCESS: Self = Result(0); + pub const NOT_READY: Self = Result(1); + pub const TIMEOUT: Self = Result(2); + pub const EVENT_SET: Self = Result(3); + pub const EVENT_RESET: Self = Result(4); + pub const INCOMPLETE: Self = Result(5); + pub const ERROR_OUT_OF_HOST_MEMORY: Self = Result(-1); + pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Result(-2); + pub const ERROR_INITIALIZATION_FAILED: Self = Result(-3); + pub const ERROR_DEVICE_LOST: Self = Result(-4); + pub const ERROR_MEMORY_MAP_FAILED: Self = Result(-5); + pub const ERROR_LAYER_NOT_PRESENT: Self = Result(-6); + pub const ERROR_EXTENSION_NOT_PRESENT: Self = Result(-7); + pub const ERROR_FEATURE_NOT_PRESENT: Self = Result(-8); + pub const ERROR_INCOMPATIBLE_DRIVER: Self = Result(-9); + pub const ERROR_TOO_MANY_OBJECTS: Self = Result(-10); + pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Result(-11); + pub const ERROR_FRAGMENTED_POOL: Self = Result(-12); } impl ::std::error::Error for Result { fn description(&self) -> &str { @@ -8543,767 +8802,1085 @@ impl ::std::error::Error for Result { impl ::std::fmt::Display for Result { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { writeln!(fmt, "vk::Result::{:?}", self)?; - match self { - Result::Success => write!(fmt, "Command completed successfully"), - Result::NotReady => write!(fmt, "A fence or query has not yet completed"), - Result::Timeout => write!( + match *self { + Result::SUCCESS => write!(fmt, "Command completed successfully"), + Result::NOT_READY => write!(fmt, "A fence or query has not yet completed"), + Result::TIMEOUT => write!( fmt, "A wait operation has not completed in the specified time" ), - Result::EventSet => write!(fmt, "An event is signaled"), - Result::EventReset => write!(fmt, "An event is unsignaled"), - Result::Incomplete => write!(fmt, "A return array was too small for the result"), - Result::ErrorOutOfHostMemory => write!(fmt, "A host memory allocation has failed"), - Result::ErrorOutOfDeviceMemory => write!(fmt, "A device memory allocation has failed"), - Result::ErrorInitializationFailed => { + Result::EVENT_SET => write!(fmt, "An event is signaled"), + Result::EVENT_RESET => write!(fmt, "An event is unsignaled"), + Result::INCOMPLETE => write!(fmt, "A return array was too small for the result"), + Result::ERROR_OUT_OF_HOST_MEMORY => write!(fmt, "A host memory allocation has failed"), + Result::ERROR_OUT_OF_DEVICE_MEMORY => { + write!(fmt, "A device memory allocation has failed") + } + Result::ERROR_INITIALIZATION_FAILED => { write!(fmt, "Initialization of a object has failed") } - Result::ErrorDeviceLost => write!( + Result::ERROR_DEVICE_LOST => write!( fmt, "The logical device has been lost. See <>" ), - Result::ErrorMemoryMapFailed => write!(fmt, "Mapping of a memory object has failed"), - Result::ErrorLayerNotPresent => write!(fmt, "Layer specified does not exist"), - Result::ErrorExtensionNotPresent => write!(fmt, "Extension specified does not exist"), - Result::ErrorFeatureNotPresent => { + Result::ERROR_MEMORY_MAP_FAILED => write!(fmt, "Mapping of a memory object has failed"), + Result::ERROR_LAYER_NOT_PRESENT => write!(fmt, "Layer specified does not exist"), + Result::ERROR_EXTENSION_NOT_PRESENT => { + write!(fmt, "Extension specified does not exist") + } + Result::ERROR_FEATURE_NOT_PRESENT => { write!(fmt, "Requested feature is not available on this device") } - Result::ErrorIncompatibleDriver => write!(fmt, "Unable to find a Vulkan driver"), - Result::ErrorTooManyObjects => write!( + Result::ERROR_INCOMPATIBLE_DRIVER => write!(fmt, "Unable to find a Vulkan driver"), + Result::ERROR_TOO_MANY_OBJECTS => write!( fmt, "Too many objects of the type have already been created" ), - Result::ErrorFormatNotSupported => { + Result::ERROR_FORMAT_NOT_SUPPORTED => { write!(fmt, "Requested format is not supported on this device") } - Result::ErrorFragmentedPool => write!( + Result::ERROR_FRAGMENTED_POOL => write!( fmt, "A requested pool allocation has failed due to fragmentation of the pool\'s memory" ), + _ => write!(fmt, "Unknown variant"), } } } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DynamicState { - Viewport = 0, - Scissor = 1, - LineWidth = 2, - DepthBias = 3, - BlendConstants = 4, - DepthBounds = 5, - StencilCompareMask = 6, - StencilWriteMask = 7, - StencilReference = 8, +pub struct DynamicState(pub i32); +impl DynamicState { + pub const VIEWPORT: Self = DynamicState(0); + pub const SCISSOR: Self = DynamicState(1); + pub const LINE_WIDTH: Self = DynamicState(2); + pub const DEPTH_BIAS: Self = DynamicState(3); + pub const BLEND_CONSTANTS: Self = DynamicState(4); + pub const DEPTH_BOUNDS: Self = DynamicState(5); + pub const STENCIL_COMPARE_MASK: Self = DynamicState(6); + pub const STENCIL_WRITE_MASK: Self = DynamicState(7); + pub const STENCIL_REFERENCE: Self = DynamicState(8); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DescriptorUpdateTemplateType { - DescriptorSet = 0, +pub struct DescriptorUpdateTemplateType(pub i32); +impl DescriptorUpdateTemplateType { + pub const DESCRIPTOR_SET: Self = DescriptorUpdateTemplateType(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ObjectType { - Unknown = 0, - Instance = 1, - PhysicalDevice = 2, - Device = 3, - Queue = 4, - Semaphore = 5, - CommandBuffer = 6, - Fence = 7, - DeviceMemory = 8, - Buffer = 9, - Image = 10, - Event = 11, - QueryPool = 12, - BufferView = 13, - ImageView = 14, - ShaderModule = 15, - PipelineCache = 16, - PipelineLayout = 17, - RenderPass = 18, - Pipeline = 19, - DescriptorSetLayout = 20, - Sampler = 21, - DescriptorPool = 22, - DescriptorSet = 23, - Framebuffer = 24, - CommandPool = 25, +pub struct ObjectType(pub i32); +impl ObjectType { + pub const UNKNOWN: Self = ObjectType(0); + pub const INSTANCE: Self = ObjectType(1); + pub const PHYSICAL_DEVICE: Self = ObjectType(2); + pub const DEVICE: Self = ObjectType(3); + pub const QUEUE: Self = ObjectType(4); + pub const SEMAPHORE: Self = ObjectType(5); + pub const COMMAND_BUFFER: Self = ObjectType(6); + pub const FENCE: Self = ObjectType(7); + pub const DEVICE_MEMORY: Self = ObjectType(8); + pub const BUFFER: Self = ObjectType(9); + pub const IMAGE: Self = ObjectType(10); + pub const EVENT: Self = ObjectType(11); + pub const QUERY_POOL: Self = ObjectType(12); + pub const BUFFER_VIEW: Self = ObjectType(13); + pub const IMAGE_VIEW: Self = ObjectType(14); + pub const SHADER_MODULE: Self = ObjectType(15); + pub const PIPELINE_CACHE: Self = ObjectType(16); + pub const PIPELINE_LAYOUT: Self = ObjectType(17); + pub const RENDER_PASS: Self = ObjectType(18); + pub const PIPELINE: Self = ObjectType(19); + pub const DESCRIPTOR_SET_LAYOUT: Self = ObjectType(20); + pub const SAMPLER: Self = ObjectType(21); + pub const DESCRIPTOR_POOL: Self = ObjectType(22); + pub const DESCRIPTOR_SET: Self = ObjectType(23); + pub const FRAMEBUFFER: Self = ObjectType(24); + pub const COMMAND_POOL: Self = ObjectType(25); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum PresentModeKHR { - Immediate = 0, - Mailbox = 1, - Fifo = 2, - FifoRelaxed = 3, +pub struct PresentModeKHR(pub i32); +impl PresentModeKHR { + pub const PRESENT_MODE_IMMEDIATE_KHR: Self = PresentModeKHR(0); + pub const PRESENT_MODE_MAILBOX_KHR: Self = PresentModeKHR(1); + pub const PRESENT_MODE_FIFO_KHR: Self = PresentModeKHR(2); + pub const PRESENT_MODE_FIFO_RELAXED_KHR: Self = PresentModeKHR(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ColorSpaceKHR { - SrgbNonlinear = 0, +pub struct ColorSpaceKHR(pub i32); +impl ColorSpaceKHR { + pub const COLOR_SPACE_SRGB_NONLINEAR_KHR: Self = ColorSpaceKHR(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DebugReportObjectTypeEXT { - Unknown = 0, - Instance = 1, - PhysicalDevice = 2, - Device = 3, - Queue = 4, - Semaphore = 5, - CommandBuffer = 6, - Fence = 7, - DeviceMemory = 8, - Buffer = 9, - Image = 10, - Event = 11, - QueryPool = 12, - BufferView = 13, - ImageView = 14, - ShaderModule = 15, - PipelineCache = 16, - PipelineLayout = 17, - RenderPass = 18, - Pipeline = 19, - DescriptorSetLayout = 20, - Sampler = 21, - DescriptorPool = 22, - DescriptorSet = 23, - Framebuffer = 24, - CommandPool = 25, - SurfaceKhr = 26, - SwapchainKhr = 27, - DebugReportCallback = 28, - DisplayKhr = 29, - DisplayModeKhr = 30, - ObjectTableNvx = 31, - IndirectCommandsLayoutNvx = 32, - ValidationCache = 33, +pub struct DebugReportObjectTypeEXT(pub i32); +impl DebugReportObjectTypeEXT { + pub const DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: Self = DebugReportObjectTypeEXT(0); + pub const DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: Self = DebugReportObjectTypeEXT(1); + pub const DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: Self = DebugReportObjectTypeEXT(2); + pub const DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: Self = DebugReportObjectTypeEXT(3); + pub const DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: Self = DebugReportObjectTypeEXT(4); + pub const DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: Self = DebugReportObjectTypeEXT(5); + pub const DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: Self = DebugReportObjectTypeEXT(6); + pub const DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: Self = DebugReportObjectTypeEXT(7); + pub const DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: Self = DebugReportObjectTypeEXT(8); + pub const DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: Self = DebugReportObjectTypeEXT(9); + pub const DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: Self = DebugReportObjectTypeEXT(10); + pub const DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: Self = DebugReportObjectTypeEXT(11); + pub const DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: Self = DebugReportObjectTypeEXT(12); + pub const DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: Self = DebugReportObjectTypeEXT(13); + pub const DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: Self = DebugReportObjectTypeEXT(14); + pub const DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: Self = DebugReportObjectTypeEXT(15); + pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: Self = DebugReportObjectTypeEXT(16); + pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: Self = DebugReportObjectTypeEXT(17); + pub const DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: Self = DebugReportObjectTypeEXT(18); + pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: Self = DebugReportObjectTypeEXT(19); + pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: Self = + DebugReportObjectTypeEXT(20); + pub const DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: Self = DebugReportObjectTypeEXT(21); + pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: Self = DebugReportObjectTypeEXT(22); + pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: Self = DebugReportObjectTypeEXT(23); + pub const DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: Self = DebugReportObjectTypeEXT(24); + pub const DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: Self = DebugReportObjectTypeEXT(25); + pub const DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: Self = DebugReportObjectTypeEXT(26); + pub const DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: Self = DebugReportObjectTypeEXT(27); + pub const DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: Self = + DebugReportObjectTypeEXT(28); + pub const DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: Self = DebugReportObjectTypeEXT(29); + pub const DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: Self = DebugReportObjectTypeEXT(30); + pub const DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT: Self = DebugReportObjectTypeEXT(31); + pub const DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT: Self = + DebugReportObjectTypeEXT(32); + pub const DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: Self = + DebugReportObjectTypeEXT(33); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum RasterizationOrderAMD { - Strict = 0, - Relaxed = 1, +pub struct RasterizationOrderAMD(pub i32); +impl RasterizationOrderAMD { + pub const RASTERIZATION_ORDER_STRICT_AMD: Self = RasterizationOrderAMD(0); + pub const RASTERIZATION_ORDER_RELAXED_AMD: Self = RasterizationOrderAMD(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ValidationCheckEXT { - All = 0, - Shaders = 1, +pub struct ValidationCheckEXT(pub i32); +impl ValidationCheckEXT { + pub const VALIDATION_CHECK_ALL_EXT: Self = ValidationCheckEXT(0); + pub const VALIDATION_CHECK_SHADERS_EXT: Self = ValidationCheckEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum IndirectCommandsTokenTypeNVX { - Pipeline = 0, - DescriptorSet = 1, - IndexBuffer = 2, - VertexBuffer = 3, - PushConstant = 4, - DrawIndexed = 5, - Draw = 6, - Dispatch = 7, +pub struct IndirectCommandsTokenTypeNVX(pub i32); +impl IndirectCommandsTokenTypeNVX { + pub const INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX: Self = IndirectCommandsTokenTypeNVX(0); + pub const INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX: Self = + IndirectCommandsTokenTypeNVX(1); + pub const INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX: Self = IndirectCommandsTokenTypeNVX(2); + pub const INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX: Self = + IndirectCommandsTokenTypeNVX(3); + pub const INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX: Self = + IndirectCommandsTokenTypeNVX(4); + pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX: Self = IndirectCommandsTokenTypeNVX(5); + pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX: Self = IndirectCommandsTokenTypeNVX(6); + pub const INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX: Self = IndirectCommandsTokenTypeNVX(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ObjectEntryTypeNVX { - DescriptorSet = 0, - Pipeline = 1, - IndexBuffer = 2, - VertexBuffer = 3, - PushConstant = 4, +pub struct ObjectEntryTypeNVX(pub i32); +impl ObjectEntryTypeNVX { + pub const OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX: Self = ObjectEntryTypeNVX(0); + pub const OBJECT_ENTRY_TYPE_PIPELINE_NVX: Self = ObjectEntryTypeNVX(1); + pub const OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(2); + pub const OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(3); + pub const OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX: Self = ObjectEntryTypeNVX(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DisplayPowerStateEXT { - Off = 0, - Suspend = 1, - On = 2, +pub struct DisplayPowerStateEXT(pub i32); +impl DisplayPowerStateEXT { + pub const DISPLAY_POWER_STATE_OFF_EXT: Self = DisplayPowerStateEXT(0); + pub const DISPLAY_POWER_STATE_SUSPEND_EXT: Self = DisplayPowerStateEXT(1); + pub const DISPLAY_POWER_STATE_ON_EXT: Self = DisplayPowerStateEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DeviceEventTypeEXT { - DisplayHotplug = 0, +pub struct DeviceEventTypeEXT(pub i32); +impl DeviceEventTypeEXT { + pub const DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: Self = DeviceEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DisplayEventTypeEXT { - FirstPixelOut = 0, +pub struct DisplayEventTypeEXT(pub i32); +impl DisplayEventTypeEXT { + pub const DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: Self = DisplayEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ViewportCoordinateSwizzleNV { - PositiveX = 0, - NegativeX = 1, - PositiveY = 2, - NegativeY = 3, - PositiveZ = 4, - NegativeZ = 5, - PositiveW = 6, - NegativeW = 7, +pub struct ViewportCoordinateSwizzleNV(pub i32); +impl ViewportCoordinateSwizzleNV { + pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: Self = ViewportCoordinateSwizzleNV(0); + pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: Self = ViewportCoordinateSwizzleNV(1); + pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(2); + pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(3); + pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(4); + pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(5); + pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: Self = ViewportCoordinateSwizzleNV(6); + pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: Self = ViewportCoordinateSwizzleNV(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum DiscardRectangleModeEXT { - Inclusive = 0, - Exclusive = 1, +pub struct DiscardRectangleModeEXT(pub i32); +impl DiscardRectangleModeEXT { + pub const DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: Self = DiscardRectangleModeEXT(0); + pub const DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: Self = DiscardRectangleModeEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum PointClippingBehavior { - AllClipPlanes = 0, - UserClipPlanesOnly = 1, +pub struct PointClippingBehavior(pub i32); +impl PointClippingBehavior { + pub const ALL_CLIP_PLANES: Self = PointClippingBehavior(0); + pub const USER_CLIP_PLANES_ONLY: Self = PointClippingBehavior(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SamplerReductionModeEXT { - WeightedAverage = 0, - Min = 1, - Max = 2, +pub struct SamplerReductionModeEXT(pub i32); +impl SamplerReductionModeEXT { + pub const SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT: Self = SamplerReductionModeEXT(0); + pub const SAMPLER_REDUCTION_MODE_MIN_EXT: Self = SamplerReductionModeEXT(1); + pub const SAMPLER_REDUCTION_MODE_MAX_EXT: Self = SamplerReductionModeEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum TessellationDomainOrigin { - UpperLeft = 0, - LowerLeft = 1, +pub struct TessellationDomainOrigin(pub i32); +impl TessellationDomainOrigin { + pub const UPPER_LEFT: Self = TessellationDomainOrigin(0); + pub const LOWER_LEFT: Self = TessellationDomainOrigin(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SamplerYcbcrModelConversion { - RgbIdentity = 0, - YcbcrIdentity = 1, - Ycbcr709 = 2, - Ycbcr601 = 3, - Ycbcr2020 = 4, +pub struct SamplerYcbcrModelConversion(pub i32); +impl SamplerYcbcrModelConversion { + pub const RGB_IDENTITY: Self = SamplerYcbcrModelConversion(0); + pub const YCBCR_IDENTITY: Self = SamplerYcbcrModelConversion(1); + pub const YCBCR_709: Self = SamplerYcbcrModelConversion(2); + pub const YCBCR_601: Self = SamplerYcbcrModelConversion(3); + pub const YCBCR_2020: Self = SamplerYcbcrModelConversion(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum SamplerYcbcrRange { - ItuFull = 0, - ItuNarrow = 1, +pub struct SamplerYcbcrRange(pub i32); +impl SamplerYcbcrRange { + pub const ITU_FULL: Self = SamplerYcbcrRange(0); + pub const ITU_NARROW: Self = SamplerYcbcrRange(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ChromaLocation { - CositedEven = 0, - Midpoint = 1, +pub struct ChromaLocation(pub i32); +impl ChromaLocation { + pub const COSITED_EVEN: Self = ChromaLocation(0); + pub const MIDPOINT: Self = ChromaLocation(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum BlendOverlapEXT { - Uncorrelated = 0, - Disjoint = 1, - Conjoint = 2, +pub struct BlendOverlapEXT(pub i32); +impl BlendOverlapEXT { + pub const BLEND_OVERLAP_UNCORRELATED_EXT: Self = BlendOverlapEXT(0); + pub const BLEND_OVERLAP_DISJOINT_EXT: Self = BlendOverlapEXT(1); + pub const BLEND_OVERLAP_CONJOINT_EXT: Self = BlendOverlapEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum CoverageModulationModeNV { - None = 0, - Rgb = 1, - Alpha = 2, - Rgba = 3, +pub struct CoverageModulationModeNV(pub i32); +impl CoverageModulationModeNV { + pub const COVERAGE_MODULATION_MODE_NONE_NV: Self = CoverageModulationModeNV(0); + pub const COVERAGE_MODULATION_MODE_RGB_NV: Self = CoverageModulationModeNV(1); + pub const COVERAGE_MODULATION_MODE_ALPHA_NV: Self = CoverageModulationModeNV(2); + pub const COVERAGE_MODULATION_MODE_RGBA_NV: Self = CoverageModulationModeNV(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ValidationCacheHeaderVersionEXT { - One = 1, +pub struct ValidationCacheHeaderVersionEXT(pub i32); +impl ValidationCacheHeaderVersionEXT { + pub const VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: Self = ValidationCacheHeaderVersionEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ShaderInfoTypeAMD { - Statistics = 0, - Binary = 1, - Disassembly = 2, +pub struct ShaderInfoTypeAMD(pub i32); +impl ShaderInfoTypeAMD { + pub const SHADER_INFO_TYPE_STATISTICS_AMD: Self = ShaderInfoTypeAMD(0); + pub const SHADER_INFO_TYPE_BINARY_AMD: Self = ShaderInfoTypeAMD(1); + pub const SHADER_INFO_TYPE_DISASSEMBLY_AMD: Self = ShaderInfoTypeAMD(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum QueueGlobalPriorityEXT { - Low = 128, - Medium = 256, - High = 512, - Realtime = 1024, +pub struct QueueGlobalPriorityEXT(pub i32); +impl QueueGlobalPriorityEXT { + pub const QUEUE_GLOBAL_PRIORITY_LOW_EXT: Self = QueueGlobalPriorityEXT(128); + pub const QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT: Self = QueueGlobalPriorityEXT(256); + pub const QUEUE_GLOBAL_PRIORITY_HIGH_EXT: Self = QueueGlobalPriorityEXT(512); + pub const QUEUE_GLOBAL_PRIORITY_REALTIME_EXT: Self = QueueGlobalPriorityEXT(1024); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub enum ConservativeRasterizationModeEXT { - Disabled = 0, - Overestimate = 1, - Underestimate = 2, +pub struct ConservativeRasterizationModeEXT(pub i32); +impl ConservativeRasterizationModeEXT { + pub const CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: Self = + ConservativeRasterizationModeEXT(0); + pub const CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT: Self = + ConservativeRasterizationModeEXT(1); + pub const CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: Self = + ConservativeRasterizationModeEXT(2); +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CullModeFlags { + flags: Flags, } -pub const CULL_MODE_FRONT_BIT: CullModeFlags = CullModeFlags { flags: 0b1 }; -pub const CULL_MODE_BACK_BIT: CullModeFlags = CullModeFlags { flags: 0b10 }; -pub const CULL_MODE_FRONT_AND_BACK: CullModeFlags = CullModeFlags { flags: 0x00000003 }; vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); -pub const QUEUE_GRAPHICS_BIT: QueueFlags = QueueFlags { flags: 0b1 }; -pub const QUEUE_COMPUTE_BIT: QueueFlags = QueueFlags { flags: 0b10 }; -pub const QUEUE_TRANSFER_BIT: QueueFlags = QueueFlags { flags: 0b100 }; -pub const QUEUE_SPARSE_BINDING_BIT: QueueFlags = QueueFlags { flags: 0b1000 }; +impl CullModeFlags { + pub const NONE: Self = CullModeFlags { flags: 0 }; + pub const FRONT_BIT: Self = CullModeFlags { flags: 0b1 }; + pub const BACK_BIT: Self = CullModeFlags { flags: 0b10 }; + pub const FRONT_AND_BACK: Self = CullModeFlags { flags: 0x00000003 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueueFlags { + flags: Flags, +} vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); +impl QueueFlags { + pub const GRAPHICS_BIT: Self = QueueFlags { flags: 0b1 }; + pub const COMPUTE_BIT: Self = QueueFlags { flags: 0b10 }; + pub const TRANSFER_BIT: Self = QueueFlags { flags: 0b100 }; + pub const SPARSE_BINDING_BIT: Self = QueueFlags { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DeviceQueueCreateFlags { + flags: Flags, +} vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); -pub const MEMORY_PROPERTY_DEVICE_LOCAL_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b1 }; -pub const MEMORY_PROPERTY_HOST_VISIBLE_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b10 }; -pub const MEMORY_PROPERTY_HOST_COHERENT_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b100 }; -pub const MEMORY_PROPERTY_HOST_CACHED_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b1000 }; -pub const MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: MemoryPropertyFlags = - MemoryPropertyFlags { flags: 0b10000 }; +impl DeviceQueueCreateFlags {} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MemoryPropertyFlags { + flags: Flags, +} vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); -pub const MEMORY_HEAP_DEVICE_LOCAL_BIT: MemoryHeapFlags = MemoryHeapFlags { flags: 0b1 }; +impl MemoryPropertyFlags { + pub const DEVICE_LOCAL_BIT: Self = MemoryPropertyFlags { flags: 0b1 }; + pub const HOST_VISIBLE_BIT: Self = MemoryPropertyFlags { flags: 0b10 }; + pub const HOST_COHERENT_BIT: Self = MemoryPropertyFlags { flags: 0b100 }; + pub const HOST_CACHED_BIT: Self = MemoryPropertyFlags { flags: 0b1000 }; + pub const LAZILY_ALLOCATED_BIT: Self = MemoryPropertyFlags { flags: 0b10000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MemoryHeapFlags { + flags: Flags, +} vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); -pub const ACCESS_INDIRECT_COMMAND_READ_BIT: AccessFlags = AccessFlags { flags: 0b1 }; -pub const ACCESS_INDEX_READ_BIT: AccessFlags = AccessFlags { flags: 0b10 }; -pub const ACCESS_VERTEX_ATTRIBUTE_READ_BIT: AccessFlags = AccessFlags { flags: 0b100 }; -pub const ACCESS_UNIFORM_READ_BIT: AccessFlags = AccessFlags { flags: 0b1000 }; -pub const ACCESS_INPUT_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000 }; -pub const ACCESS_SHADER_READ_BIT: AccessFlags = AccessFlags { flags: 0b100000 }; -pub const ACCESS_SHADER_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b1000000 }; -pub const ACCESS_COLOR_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { flags: 0b10000000 }; -pub const ACCESS_COLOR_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { flags: 0b100000000 }; -pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: AccessFlags = AccessFlags { - flags: 0b1000000000, -}; -pub const ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b10000000000, -}; -pub const ACCESS_TRANSFER_READ_BIT: AccessFlags = AccessFlags { - flags: 0b100000000000, -}; -pub const ACCESS_TRANSFER_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b1000000000000, -}; -pub const ACCESS_HOST_READ_BIT: AccessFlags = AccessFlags { - flags: 0b10000000000000, -}; -pub const ACCESS_HOST_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b100000000000000, -}; -pub const ACCESS_MEMORY_READ_BIT: AccessFlags = AccessFlags { - flags: 0b1000000000000000, -}; -pub const ACCESS_MEMORY_WRITE_BIT: AccessFlags = AccessFlags { - flags: 0b10000000000000000, -}; +impl MemoryHeapFlags { + pub const DEVICE_LOCAL_BIT: Self = MemoryHeapFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct AccessFlags { + flags: Flags, +} vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); -pub const BUFFER_USAGE_TRANSFER_SRC_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b1 }; -pub const BUFFER_USAGE_TRANSFER_DST_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b10 }; -pub const BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b100 }; -pub const BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b1000 }; -pub const BUFFER_USAGE_UNIFORM_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b10000 }; -pub const BUFFER_USAGE_STORAGE_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b100000 }; -pub const BUFFER_USAGE_INDEX_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b1000000 }; -pub const BUFFER_USAGE_VERTEX_BUFFER_BIT: BufferUsageFlags = BufferUsageFlags { flags: 0b10000000 }; -pub const BUFFER_USAGE_INDIRECT_BUFFER_BIT: BufferUsageFlags = - BufferUsageFlags { flags: 0b100000000 }; -vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); -pub const BUFFER_CREATE_SPARSE_BINDING_BIT: BufferCreateFlags = BufferCreateFlags { flags: 0b1 }; -pub const BUFFER_CREATE_SPARSE_RESIDENCY_BIT: BufferCreateFlags = BufferCreateFlags { flags: 0b10 }; -pub const BUFFER_CREATE_SPARSE_ALIASED_BIT: BufferCreateFlags = BufferCreateFlags { flags: 0b100 }; -vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); -pub const SHADER_STAGE_VERTEX_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b1 }; -pub const SHADER_STAGE_TESSELLATION_CONTROL_BIT: ShaderStageFlags = - ShaderStageFlags { flags: 0b10 }; -pub const SHADER_STAGE_TESSELLATION_EVALUATION_BIT: ShaderStageFlags = - ShaderStageFlags { flags: 0b100 }; -pub const SHADER_STAGE_GEOMETRY_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b1000 }; -pub const SHADER_STAGE_FRAGMENT_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b10000 }; -pub const SHADER_STAGE_COMPUTE_BIT: ShaderStageFlags = ShaderStageFlags { flags: 0b100000 }; -pub const SHADER_STAGE_ALL_GRAPHICS: ShaderStageFlags = ShaderStageFlags { flags: 0x0000001F }; -pub const SHADER_STAGE_ALL: ShaderStageFlags = ShaderStageFlags { flags: 0x7FFFFFFF }; -vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); -pub const IMAGE_USAGE_TRANSFER_SRC_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b1 }; -pub const IMAGE_USAGE_TRANSFER_DST_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b10 }; -pub const IMAGE_USAGE_SAMPLED_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b100 }; -pub const IMAGE_USAGE_STORAGE_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b1000 }; -pub const IMAGE_USAGE_COLOR_ATTACHMENT_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b10000 }; -pub const IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: ImageUsageFlags = - ImageUsageFlags { flags: 0b100000 }; -pub const IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: ImageUsageFlags = - ImageUsageFlags { flags: 0b1000000 }; -pub const IMAGE_USAGE_INPUT_ATTACHMENT_BIT: ImageUsageFlags = ImageUsageFlags { flags: 0b10000000 }; -vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); -pub const IMAGE_CREATE_SPARSE_BINDING_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b1 }; -pub const IMAGE_CREATE_SPARSE_RESIDENCY_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b10 }; -pub const IMAGE_CREATE_SPARSE_ALIASED_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b100 }; -pub const IMAGE_CREATE_MUTABLE_FORMAT_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b1000 }; -pub const IMAGE_CREATE_CUBE_COMPATIBLE_BIT: ImageCreateFlags = ImageCreateFlags { flags: 0b10000 }; -vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); -pub const PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: PipelineCreateFlags = - PipelineCreateFlags { flags: 0b1 }; -pub const PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: PipelineCreateFlags = - PipelineCreateFlags { flags: 0b10 }; -pub const PIPELINE_CREATE_DERIVATIVE_BIT: PipelineCreateFlags = - PipelineCreateFlags { flags: 0b100 }; -vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); -pub const COLOR_COMPONENT_R_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b1 }; -pub const COLOR_COMPONENT_G_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b10 }; -pub const COLOR_COMPONENT_B_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b100 }; -pub const COLOR_COMPONENT_A_BIT: ColorComponentFlags = ColorComponentFlags { flags: 0b1000 }; -vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); -pub const FENCE_CREATE_SIGNALED_BIT: FenceCreateFlags = FenceCreateFlags { flags: 0b1 }; -vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); -pub const FORMAT_FEATURE_SAMPLED_IMAGE_BIT: FormatFeatureFlags = FormatFeatureFlags { flags: 0b1 }; -pub const FORMAT_FEATURE_STORAGE_IMAGE_BIT: FormatFeatureFlags = FormatFeatureFlags { flags: 0b10 }; -pub const FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b100 }; -pub const FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b1000 }; -pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b10000 }; -pub const FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b100000 }; -pub const FORMAT_FEATURE_VERTEX_BUFFER_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b1000000 }; -pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b10000000 }; -pub const FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: FormatFeatureFlags = - FormatFeatureFlags { flags: 0b100000000 }; -pub const FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: FormatFeatureFlags = FormatFeatureFlags { - flags: 0b1000000000, -}; -pub const FORMAT_FEATURE_BLIT_SRC_BIT: FormatFeatureFlags = FormatFeatureFlags { - flags: 0b10000000000, -}; -pub const FORMAT_FEATURE_BLIT_DST_BIT: FormatFeatureFlags = FormatFeatureFlags { - flags: 0b100000000000, -}; -pub const FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: FormatFeatureFlags = FormatFeatureFlags { - flags: 0b1000000000000, -}; -vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); -pub const QUERY_CONTROL_PRECISE_BIT: QueryControlFlags = QueryControlFlags { flags: 0b1 }; -vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); -pub const QUERY_RESULT_64_BIT: QueryResultFlags = QueryResultFlags { flags: 0b1 }; -pub const QUERY_RESULT_WAIT_BIT: QueryResultFlags = QueryResultFlags { flags: 0b10 }; -pub const QUERY_RESULT_WITH_AVAILABILITY_BIT: QueryResultFlags = QueryResultFlags { flags: 0b100 }; -pub const QUERY_RESULT_PARTIAL_BIT: QueryResultFlags = QueryResultFlags { flags: 0b1000 }; -vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); -pub const COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: CommandBufferUsageFlags = - CommandBufferUsageFlags { flags: 0b1 }; -pub const COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: CommandBufferUsageFlags = - CommandBufferUsageFlags { flags: 0b10 }; -pub const COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: CommandBufferUsageFlags = - CommandBufferUsageFlags { flags: 0b100 }; -vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); -pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b1 }; -pub const QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b10 }; -pub const QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b100 }; -pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b1000 }; -pub const QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b10000 }; -pub const QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b100000 }; -pub const QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b1000000 }; -pub const QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { flags: 0b10000000 }; -pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: - QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { flags: 0b100000000 }; -pub const QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: - QueryPipelineStatisticFlags = QueryPipelineStatisticFlags { - flags: 0b1000000000, -}; -pub const QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: QueryPipelineStatisticFlags = - QueryPipelineStatisticFlags { +impl AccessFlags { + pub const INDIRECT_COMMAND_READ_BIT: Self = AccessFlags { flags: 0b1 }; + pub const INDEX_READ_BIT: Self = AccessFlags { flags: 0b10 }; + pub const VERTEX_ATTRIBUTE_READ_BIT: Self = AccessFlags { flags: 0b100 }; + pub const UNIFORM_READ_BIT: Self = AccessFlags { flags: 0b1000 }; + pub const INPUT_ATTACHMENT_READ_BIT: Self = AccessFlags { flags: 0b10000 }; + pub const SHADER_READ_BIT: Self = AccessFlags { flags: 0b100000 }; + pub const SHADER_WRITE_BIT: Self = AccessFlags { flags: 0b1000000 }; + pub const COLOR_ATTACHMENT_READ_BIT: Self = AccessFlags { flags: 0b10000000 }; + pub const COLOR_ATTACHMENT_WRITE_BIT: Self = AccessFlags { flags: 0b100000000 }; + pub const DEPTH_STENCIL_ATTACHMENT_READ_BIT: Self = AccessFlags { + flags: 0b1000000000, + }; + pub const DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: Self = AccessFlags { flags: 0b10000000000, }; -vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); -pub const IMAGE_ASPECT_COLOR_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b1 }; -pub const IMAGE_ASPECT_DEPTH_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b10 }; -pub const IMAGE_ASPECT_STENCIL_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b100 }; -pub const IMAGE_ASPECT_METADATA_BIT: ImageAspectFlags = ImageAspectFlags { flags: 0b1000 }; -vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); -pub const SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: SparseImageFormatFlags = - SparseImageFormatFlags { flags: 0b1 }; -pub const SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: SparseImageFormatFlags = - SparseImageFormatFlags { flags: 0b10 }; -pub const SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: SparseImageFormatFlags = - SparseImageFormatFlags { flags: 0b100 }; -vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); -pub const SPARSE_MEMORY_BIND_METADATA_BIT: SparseMemoryBindFlags = - SparseMemoryBindFlags { flags: 0b1 }; -vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); -pub const PIPELINE_STAGE_TOP_OF_PIPE_BIT: PipelineStageFlags = PipelineStageFlags { flags: 0b1 }; -pub const PIPELINE_STAGE_DRAW_INDIRECT_BIT: PipelineStageFlags = PipelineStageFlags { flags: 0b10 }; -pub const PIPELINE_STAGE_VERTEX_INPUT_BIT: PipelineStageFlags = PipelineStageFlags { flags: 0b100 }; -pub const PIPELINE_STAGE_VERTEX_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1000 }; -pub const PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10000 }; -pub const PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b100000 }; -pub const PIPELINE_STAGE_GEOMETRY_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b1000000 }; -pub const PIPELINE_STAGE_FRAGMENT_SHADER_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b10000000 }; -pub const PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: PipelineStageFlags = - PipelineStageFlags { flags: 0b100000000 }; -pub const PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b1000000000, -}; -pub const PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b10000000000, -}; -pub const PIPELINE_STAGE_COMPUTE_SHADER_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b100000000000, -}; -pub const PIPELINE_STAGE_TRANSFER_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b1000000000000, -}; -pub const PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b10000000000000, -}; -pub const PIPELINE_STAGE_HOST_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b100000000000000, -}; -pub const PIPELINE_STAGE_ALL_GRAPHICS_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b1000000000000000, -}; -pub const PIPELINE_STAGE_ALL_COMMANDS_BIT: PipelineStageFlags = PipelineStageFlags { - flags: 0b10000000000000000, -}; -vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); -pub const COMMAND_POOL_CREATE_TRANSIENT_BIT: CommandPoolCreateFlags = - CommandPoolCreateFlags { flags: 0b1 }; -pub const COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: CommandPoolCreateFlags = - CommandPoolCreateFlags { flags: 0b10 }; -vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); -pub const COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: CommandPoolResetFlags = - CommandPoolResetFlags { flags: 0b1 }; -vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); -pub const COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: CommandBufferResetFlags = - CommandBufferResetFlags { flags: 0b1 }; -vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); -pub const SAMPLE_COUNT_1_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1 }; -pub const SAMPLE_COUNT_2_BIT: SampleCountFlags = SampleCountFlags { flags: 0b10 }; -pub const SAMPLE_COUNT_4_BIT: SampleCountFlags = SampleCountFlags { flags: 0b100 }; -pub const SAMPLE_COUNT_8_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1000 }; -pub const SAMPLE_COUNT_16_BIT: SampleCountFlags = SampleCountFlags { flags: 0b10000 }; -pub const SAMPLE_COUNT_32_BIT: SampleCountFlags = SampleCountFlags { flags: 0b100000 }; -pub const SAMPLE_COUNT_64_BIT: SampleCountFlags = SampleCountFlags { flags: 0b1000000 }; -vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); -pub const ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: AttachmentDescriptionFlags = - AttachmentDescriptionFlags { flags: 0b1 }; -vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); -pub const STENCIL_FACE_FRONT_BIT: StencilFaceFlags = StencilFaceFlags { flags: 0b1 }; -pub const STENCIL_FACE_BACK_BIT: StencilFaceFlags = StencilFaceFlags { flags: 0b10 }; -pub const STENCIL_FRONT_AND_BACK: StencilFaceFlags = StencilFaceFlags { flags: 0x00000003 }; -vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); -pub const DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: DescriptorPoolCreateFlags = - DescriptorPoolCreateFlags { flags: 0b1 }; -vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); -pub const DEPENDENCY_BY_REGION_BIT: DependencyFlags = DependencyFlags { flags: 0b1 }; -vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); -pub const DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b1 }; -pub const DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b10 }; -pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b100 }; -pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: DisplayPlaneAlphaFlagsKHR = - DisplayPlaneAlphaFlagsKHR { flags: 0b1000 }; -vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); -pub const COMPOSITE_ALPHA_OPAQUE_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b1 }; -pub const COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b10 }; -pub const COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b100 }; -pub const COMPOSITE_ALPHA_INHERIT_BIT_KHR: CompositeAlphaFlagsKHR = - CompositeAlphaFlagsKHR { flags: 0b1000 }; -vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); -pub const SURFACE_TRANSFORM_IDENTITY_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b1 }; -pub const SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b10 }; -pub const SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b100 }; -pub const SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b1000 }; -pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b10000 }; -pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b100000 }; -pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b1000000 }; -pub const SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b10000000 }; -pub const SURFACE_TRANSFORM_INHERIT_BIT_KHR: SurfaceTransformFlagsKHR = - SurfaceTransformFlagsKHR { flags: 0b100000000 }; -vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); -pub const DEBUG_REPORT_INFORMATION_BIT_EXT: DebugReportFlagsEXT = - DebugReportFlagsEXT { flags: 0b1 }; -pub const DEBUG_REPORT_WARNING_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT { flags: 0b10 }; -pub const DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: DebugReportFlagsEXT = - DebugReportFlagsEXT { flags: 0b100 }; -pub const DEBUG_REPORT_ERROR_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT { flags: 0b1000 }; -pub const DEBUG_REPORT_DEBUG_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT { flags: 0b10000 }; -vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); -pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV: ExternalMemoryHandleTypeFlagsNV = - ExternalMemoryHandleTypeFlagsNV { flags: 0b1 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV: ExternalMemoryHandleTypeFlagsNV = - ExternalMemoryHandleTypeFlagsNV { flags: 0b10 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV: ExternalMemoryHandleTypeFlagsNV = - ExternalMemoryHandleTypeFlagsNV { flags: 0b100 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV: ExternalMemoryHandleTypeFlagsNV = - ExternalMemoryHandleTypeFlagsNV { flags: 0b1000 }; -vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); -pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV: ExternalMemoryFeatureFlagsNV = - ExternalMemoryFeatureFlagsNV { flags: 0b1 }; -pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV: ExternalMemoryFeatureFlagsNV = - ExternalMemoryFeatureFlagsNV { flags: 0b10 }; -pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV: ExternalMemoryFeatureFlagsNV = - ExternalMemoryFeatureFlagsNV { flags: 0b100 }; -vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); -pub const SUBGROUP_FEATURE_BASIC_BIT: SubgroupFeatureFlags = SubgroupFeatureFlags { flags: 0b1 }; -pub const SUBGROUP_FEATURE_VOTE_BIT: SubgroupFeatureFlags = SubgroupFeatureFlags { flags: 0b10 }; -pub const SUBGROUP_FEATURE_ARITHMETIC_BIT: SubgroupFeatureFlags = - SubgroupFeatureFlags { flags: 0b100 }; -pub const SUBGROUP_FEATURE_BALLOT_BIT: SubgroupFeatureFlags = - SubgroupFeatureFlags { flags: 0b1000 }; -pub const SUBGROUP_FEATURE_SHUFFLE_BIT: SubgroupFeatureFlags = - SubgroupFeatureFlags { flags: 0b10000 }; -pub const SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: SubgroupFeatureFlags = - SubgroupFeatureFlags { flags: 0b100000 }; -pub const SUBGROUP_FEATURE_CLUSTERED_BIT: SubgroupFeatureFlags = - SubgroupFeatureFlags { flags: 0b1000000 }; -pub const SUBGROUP_FEATURE_QUAD_BIT: SubgroupFeatureFlags = - SubgroupFeatureFlags { flags: 0b10000000 }; -vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); -pub const INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX: - IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1 }; -pub const INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX: - IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b10 }; -pub const INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX: - IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b100 }; -pub const INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX: - IndirectCommandsLayoutUsageFlagsNVX = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1000 }; -vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); -pub const OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX: ObjectEntryUsageFlagsNVX = - ObjectEntryUsageFlagsNVX { flags: 0b1 }; -pub const OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX: ObjectEntryUsageFlagsNVX = - ObjectEntryUsageFlagsNVX { flags: 0b10 }; -vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); -vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); -pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: ExternalMemoryHandleTypeFlags = - ExternalMemoryHandleTypeFlags { flags: 0b1 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: ExternalMemoryHandleTypeFlags = - ExternalMemoryHandleTypeFlags { flags: 0b10 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: ExternalMemoryHandleTypeFlags = - ExternalMemoryHandleTypeFlags { flags: 0b100 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT: ExternalMemoryHandleTypeFlags = - ExternalMemoryHandleTypeFlags { flags: 0b1000 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT: ExternalMemoryHandleTypeFlags = - ExternalMemoryHandleTypeFlags { flags: 0b10000 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT: ExternalMemoryHandleTypeFlags = - ExternalMemoryHandleTypeFlags { flags: 0b100000 }; -pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT: ExternalMemoryHandleTypeFlags = - ExternalMemoryHandleTypeFlags { flags: 0b1000000 }; -vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); -pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT: ExternalMemoryFeatureFlags = - ExternalMemoryFeatureFlags { flags: 0b1 }; -pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT: ExternalMemoryFeatureFlags = - ExternalMemoryFeatureFlags { flags: 0b10 }; -pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT: ExternalMemoryFeatureFlags = - ExternalMemoryFeatureFlags { flags: 0b100 }; -vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); -pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: ExternalSemaphoreHandleTypeFlags = - ExternalSemaphoreHandleTypeFlags { flags: 0b1 }; -pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT: ExternalSemaphoreHandleTypeFlags = - ExternalSemaphoreHandleTypeFlags { flags: 0b10 }; -pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: ExternalSemaphoreHandleTypeFlags = - ExternalSemaphoreHandleTypeFlags { flags: 0b100 }; -pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT: ExternalSemaphoreHandleTypeFlags = - ExternalSemaphoreHandleTypeFlags { flags: 0b1000 }; -pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: ExternalSemaphoreHandleTypeFlags = - ExternalSemaphoreHandleTypeFlags { flags: 0b10000 }; -vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); -pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT: ExternalSemaphoreFeatureFlags = - ExternalSemaphoreFeatureFlags { flags: 0b1 }; -pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT: ExternalSemaphoreFeatureFlags = - ExternalSemaphoreFeatureFlags { flags: 0b10 }; -vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); -pub const SEMAPHORE_IMPORT_TEMPORARY_BIT: SemaphoreImportFlags = - SemaphoreImportFlags { flags: 0b1 }; -vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); -pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: ExternalFenceHandleTypeFlags = - ExternalFenceHandleTypeFlags { flags: 0b1 }; -pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT: ExternalFenceHandleTypeFlags = - ExternalFenceHandleTypeFlags { flags: 0b10 }; -pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: ExternalFenceHandleTypeFlags = - ExternalFenceHandleTypeFlags { flags: 0b100 }; -pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: ExternalFenceHandleTypeFlags = - ExternalFenceHandleTypeFlags { flags: 0b1000 }; -vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); -pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT: ExternalFenceFeatureFlags = - ExternalFenceFeatureFlags { flags: 0b1 }; -pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT: ExternalFenceFeatureFlags = - ExternalFenceFeatureFlags { flags: 0b10 }; -vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); -pub const FENCE_IMPORT_TEMPORARY_BIT: FenceImportFlags = FenceImportFlags { flags: 0b1 }; -vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); -pub const SURFACE_COUNTER_VBLANK_EXT: SurfaceCounterFlagsEXT = - SurfaceCounterFlagsEXT { flags: 0b1 }; -vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); -pub const PEER_MEMORY_FEATURE_COPY_SRC_BIT: PeerMemoryFeatureFlags = - PeerMemoryFeatureFlags { flags: 0b1 }; -pub const PEER_MEMORY_FEATURE_COPY_DST_BIT: PeerMemoryFeatureFlags = - PeerMemoryFeatureFlags { flags: 0b10 }; -pub const PEER_MEMORY_FEATURE_GENERIC_SRC_BIT: PeerMemoryFeatureFlags = - PeerMemoryFeatureFlags { flags: 0b100 }; -pub const PEER_MEMORY_FEATURE_GENERIC_DST_BIT: PeerMemoryFeatureFlags = - PeerMemoryFeatureFlags { flags: 0b1000 }; -vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); -pub const MEMORY_ALLOCATE_DEVICE_MASK_BIT: MemoryAllocateFlags = MemoryAllocateFlags { flags: 0b1 }; -vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); -pub const DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR: DeviceGroupPresentModeFlagsKHR = - DeviceGroupPresentModeFlagsKHR { flags: 0b1 }; -pub const DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR: DeviceGroupPresentModeFlagsKHR = - DeviceGroupPresentModeFlagsKHR { flags: 0b10 }; -pub const DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR: DeviceGroupPresentModeFlagsKHR = - DeviceGroupPresentModeFlagsKHR { flags: 0b100 }; -pub const DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR: DeviceGroupPresentModeFlagsKHR = - DeviceGroupPresentModeFlagsKHR { flags: 0b1000 }; -vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); -vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); -vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); -pub const DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = - DebugUtilsMessageSeverityFlagsEXT { flags: 0b1 }; -pub const DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = - DebugUtilsMessageSeverityFlagsEXT { flags: 0b10000 }; -pub const DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = - DebugUtilsMessageSeverityFlagsEXT { flags: 0b100000000 }; -pub const DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: DebugUtilsMessageSeverityFlagsEXT = - DebugUtilsMessageSeverityFlagsEXT { + pub const TRANSFER_READ_BIT: Self = AccessFlags { + flags: 0b100000000000, + }; + pub const TRANSFER_WRITE_BIT: Self = AccessFlags { flags: 0b1000000000000, }; + pub const HOST_READ_BIT: Self = AccessFlags { + flags: 0b10000000000000, + }; + pub const HOST_WRITE_BIT: Self = AccessFlags { + flags: 0b100000000000000, + }; + pub const MEMORY_READ_BIT: Self = AccessFlags { + flags: 0b1000000000000000, + }; + pub const MEMORY_WRITE_BIT: Self = AccessFlags { + flags: 0b10000000000000000, + }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct BufferUsageFlags { + flags: Flags, +} +vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); +impl BufferUsageFlags { + pub const TRANSFER_SRC_BIT: Self = BufferUsageFlags { flags: 0b1 }; + pub const TRANSFER_DST_BIT: Self = BufferUsageFlags { flags: 0b10 }; + pub const UNIFORM_TEXEL_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b100 }; + pub const STORAGE_TEXEL_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b1000 }; + pub const UNIFORM_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b10000 }; + pub const STORAGE_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b100000 }; + pub const INDEX_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b1000000 }; + pub const VERTEX_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b10000000 }; + pub const INDIRECT_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b100000000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct BufferCreateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); +impl BufferCreateFlags { + pub const SPARSE_BINDING_BIT: Self = BufferCreateFlags { flags: 0b1 }; + pub const SPARSE_RESIDENCY_BIT: Self = BufferCreateFlags { flags: 0b10 }; + pub const SPARSE_ALIASED_BIT: Self = BufferCreateFlags { flags: 0b100 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ShaderStageFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); +impl ShaderStageFlags { + pub const VERTEX_BIT: Self = ShaderStageFlags { flags: 0b1 }; + pub const TESSELLATION_CONTROL_BIT: Self = ShaderStageFlags { flags: 0b10 }; + pub const TESSELLATION_EVALUATION_BIT: Self = ShaderStageFlags { flags: 0b100 }; + pub const GEOMETRY_BIT: Self = ShaderStageFlags { flags: 0b1000 }; + pub const FRAGMENT_BIT: Self = ShaderStageFlags { flags: 0b10000 }; + pub const COMPUTE_BIT: Self = ShaderStageFlags { flags: 0b100000 }; + pub const ALL_GRAPHICS: Self = ShaderStageFlags { flags: 0x0000001F }; + pub const ALL: Self = ShaderStageFlags { flags: 0x7FFFFFFF }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ImageUsageFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); +impl ImageUsageFlags { + pub const TRANSFER_SRC_BIT: Self = ImageUsageFlags { flags: 0b1 }; + pub const TRANSFER_DST_BIT: Self = ImageUsageFlags { flags: 0b10 }; + pub const SAMPLED_BIT: Self = ImageUsageFlags { flags: 0b100 }; + pub const STORAGE_BIT: Self = ImageUsageFlags { flags: 0b1000 }; + pub const COLOR_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b10000 }; + pub const DEPTH_STENCIL_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b100000 }; + pub const TRANSIENT_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b1000000 }; + pub const INPUT_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b10000000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ImageCreateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); +impl ImageCreateFlags { + pub const SPARSE_BINDING_BIT: Self = ImageCreateFlags { flags: 0b1 }; + pub const SPARSE_RESIDENCY_BIT: Self = ImageCreateFlags { flags: 0b10 }; + pub const SPARSE_ALIASED_BIT: Self = ImageCreateFlags { flags: 0b100 }; + pub const MUTABLE_FORMAT_BIT: Self = ImageCreateFlags { flags: 0b1000 }; + pub const CUBE_COMPATIBLE_BIT: Self = ImageCreateFlags { flags: 0b10000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineCreateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); +impl PipelineCreateFlags { + pub const DISABLE_OPTIMIZATION_BIT: Self = PipelineCreateFlags { flags: 0b1 }; + pub const ALLOW_DERIVATIVES_BIT: Self = PipelineCreateFlags { flags: 0b10 }; + pub const DERIVATIVE_BIT: Self = PipelineCreateFlags { flags: 0b100 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ColorComponentFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); +impl ColorComponentFlags { + pub const R_BIT: Self = ColorComponentFlags { flags: 0b1 }; + pub const G_BIT: Self = ColorComponentFlags { flags: 0b10 }; + pub const B_BIT: Self = ColorComponentFlags { flags: 0b100 }; + pub const A_BIT: Self = ColorComponentFlags { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FenceCreateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); +impl FenceCreateFlags { + pub const SIGNALED_BIT: Self = FenceCreateFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FormatFeatureFlags { + flags: Flags, +} +vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_BIT: Self = FormatFeatureFlags { flags: 0b1 }; + pub const STORAGE_IMAGE_BIT: Self = FormatFeatureFlags { flags: 0b10 }; + pub const STORAGE_IMAGE_ATOMIC_BIT: Self = FormatFeatureFlags { flags: 0b100 }; + pub const UNIFORM_TEXEL_BUFFER_BIT: Self = FormatFeatureFlags { flags: 0b1000 }; + pub const STORAGE_TEXEL_BUFFER_BIT: Self = FormatFeatureFlags { flags: 0b10000 }; + pub const STORAGE_TEXEL_BUFFER_ATOMIC_BIT: Self = FormatFeatureFlags { flags: 0b100000 }; + pub const VERTEX_BUFFER_BIT: Self = FormatFeatureFlags { flags: 0b1000000 }; + pub const COLOR_ATTACHMENT_BIT: Self = FormatFeatureFlags { flags: 0b10000000 }; + pub const COLOR_ATTACHMENT_BLEND_BIT: Self = FormatFeatureFlags { flags: 0b100000000 }; + pub const DEPTH_STENCIL_ATTACHMENT_BIT: Self = FormatFeatureFlags { + flags: 0b1000000000, + }; + pub const BLIT_SRC_BIT: Self = FormatFeatureFlags { + flags: 0b10000000000, + }; + pub const BLIT_DST_BIT: Self = FormatFeatureFlags { + flags: 0b100000000000, + }; + pub const SAMPLED_IMAGE_FILTER_LINEAR_BIT: Self = FormatFeatureFlags { + flags: 0b1000000000000, + }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueryControlFlags { + flags: Flags, +} +vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); +impl QueryControlFlags { + pub const PRECISE_BIT: Self = QueryControlFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueryResultFlags { + flags: Flags, +} +vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); +impl QueryResultFlags { + pub const TYPE_64_BIT: Self = QueryResultFlags { flags: 0b1 }; + pub const WAIT_BIT: Self = QueryResultFlags { flags: 0b10 }; + pub const WITH_AVAILABILITY_BIT: Self = QueryResultFlags { flags: 0b100 }; + pub const PARTIAL_BIT: Self = QueryResultFlags { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandBufferUsageFlags { + flags: Flags, +} +vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); +impl CommandBufferUsageFlags { + pub const ONE_TIME_SUBMIT_BIT: Self = CommandBufferUsageFlags { flags: 0b1 }; + pub const RENDER_PASS_CONTINUE_BIT: Self = CommandBufferUsageFlags { flags: 0b10 }; + pub const SIMULTANEOUS_USE_BIT: Self = CommandBufferUsageFlags { flags: 0b100 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueryPipelineStatisticFlags { + flags: Flags, +} +vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); +impl QueryPipelineStatisticFlags { + pub const INPUT_ASSEMBLY_VERTICES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b1 }; + pub const INPUT_ASSEMBLY_PRIMITIVES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b10 }; + pub const VERTEX_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { flags: 0b100 }; + pub const GEOMETRY_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { flags: 0b1000 }; + pub const GEOMETRY_SHADER_PRIMITIVES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b10000 }; + pub const CLIPPING_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { flags: 0b100000 }; + pub const CLIPPING_PRIMITIVES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b1000000 }; + pub const FRAGMENT_SHADER_INVOCATIONS_BIT: Self = + QueryPipelineStatisticFlags { flags: 0b10000000 }; + pub const TESSELLATION_CONTROL_SHADER_PATCHES_BIT: Self = + QueryPipelineStatisticFlags { flags: 0b100000000 }; + pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { + flags: 0b1000000000, + }; + pub const COMPUTE_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { + flags: 0b10000000000, + }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ImageAspectFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); +impl ImageAspectFlags { + pub const COLOR_BIT: Self = ImageAspectFlags { flags: 0b1 }; + pub const DEPTH_BIT: Self = ImageAspectFlags { flags: 0b10 }; + pub const STENCIL_BIT: Self = ImageAspectFlags { flags: 0b100 }; + pub const METADATA_BIT: Self = ImageAspectFlags { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SparseImageFormatFlags { + flags: Flags, +} +vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); +impl SparseImageFormatFlags { + pub const SINGLE_MIPTAIL_BIT: Self = SparseImageFormatFlags { flags: 0b1 }; + pub const ALIGNED_MIP_SIZE_BIT: Self = SparseImageFormatFlags { flags: 0b10 }; + pub const NONSTANDARD_BLOCK_SIZE_BIT: Self = SparseImageFormatFlags { flags: 0b100 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SparseMemoryBindFlags { + flags: Flags, +} +vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); +impl SparseMemoryBindFlags { + pub const METADATA_BIT: Self = SparseMemoryBindFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineStageFlags { + flags: Flags, +} +vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); +impl PipelineStageFlags { + pub const TOP_OF_PIPE_BIT: Self = PipelineStageFlags { flags: 0b1 }; + pub const DRAW_INDIRECT_BIT: Self = PipelineStageFlags { flags: 0b10 }; + pub const VERTEX_INPUT_BIT: Self = PipelineStageFlags { flags: 0b100 }; + pub const VERTEX_SHADER_BIT: Self = PipelineStageFlags { flags: 0b1000 }; + pub const TESSELLATION_CONTROL_SHADER_BIT: Self = PipelineStageFlags { flags: 0b10000 }; + pub const TESSELLATION_EVALUATION_SHADER_BIT: Self = PipelineStageFlags { flags: 0b100000 }; + pub const GEOMETRY_SHADER_BIT: Self = PipelineStageFlags { flags: 0b1000000 }; + pub const FRAGMENT_SHADER_BIT: Self = PipelineStageFlags { flags: 0b10000000 }; + pub const EARLY_FRAGMENT_TESTS_BIT: Self = PipelineStageFlags { flags: 0b100000000 }; + pub const LATE_FRAGMENT_TESTS_BIT: Self = PipelineStageFlags { + flags: 0b1000000000, + }; + pub const COLOR_ATTACHMENT_OUTPUT_BIT: Self = PipelineStageFlags { + flags: 0b10000000000, + }; + pub const COMPUTE_SHADER_BIT: Self = PipelineStageFlags { + flags: 0b100000000000, + }; + pub const TRANSFER_BIT: Self = PipelineStageFlags { + flags: 0b1000000000000, + }; + pub const BOTTOM_OF_PIPE_BIT: Self = PipelineStageFlags { + flags: 0b10000000000000, + }; + pub const HOST_BIT: Self = PipelineStageFlags { + flags: 0b100000000000000, + }; + pub const ALL_GRAPHICS_BIT: Self = PipelineStageFlags { + flags: 0b1000000000000000, + }; + pub const ALL_COMMANDS_BIT: Self = PipelineStageFlags { + flags: 0b10000000000000000, + }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandPoolCreateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); +impl CommandPoolCreateFlags { + pub const TRANSIENT_BIT: Self = CommandPoolCreateFlags { flags: 0b1 }; + pub const RESET_COMMAND_BUFFER_BIT: Self = CommandPoolCreateFlags { flags: 0b10 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandPoolResetFlags { + flags: Flags, +} +vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); +impl CommandPoolResetFlags { + pub const RELEASE_RESOURCES_BIT: Self = CommandPoolResetFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandBufferResetFlags { + flags: Flags, +} +vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); +impl CommandBufferResetFlags { + pub const RELEASE_RESOURCES_BIT: Self = CommandBufferResetFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SampleCountFlags { + flags: Flags, +} +vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); +impl SampleCountFlags { + pub const TYPE_1_BIT: Self = SampleCountFlags { flags: 0b1 }; + pub const TYPE_2_BIT: Self = SampleCountFlags { flags: 0b10 }; + pub const TYPE_4_BIT: Self = SampleCountFlags { flags: 0b100 }; + pub const TYPE_8_BIT: Self = SampleCountFlags { flags: 0b1000 }; + pub const TYPE_16_BIT: Self = SampleCountFlags { flags: 0b10000 }; + pub const TYPE_32_BIT: Self = SampleCountFlags { flags: 0b100000 }; + pub const TYPE_64_BIT: Self = SampleCountFlags { flags: 0b1000000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct AttachmentDescriptionFlags { + flags: Flags, +} +vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); +impl AttachmentDescriptionFlags { + pub const MAY_ALIAS_BIT: Self = AttachmentDescriptionFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct StencilFaceFlags { + flags: Flags, +} +vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); +impl StencilFaceFlags { + pub const FRONT_BIT: Self = StencilFaceFlags { flags: 0b1 }; + pub const BACK_BIT: Self = StencilFaceFlags { flags: 0b10 }; + pub const STENCIL_FRONT_AND_BACK: Self = StencilFaceFlags { flags: 0x00000003 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorPoolCreateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); +impl DescriptorPoolCreateFlags { + pub const FREE_DESCRIPTOR_SET_BIT: Self = DescriptorPoolCreateFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DependencyFlags { + flags: Flags, +} +vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); +impl DependencyFlags { + pub const BY_REGION_BIT: Self = DependencyFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DisplayPlaneAlphaFlagsKHR { + flags: Flags, +} +vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); +impl DisplayPlaneAlphaFlagsKHR { + pub const OPAQUE_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b1 }; + pub const GLOBAL_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b10 }; + pub const PER_PIXEL_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b100 }; + pub const PER_PIXEL_PREMULTIPLIED_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CompositeAlphaFlagsKHR { + flags: Flags, +} +vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); +impl CompositeAlphaFlagsKHR { + pub const OPAQUE_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b1 }; + pub const PRE_MULTIPLIED_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b10 }; + pub const POST_MULTIPLIED_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b100 }; + pub const INHERIT_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SurfaceTransformFlagsKHR { + flags: Flags, +} +vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); +impl SurfaceTransformFlagsKHR { + pub const IDENTITY_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b1 }; + pub const ROTATE_90_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b10 }; + pub const ROTATE_180_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b100 }; + pub const ROTATE_270_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b1000 }; + pub const HORIZONTAL_MIRROR_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b10000 }; + pub const HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: Self = + SurfaceTransformFlagsKHR { flags: 0b100000 }; + pub const HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: Self = + SurfaceTransformFlagsKHR { flags: 0b1000000 }; + pub const HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: Self = + SurfaceTransformFlagsKHR { flags: 0b10000000 }; + pub const INHERIT_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b100000000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugReportFlagsEXT { + flags: Flags, +} +vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); +impl DebugReportFlagsEXT { + pub const INFORMATION_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b1 }; + pub const WARNING_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b10 }; + pub const PERFORMANCE_WARNING_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b100 }; + pub const ERROR_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b1000 }; + pub const DEBUG_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b10000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryHandleTypeFlagsNV { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); +impl ExternalMemoryHandleTypeFlagsNV { + pub const OPAQUE_WIN32_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b1 }; + pub const OPAQUE_WIN32_KMT_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b10 }; + pub const D3D11_IMAGE_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b100 }; + pub const D3D11_IMAGE_KMT_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryFeatureFlagsNV { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); +impl ExternalMemoryFeatureFlagsNV { + pub const DEDICATED_ONLY_BIT_NV: Self = ExternalMemoryFeatureFlagsNV { flags: 0b1 }; + pub const EXPORTABLE_BIT_NV: Self = ExternalMemoryFeatureFlagsNV { flags: 0b10 }; + pub const IMPORTABLE_BIT_NV: Self = ExternalMemoryFeatureFlagsNV { flags: 0b100 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SubgroupFeatureFlags { + flags: Flags, +} +vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); +impl SubgroupFeatureFlags { + pub const BASIC_BIT: Self = SubgroupFeatureFlags { flags: 0b1 }; + pub const VOTE_BIT: Self = SubgroupFeatureFlags { flags: 0b10 }; + pub const ARITHMETIC_BIT: Self = SubgroupFeatureFlags { flags: 0b100 }; + pub const BALLOT_BIT: Self = SubgroupFeatureFlags { flags: 0b1000 }; + pub const SHUFFLE_BIT: Self = SubgroupFeatureFlags { flags: 0b10000 }; + pub const SHUFFLE_RELATIVE_BIT: Self = SubgroupFeatureFlags { flags: 0b100000 }; + pub const CLUSTERED_BIT: Self = SubgroupFeatureFlags { flags: 0b1000000 }; + pub const QUAD_BIT: Self = SubgroupFeatureFlags { flags: 0b10000000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct IndirectCommandsLayoutUsageFlagsNVX { + flags: Flags, +} +vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); +impl IndirectCommandsLayoutUsageFlagsNVX { + pub const UNORDERED_SEQUENCES_BIT_NVX: Self = + IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1 }; + pub const SPARSE_SEQUENCES_BIT_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b10 }; + pub const EMPTY_EXECUTIONS_BIT_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b100 }; + pub const INDEXED_SEQUENCES_BIT_NVX: Self = + IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ObjectEntryUsageFlagsNVX { + flags: Flags, +} +vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); +impl ObjectEntryUsageFlagsNVX { + pub const GRAPHICS_BIT_NVX: Self = ObjectEntryUsageFlagsNVX { flags: 0b1 }; + pub const COMPUTE_BIT_NVX: Self = ObjectEntryUsageFlagsNVX { flags: 0b10 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorSetLayoutCreateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); +impl DescriptorSetLayoutCreateFlags {} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryHandleTypeFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); +impl ExternalMemoryHandleTypeFlags { + pub const OPAQUE_FD_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b1 }; + pub const OPAQUE_WIN32_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b10 }; + pub const OPAQUE_WIN32_KMT_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b100 }; + pub const D3D11_TEXTURE_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b1000 }; + pub const D3D11_TEXTURE_KMT_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b10000 }; + pub const D3D12_HEAP_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b100000 }; + pub const D3D12_RESOURCE_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b1000000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryFeatureFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); +impl ExternalMemoryFeatureFlags { + pub const DEDICATED_ONLY_BIT: Self = ExternalMemoryFeatureFlags { flags: 0b1 }; + pub const EXPORTABLE_BIT: Self = ExternalMemoryFeatureFlags { flags: 0b10 }; + pub const IMPORTABLE_BIT: Self = ExternalMemoryFeatureFlags { flags: 0b100 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalSemaphoreHandleTypeFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); +impl ExternalSemaphoreHandleTypeFlags { + pub const OPAQUE_FD_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b1 }; + pub const OPAQUE_WIN32_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b10 }; + pub const OPAQUE_WIN32_KMT_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b100 }; + pub const D3D12_FENCE_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b1000 }; + pub const SYNC_FD_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b10000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalSemaphoreFeatureFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); +impl ExternalSemaphoreFeatureFlags { + pub const EXPORTABLE_BIT: Self = ExternalSemaphoreFeatureFlags { flags: 0b1 }; + pub const IMPORTABLE_BIT: Self = ExternalSemaphoreFeatureFlags { flags: 0b10 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SemaphoreImportFlags { + flags: Flags, +} +vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); +impl SemaphoreImportFlags { + pub const TEMPORARY_BIT: Self = SemaphoreImportFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalFenceHandleTypeFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); +impl ExternalFenceHandleTypeFlags { + pub const OPAQUE_FD_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b1 }; + pub const OPAQUE_WIN32_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b10 }; + pub const OPAQUE_WIN32_KMT_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b100 }; + pub const SYNC_FD_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalFenceFeatureFlags { + flags: Flags, +} +vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); +impl ExternalFenceFeatureFlags { + pub const EXPORTABLE_BIT: Self = ExternalFenceFeatureFlags { flags: 0b1 }; + pub const IMPORTABLE_BIT: Self = ExternalFenceFeatureFlags { flags: 0b10 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FenceImportFlags { + flags: Flags, +} +vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); +impl FenceImportFlags { + pub const TEMPORARY_BIT: Self = FenceImportFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SurfaceCounterFlagsEXT { + flags: Flags, +} +vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); +impl SurfaceCounterFlagsEXT { + pub const VBLANK_EXT: Self = SurfaceCounterFlagsEXT { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PeerMemoryFeatureFlags { + flags: Flags, +} +vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); +impl PeerMemoryFeatureFlags { + pub const COPY_SRC_BIT: Self = PeerMemoryFeatureFlags { flags: 0b1 }; + pub const COPY_DST_BIT: Self = PeerMemoryFeatureFlags { flags: 0b10 }; + pub const GENERIC_SRC_BIT: Self = PeerMemoryFeatureFlags { flags: 0b100 }; + pub const GENERIC_DST_BIT: Self = PeerMemoryFeatureFlags { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MemoryAllocateFlags { + flags: Flags, +} +vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); +impl MemoryAllocateFlags { + pub const DEVICE_MASK_BIT: Self = MemoryAllocateFlags { flags: 0b1 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DeviceGroupPresentModeFlagsKHR { + flags: Flags, +} +vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); +impl DeviceGroupPresentModeFlagsKHR { + pub const LOCAL_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b1 }; + pub const REMOTE_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b10 }; + pub const SUM_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b100 }; + pub const LOCAL_MULTI_DEVICE_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b1000 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SwapchainCreateFlagsKHR { + flags: Flags, +} +vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); +impl SwapchainCreateFlagsKHR {} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SubpassDescriptionFlags { + flags: Flags, +} +vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); +impl SubpassDescriptionFlags {} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugUtilsMessageSeverityFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); -pub const DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: DebugUtilsMessageTypeFlagsEXT = - DebugUtilsMessageTypeFlagsEXT { flags: 0b1 }; -pub const DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: DebugUtilsMessageTypeFlagsEXT = - DebugUtilsMessageTypeFlagsEXT { flags: 0b10 }; -pub const DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: DebugUtilsMessageTypeFlagsEXT = - DebugUtilsMessageTypeFlagsEXT { flags: 0b100 }; +impl DebugUtilsMessageSeverityFlagsEXT { + pub const VERBOSE_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { flags: 0b1 }; + pub const INFO_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { flags: 0b10000 }; + pub const WARNING_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { flags: 0b100000000 }; + pub const ERROR_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { + flags: 0b1000000000000, + }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugUtilsMessageTypeFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); -pub const DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT: DescriptorBindingFlagsEXT = - DescriptorBindingFlagsEXT { flags: 0b1 }; -pub const DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: DescriptorBindingFlagsEXT = - DescriptorBindingFlagsEXT { flags: 0b10 }; -pub const DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT: DescriptorBindingFlagsEXT = - DescriptorBindingFlagsEXT { flags: 0b100 }; -pub const DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: DescriptorBindingFlagsEXT = - DescriptorBindingFlagsEXT { flags: 0b1000 }; +impl DebugUtilsMessageTypeFlagsEXT { + pub const GENERAL_BIT_EXT: Self = DebugUtilsMessageTypeFlagsEXT { flags: 0b1 }; + pub const VALIDATION_BIT_EXT: Self = DebugUtilsMessageTypeFlagsEXT { flags: 0b10 }; + pub const PERFORMANCE_BIT_EXT: Self = DebugUtilsMessageTypeFlagsEXT { flags: 0b100 }; +} +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorBindingFlagsEXT { + flags: Flags, +} vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); +impl DescriptorBindingFlagsEXT { + pub const UPDATE_AFTER_BIND_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b1 }; + pub const UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b10 }; + pub const PARTIALLY_BOUND_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b100 }; + pub const VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b1000 }; +} pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; pub const VK_UUID_SIZE: usize = 16; pub const VK_LUID_SIZE: usize = 8; diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 7f516f3..2ddd8fc 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -176,9 +176,6 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { quote!{ macro_rules! vk_bitflags_wrapped { ($name: ident, $all: expr, $flag_type: ty) => { - #[repr(C)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct $name {flags: $flag_type} impl Default for $name{ fn default() -> $name { @@ -783,6 +780,9 @@ pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { let name = &bitmask.name[2..]; let ident = Ident::from(name); Some(quote!{ + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct #ident {flags: Flags} vk_bitflags_wrapped!(#ident, 0b0, Flags); }) } @@ -820,6 +820,24 @@ pub enum EnumType { Enum(Tokens), } +pub fn variant_ident(_enum: &vkxml::Enumeration, variant_name: &str) -> Ident { + let _name = _enum.name.split("FlagBits").nth(0).expect("split"); + let struct_name = _name.to_shouty_snake_case(); + let new_variant_name = variant_name.replace(&struct_name, "").replace("VK", ""); + // Not every variant in the vk.xml has a correct shouty snake case name + let new_variant_name = new_variant_name.trim_matches('_').to_shouty_snake_case(); + let is_digit = new_variant_name + .chars() + .nth(0) + .map(|c| c.is_digit(10)) + .unwrap_or(false); + if is_digit { + Ident::from(format!("TYPE_{}", new_variant_name).as_str()) + } else { + Ident::from(new_variant_name) + } +} + pub fn generate_enum( _enum: &vkxml::Enumeration, create_info_constants: &[&vkxml::Constant], @@ -827,34 +845,23 @@ pub fn generate_enum( let name = &_enum.name[2..]; let _name = name.replace("FlagBits", "Flags"); let ident = Ident::from(_name.as_str()); - let variants = _enum.elements.iter().filter_map(|elem| { - let (variant_name, value) = match *elem { - vkxml::EnumerationElement::Enum(ref constant) => { - let c = Constant::from_constant(constant); - (constant.name.as_str(), c.to_tokens()) - } - _ => { - return None; - } - }; - - let _name = _name.split("Flags").nth(0).expect("split"); - let struct_name = _name.to_shouty_snake_case(); - println!("{}", struct_name); - let new_variant_name = variant_name.replace(&struct_name, "").replace("VK", ""); - let new_variant_name = new_variant_name.trim_matches('_'); - let is_digit = new_variant_name - .chars() - .nth(0) - .map(|c| c.is_digit(10)) - .unwrap_or(false); - let variant_ident = if is_digit { - Ident::from(format!("TYPE_{}", new_variant_name).as_str()) - } else { - Ident::from(new_variant_name) - }; - Some((variant_ident, value)) - }).collect_vec(); + let variants = _enum + .elements + .iter() + .filter_map(|elem| { + let (variant_name, value) = match *elem { + vkxml::EnumerationElement::Enum(ref constant) => { + let c = Constant::from_constant(constant); + (constant.name.as_str(), c.to_tokens()) + } + _ => { + return None; + } + }; + let variant_ident = variant_ident(_enum, variant_name); + Some((variant_ident, value)) + }) + .collect_vec(); if name.contains("Bit") { let ident = Ident::from(_name.as_str()); let all_bits = _enum @@ -870,12 +877,15 @@ pub fn generate_enum( .fold(0, |acc, next| acc | next.bits()); let all_bits_term = Term::intern(&format!("0b{:b}", all_bits)); - let variants = variants.iter().map(|(variant_ident, value)|{ + let variants = variants.iter().map(|(variant_ident, value)| { quote!{ pub const #variant_ident: Self = #ident { flags: #value } } }); let q = quote!{ + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct #ident {flags: Flags} vk_bitflags_wrapped!(#ident, #all_bits_term, Flags); impl #ident { #(#variants;)* @@ -883,81 +893,38 @@ pub fn generate_enum( }; EnumType::Bitflags(q) } else { - let variants = variants.iter().map(|(variant_ident, value)|{ + let variants = variants.iter().map(|(variant_ident, value)| { quote!{ pub const #variant_ident: Self = #ident(#value) } }); - let q = match _name.as_str() { - //"StructureType" => generate_structure_type(&_name, _enum, create_info_constants), - //"Result" => generate_result(&_name, _enum), - _ => { - quote!{ - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - #[repr(C)] - pub struct #ident(pub i32); - impl #ident { - #( - #variants; - )* - } - } + let enum_quote = quote!{ + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + #[repr(C)] + pub struct #ident(pub i32); + impl #ident { + #( + #variants; + )* } }; + let special_quote = match _name.as_str() { + //"StructureType" => generate_structure_type(&_name, _enum, create_info_constants), + "Result" => generate_result(&ident, _enum), + _ => { + quote!{} + } + }; + let q = quote!{ + #enum_quote + #special_quote + + }; EnumType::Enum(q) } } -pub fn generate_structure_type( - name: &str, - _enum: &vkxml::Enumeration, - create_info_constants: &[&vkxml::Constant], -) -> Tokens { - let ident = Ident::from(name); - let constants: Vec<_> = _enum - .elements - .iter() - .filter_map(|elem| match elem { - vkxml::EnumerationElement::Enum(constant) => Some(constant), - _ => None, - }) - .collect(); - let variants = constants - .iter() - .chain(create_info_constants.into_iter()) - .map(|constant| { - let value_tokens = Constant::from_constant(constant).to_tokens(); - let variant_ident = to_variant_ident(&name, &constant.name); - quote!{ - #variant_ident = #value_tokens - } - }); - quote!{ - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - #[repr(C)] - pub enum #ident { - #(#variants,)* - } - } -} -pub fn generate_result(name: &str, _enum: &vkxml::Enumeration) -> Tokens { - let ident = Ident::from(name); - let variants = _enum.elements.iter().filter_map(|elem| { - let (variant_name, value) = match *elem { - vkxml::EnumerationElement::Enum(ref constant) => { - let c = Constant::from_constant(constant); - //println!("value {:?}", c.value()); - (constant.name.as_str(), c.to_tokens()) - } - _ => { - return None; - } - }; - let variant_ident = to_variant_ident(&name, variant_name); - Some(quote!{ - #variant_ident = #value - }) - }); +pub fn generate_result(ident: &Ident, _enum: &vkxml::Enumeration) -> Tokens { let notation = _enum.elements.iter().filter_map(|elem| { let (variant_name, notation) = match *elem { vkxml::EnumerationElement::Enum(ref constant) => ( @@ -969,18 +936,13 @@ pub fn generate_result(name: &str, _enum: &vkxml::Enumeration) -> Tokens { } }; - let variant_ident = to_variant_ident(&name, variant_name); + let variant_ident = variant_ident(_enum, variant_name); Some(quote!{ #ident::#variant_ident => write!(fmt, #notation) }) }); quote!{ - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - #[repr(C)] - pub enum #ident { - #(#variants,)* - } impl ::std::error::Error for #ident { fn description(&self) -> &str { "vk::Result" @@ -989,8 +951,9 @@ pub fn generate_result(name: &str, _enum: &vkxml::Enumeration) -> Tokens { impl ::std::fmt::Display for #ident { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { writeln!(fmt, "vk::Result::{:?}", self)?; - match self { - #(#notation),* + match *self { + #(#notation),*, + _ => write!(fmt, "Unknown variant") } } } @@ -1280,17 +1243,17 @@ pub fn write_source_code(spec: &vkxml::Registry) { let platform_specific_types = platform_specific_types(); let source_code = quote!{ pub use libc::*; - // #version_macros - // #platform_specific_types + #version_macros + #platform_specific_types #bitflags_macro - // #handle_nondispatchable_macro - // #define_handle_macro - // #(#feature_code)* - // #(#definition_code)* + #handle_nondispatchable_macro + #define_handle_macro + #(#feature_code)* + #(#definition_code)* #(#enum_code)* #(#bitflags_code)* - // #(#constants_code)* - // #(#extension_code)* + #(#constants_code)* + #(#extension_code)* }; write!(&mut file, "{}", source_code); } From a9bf74cebf137de9ce59b4683099e1a6c775fd84 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 9 Jul 2018 09:25:37 +0200 Subject: [PATCH 021/122] Remove unnecessary println --- generator/src/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 2ddd8fc..8d38ddc 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1140,7 +1140,6 @@ pub fn generate_constant(constant: &vkxml::Constant) -> Tokens { pub fn write_source_code(spec: &vkxml::Registry) { use std::fs::File; use std::io::Write; - println!("{:#?}", spec); let commands: HashMap = spec .elements .iter() From 3fc04b77a650fa48fa7f96bfbaf2a83378e6217c Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 11 Jul 2018 13:18:22 +0200 Subject: [PATCH 022/122] Abstract over constants --- generator/src/lib.rs | 239 +++++++++++++++++++++++++++++-------------- 1 file changed, 161 insertions(+), 78 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 8d38ddc..a87a2cc 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -179,35 +179,35 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { impl Default for $name{ fn default() -> $name { - $name {flags: 0} + $name(0) } } impl ::std::fmt::Debug for $name { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - write!(f, "{}({:b})", stringify!($name), self.flags) + write!(f, "{}({:b})", stringify!($name), self.0) } } impl $name { #[inline] pub fn empty() -> $name { - $name {flags: 0} + $name(0) } #[inline] pub fn all() -> $name { - $name {flags: $all} + $name($all) } #[inline] pub fn flags(self) -> $flag_type { - self.flags + self.0 } #[inline] pub fn from_flags(flags: $flag_type) -> Option<$name> { if flags & !$all == 0 { - Some($name {flags: flags}) + Some($name(flags)) } else { None } @@ -215,7 +215,7 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { #[inline] pub fn from_flags_truncate(flags: $flag_type) -> $name { - $name {flags: flags & $all} + $name (flags & $all) } #[inline] @@ -245,7 +245,7 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { #[inline] fn bitor(self, rhs: $name) -> $name { - $name {flags: self.flags | rhs.flags } + $name (self.0 | rhs.0 ) } } @@ -261,7 +261,7 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { #[inline] fn bitand(self, rhs: $name) -> $name { - $name {flags: self.flags & rhs.flags} + $name (self.0 & rhs.0) } } @@ -277,7 +277,7 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { #[inline] fn bitxor(self, rhs: $name) -> $name { - $name {flags: self.flags ^ rhs.flags} + $name (self.0 ^ rhs.0 ) } } @@ -365,6 +365,23 @@ impl ConstVal { } } } +pub trait ConstantExt { + fn variant_ident(&self, enum_name: &str) -> Ident; + fn to_tokens(&self) -> Tokens; + fn notation(&self) -> Option<&str>; +} + +impl ConstantExt for vkxml::Constant { + fn variant_ident(&self, enum_name: &str) -> Ident { + variant_ident(enum_name, &self.name) + } + fn to_tokens(&self) -> Tokens { + Constant::from_constant(self).to_tokens() + } + fn notation(&self) -> Option<&str> { + self.notation.as_ref().map(|s| s.as_str()) + } +} pub enum Constant { Number(i32), Hex(String), @@ -431,6 +448,27 @@ impl Constant { } } + pub fn from_extension_enum(constant: &vkxml::ExtensionEnum) -> Self { + let number = constant.number.map(|n| Constant::Number(n)); + let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); + let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); + let expr = constant + .c_expression + .as_ref() + .map(|e| Constant::CExpr(e.clone())); + number.or(hex).or(bitpos).or(expr).expect("") + } + pub fn from_extension_constant(constant: &vkxml::ExtensionConstant) -> Self { + let number = constant.number.map(|n| Constant::Number(n)); + let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); + let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); + let text = constant.text.as_ref().map(|bit| Constant::Text(bit.clone())); + let expr = constant + .c_expression + .as_ref() + .map(|e| Constant::CExpr(e.clone())); + number.or(hex).or(bitpos).or(expr).or(text).expect("") + } pub fn from_constant(constant: &vkxml::Constant) -> Self { let number = constant.number.map(|n| Constant::Number(n)); let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); @@ -454,8 +492,6 @@ impl Constant { } } -pub trait ConstantExt {} -impl ConstantExt for vkxml::Constant {} pub trait FeatureExt { fn version_string(&self) -> String; } @@ -723,26 +759,22 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo } } } -pub fn generate_extension(extension: &vkxml::Extension, commands: &CommandMap) -> quote::Tokens { - let extension_commands: Vec<&vkxml::Command> = extension +pub fn generate_extension(extension: &vkxml::Extension, cmd_map: &CommandMap) -> quote::Tokens { + // Don't generate disabled or reserved extensions + if extension.disabled { + return quote!{}; + } + let cmd_refs = extension .elements .iter() - .flat_map(|extension| { - if let &vkxml::ExtensionElement::Require(ref spec) = extension { + .flat_map(|ext| { + if let &vkxml::ExtensionElement::Require(ref spec) = ext { spec.elements .iter() .filter_map(|extension_spec| match extension_spec { vkxml::ExtensionSpecificationElement::CommandReference(ref cmd_ref) => { Some(cmd_ref) } - vkxml::ExtensionSpecificationElement::Constant(ref field) => { - //println!("EXT {:?}", field); - None - } - vkxml::ExtensionSpecificationElement::Enum(ref field) => { - //println!("Enum {:?}", field); - None - } _ => None, }) .collect() @@ -750,15 +782,44 @@ pub fn generate_extension(extension: &vkxml::Extension, commands: &CommandMap) - vec![] } }) - .filter_map(|cmd_ref| commands.get(&cmd_ref.name)) - .map(|&cmd| cmd) - .collect(); - if extension_commands.is_empty() { - return quote!{}; - } + .collect_vec(); + let commands = cmd_refs + .iter() + .filter_map(|cmd_ref| cmd_map.get(&cmd_ref.name).map(|c| *c)) + .collect_vec(); let name = format!("{}Fn", extension.name.to_camel_case()); let ident = Ident::from(&name[2..]); - generate_function_pointers(ident, &extension_commands) + let fp = generate_function_pointers(ident, &commands); + let extension_enums = extension + .elements + .iter() + .flat_map(|ext| { + if let &vkxml::ExtensionElement::Require(ref spec) = ext { + spec.elements + .iter() + .filter_map(|extension_spec| match extension_spec { + vkxml::ExtensionSpecificationElement::Enum(ref _enum) => { + Some(_enum) + } + _ => None, + }) + .collect() + } else { + vec![] + } + }) + .collect_vec(); + let variants = extension_enums.iter().map(|&constant|{ + let c = Constant::from_extension_enum(constant); + let variant_ident = variant_ident(&constant.name, &constant.name); + (variant_ident, c.to_tokens()) + }); + println!("{:?}", extension_enums); + //let enum_tokens = im + quote!{ + #fp + //#(#enum_tokens)* + } } pub fn generate_typedef(typedef: &vkxml::Typedef) -> Tokens { let typedef_name = to_type_tokens(&typedef.name, None); @@ -782,7 +843,7 @@ pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { Some(quote!{ #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct #ident {flags: Flags} + pub struct #ident(Flags); vk_bitflags_wrapped!(#ident, 0b0, Flags); }) } @@ -820,12 +881,15 @@ pub enum EnumType { Enum(Tokens), } -pub fn variant_ident(_enum: &vkxml::Enumeration, variant_name: &str) -> Ident { - let _name = _enum.name.split("FlagBits").nth(0).expect("split"); +pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { + let _name = enum_name.split("FlagBits").nth(0).expect("split"); let struct_name = _name.to_shouty_snake_case(); let new_variant_name = variant_name.replace(&struct_name, "").replace("VK", ""); // Not every variant in the vk.xml has a correct shouty snake case name - let new_variant_name = new_variant_name.trim_matches('_').to_shouty_snake_case(); + let new_variant_name = new_variant_name + .trim_matches('_') + .to_shouty_snake_case() + .replace("_BIT", ""); let is_digit = new_variant_name .chars() .nth(0) @@ -838,6 +902,43 @@ pub fn variant_ident(_enum: &vkxml::Enumeration, variant_name: &str) -> Ident { } } +pub fn bitflags_impl_block( + ident: &Ident, + _enum: &vkxml::Enumeration, + constants: &[& impl ConstantExt], +) -> Tokens { + let variants = constants + .iter() + .map(|constant| { + let variant_ident = constant.variant_ident(&_enum.name); + let tokens = constant.to_tokens(); + (variant_ident, tokens) + }) + .collect_vec(); + + let notations = constants.iter().map(|constant| { + constant.notation().map(|n| { + quote!{ + #[doc = #n] + } + }) + }); + + let variants = variants.iter().zip(notations.clone()).map( + |((variant_ident, value), ref notation)| { + quote!{ + #notation + pub const #variant_ident: Self = #ident(#value); + } + }, + ); + quote!{ + impl #ident { + #(#variants)* + } + } +} + pub fn generate_enum( _enum: &vkxml::Enumeration, create_info_constants: &[&vkxml::Constant], @@ -845,68 +946,39 @@ pub fn generate_enum( let name = &_enum.name[2..]; let _name = name.replace("FlagBits", "Flags"); let ident = Ident::from(_name.as_str()); - let variants = _enum + let constants: Vec<_> = _enum .elements .iter() - .filter_map(|elem| { - let (variant_name, value) = match *elem { - vkxml::EnumerationElement::Enum(ref constant) => { - let c = Constant::from_constant(constant); - (constant.name.as_str(), c.to_tokens()) - } - _ => { - return None; - } - }; - let variant_ident = variant_ident(_enum, variant_name); - Some((variant_ident, value)) + .filter_map(|elem| match *elem { + vkxml::EnumerationElement::Enum(ref constant) => Some(constant), + _ => None, }) .collect_vec(); + if name.contains("Bit") { let ident = Ident::from(_name.as_str()); - let all_bits = _enum - .elements + let all_bits = constants .iter() - .filter_map(|elem| match elem { - vkxml::EnumerationElement::Enum(ref constant) => { - let c = Constant::from_constant(constant); - c.value() - } - _ => None, - }) + .filter_map(|constant| Constant::from_constant(constant).value()) .fold(0, |acc, next| acc | next.bits()); let all_bits_term = Term::intern(&format!("0b{:b}", all_bits)); - let variants = variants.iter().map(|(variant_ident, value)| { - quote!{ - pub const #variant_ident: Self = #ident { flags: #value } - } - }); + let impl_bitflags = bitflags_impl_block(&ident, _enum, &constants); let q = quote!{ #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct #ident {flags: Flags} + pub struct #ident(Flags); vk_bitflags_wrapped!(#ident, #all_bits_term, Flags); - impl #ident { - #(#variants;)* - } + #impl_bitflags }; EnumType::Bitflags(q) } else { - let variants = variants.iter().map(|(variant_ident, value)| { - quote!{ - pub const #variant_ident: Self = #ident(#value) - } - }); + let impl_block = bitflags_impl_block(&ident, _enum, &constants); let enum_quote = quote!{ #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] pub struct #ident(pub i32); - impl #ident { - #( - #variants; - )* - } + #impl_block }; let special_quote = match _name.as_str() { //"StructureType" => generate_structure_type(&_name, _enum, create_info_constants), @@ -936,7 +1008,7 @@ pub fn generate_result(ident: &Ident, _enum: &vkxml::Enumeration) -> Tokens { } }; - let variant_ident = variant_ident(_enum, variant_name); + let variant_ident = variant_ident(&_enum.name, variant_name); Some(quote!{ #ident::#variant_ident => write!(fmt, #notation) }) @@ -1025,9 +1097,16 @@ pub fn generate_handle(handle: &vkxml::Handle) -> Option { fn generate_funcptr(fnptr: &vkxml::FunctionPointer) -> Tokens { let name = Ident::from(fnptr.name.as_str()); let ret_ty_tokens = fnptr.return_type.type_tokens(); + let params = fnptr.param.iter().map(|field| { + let ident = field.param_ident(); + let type_tokens = field.type_tokens(); + quote!{ + #ident: #type_tokens + } + }); quote!{ #[allow(non_camel_case_types)] - pub type #name = unsafe extern "system" fn() -> #ret_ty_tokens; + pub type #name = unsafe extern "system" fn(#(#params),*) -> #ret_ty_tokens; } } @@ -1133,6 +1212,10 @@ pub fn generate_constant(constant: &vkxml::Constant) -> Tokens { let value = c.to_tokens(); let ty = c.ty().to_tokens(); quote!{ + // pub mod constants { + // pub const #ident: #ty = #value; + // } + //pub use constants::*; pub const #ident: #ty = #value; } } From 1a3094d4c215ead72ac865ff91ee1ac0441d7a4b Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 21 Jul 2018 12:56:16 +0200 Subject: [PATCH 023/122] Add extensions --- examples/src/lib.rs | 4 +- generator/src/bin/generator.rs | 3 +- generator/src/lib.rs | 174 +++++++++++++++++++++++++-------- 3 files changed, 138 insertions(+), 43 deletions(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 55c4862..8d1ad5a 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -382,7 +382,7 @@ impl ExampleBase { let surface_format = surface_formats .iter() .map(|sfmt| match sfmt.format { - vk::Format::Undefined => vk::SurfaceFormatKHR { + vk::Format:: => vk::SurfaceFormatKHR { format: vk::Format::B8g8r8Unorm, color_space: sfmt.color_space, }, @@ -450,7 +450,7 @@ impl ExampleBase { let pool_create_info = vk::CommandPoolCreateInfo { s_type: vk::StructureType::CommandPoolCreateInfo, p_next: ptr::null(), - flags: vk::COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, + flags: vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER_BIT, queue_family_index: queue_family_index, }; let pool = device.create_command_pool(&pool_create_info, None).unwrap(); diff --git a/generator/src/bin/generator.rs b/generator/src/bin/generator.rs index 80a411f..0ce52c6 100644 --- a/generator/src/bin/generator.rs +++ b/generator/src/bin/generator.rs @@ -8,6 +8,5 @@ use std::path::Path; fn main() { //let file = File::open("New-Vulkan-XML-Format/vk_new.xml").expect("vknew"); - let spec = vk_parse::parse_file_as_vkxml(Path::new("vk.xml")); - write_source_code(&spec); + write_source_code(Path::new("vk.xml")); } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index a87a2cc..09d1981 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -18,12 +18,9 @@ use itertools::Itertools; use proc_macro2::{Term, TokenTree}; use quote::Tokens; use std::collections::HashMap; +use std::path::Path; use syn::Ident; - -pub struct Foo; -impl Foo { - const FOO: u32 = 1; -} +pub trait ExtensionExt {} #[derive(Copy, Clone, Debug)] pub enum CType { USize, @@ -31,6 +28,7 @@ pub enum CType { U64, Float, } + impl CType { fn to_tokens(&self) -> Tokens { let term = match self { @@ -46,7 +44,7 @@ impl CType { named!(ctype<&str, CType>, alt!( tag!("ULL") => { |_| CType::U64 } | - tag!("U") => { |_| CType::U32 } + tag!("U") => { |_| CType::U32 } ) ); named!(cexpr<&str, (CType, String)>, @@ -371,6 +369,17 @@ pub trait ConstantExt { fn notation(&self) -> Option<&str>; } +impl ConstantExt for vkxml::ExtensionEnum { + fn variant_ident(&self, enum_name: &str) -> Ident { + variant_ident(enum_name, &self.name) + } + fn to_tokens(&self) -> Tokens { + Constant::from_extension_enum(self).expect("").to_tokens() + } + fn notation(&self) -> Option<&str> { + self.notation.as_ref().map(|s| s.as_str()) + } +} impl ConstantExt for vkxml::Constant { fn variant_ident(&self, enum_name: &str) -> Ident { variant_ident(enum_name, &self.name) @@ -382,6 +391,7 @@ impl ConstantExt for vkxml::Constant { self.notation.as_ref().map(|s| s.as_str()) } } + pub enum Constant { Number(i32), Hex(String), @@ -448,7 +458,8 @@ impl Constant { } } - pub fn from_extension_enum(constant: &vkxml::ExtensionEnum) -> Self { + pub fn from_extension_enum(constant: &vkxml::ExtensionEnum) -> Option { + println!("{:#?}", constant); let number = constant.number.map(|n| Constant::Number(n)); let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); @@ -456,13 +467,16 @@ impl Constant { .c_expression .as_ref() .map(|e| Constant::CExpr(e.clone())); - number.or(hex).or(bitpos).or(expr).expect("") + number.or(hex).or(bitpos).or(expr) } pub fn from_extension_constant(constant: &vkxml::ExtensionConstant) -> Self { let number = constant.number.map(|n| Constant::Number(n)); let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); - let text = constant.text.as_ref().map(|bit| Constant::Text(bit.clone())); + let text = constant + .text + .as_ref() + .map(|bit| Constant::Text(bit.clone())); let expr = constant .c_expression .as_ref() @@ -759,6 +773,45 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo } } } +pub fn generate_interface_item(items: &[vk_parse::InterfaceItem]) -> quote::Tokens { + use vk_parse::InterfaceItem::*; + for item in items { + match item { + Type { name,.. } => println!("type {}", name), + Enum(e) => println!("type {}", name), + _ => () + }; + } + quote!{} +} +pub fn generate_extension2( + extension: &vk_parse::Extension, + cmd_map: &CommandMap, +) -> Option { + let _ = extension + .supported + .as_ref() + .filter(|s| s.as_str() == "vulkan")?; + extension + .items + .iter() + .filter_map(|item| match item { + vk_parse::ExtensionItem::Require { + extension: ext, + feature, + items, + .. + } => { + //println!("feature {:?} - {:?}", feature, ext); + let t = generate_interface_item(items); + Some(t) + } + _ => None, + }) + .collect_vec(); + + None +} pub fn generate_extension(extension: &vkxml::Extension, cmd_map: &CommandMap) -> quote::Tokens { // Don't generate disabled or reserved extensions if extension.disabled { @@ -794,13 +847,12 @@ pub fn generate_extension(extension: &vkxml::Extension, cmd_map: &CommandMap) -> .elements .iter() .flat_map(|ext| { + println!("{:?}", ext); if let &vkxml::ExtensionElement::Require(ref spec) = ext { spec.elements .iter() .filter_map(|extension_spec| match extension_spec { - vkxml::ExtensionSpecificationElement::Enum(ref _enum) => { - Some(_enum) - } + vkxml::ExtensionSpecificationElement::Enum(ref _enum) => Some(_enum), _ => None, }) .collect() @@ -809,17 +861,22 @@ pub fn generate_extension(extension: &vkxml::Extension, cmd_map: &CommandMap) -> } }) .collect_vec(); - let variants = extension_enums.iter().map(|&constant|{ - let c = Constant::from_extension_enum(constant); - let variant_ident = variant_ident(&constant.name, &constant.name); - (variant_ident, c.to_tokens()) - }); - println!("{:?}", extension_enums); - //let enum_tokens = im - quote!{ - #fp - //#(#enum_tokens)* - } + let extend_enums = extension_enums.iter().filter_map(|&constant| { + let c = Constant::from_extension_enum(constant)?; + let variant_ident = variant_ident(&constant.extends, &constant.name); + let tokens = c.to_tokens(); + let enum_name = name_to_tokens(&constant.extends); + Some(quote! { + impl #enum_name { + pub const #variant_ident: Self = #enum_name(#tokens); + } + }) + }); + //println!("{:#?}", extension_enums); + quote!{ + #fp + #(#extend_enums)* + } } pub fn generate_typedef(typedef: &vkxml::Typedef) -> Tokens { let typedef_name = to_type_tokens(&typedef.name, None); @@ -905,7 +962,7 @@ pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { pub fn bitflags_impl_block( ident: &Ident, _enum: &vkxml::Enumeration, - constants: &[& impl ConstantExt], + constants: &[&impl ConstantExt], ) -> Tokens { let variants = constants .iter() @@ -1220,9 +1277,44 @@ pub fn generate_constant(constant: &vkxml::Constant) -> Tokens { } } -pub fn write_source_code(spec: &vkxml::Registry) { +pub fn write_source_code(path: &Path) { use std::fs::File; use std::io::Write; + let spec2 = vk_parse::parse_file(path); + let extensions: &Vec = spec2 + .0 + .iter() + .filter_map(|item| match item { + vk_parse::RegistryItem::Extensions { items: ext, .. } => Some(ext), + _ => None, + }) + .nth(0) + .expect("extension"); + // for ext in extensions { + // println!("{}", ext.name); + // for item in &ext.items { + // match item { + // vk_parse::ExtensionItem::Require { items, .. } => { + // for interface in items { + // match interface { + // vk_parse::InterfaceItem::Enum(ref e) => match &e.spec { + // vk_parse::EnumSpec::Value { value, extends } => { + // print!("{} - ", e.name,); + // println!("{} {:?}", value, extends); + // } + // _ => (), + // }, + // _ => (), + // } + // } + // } + // _ => (), + // } + // } + // println!("ext {} {:?}", ext.name, ext.supported); + // } + + let spec = vk_parse::parse_file_as_vkxml(path); let commands: HashMap = spec .elements .iter() @@ -1233,6 +1325,10 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) .collect(); + let _ = extensions + .iter() + .filter_map(|ext| generate_extension2(ext, &commands)) + .collect_vec(); let features: Vec<&vkxml::Feature> = spec .elements .iter() @@ -1243,15 +1339,15 @@ pub fn write_source_code(spec: &vkxml::Registry) { .flat_map(|features| features.elements.iter().map(|feature| feature)) .collect(); - let extensions: Vec<&vkxml::Extension> = spec - .elements - .iter() - .filter_map(|elem| match elem { - &vkxml::RegistryElement::Extensions(ref extensions) => Some(extensions), - _ => None, - }) - .flat_map(|extensions| extensions.elements.iter().map(|extension| extension)) - .collect(); + // let extensions: Vec<&vkxml::Extension> = spec + // .elements + // .iter() + // .filter_map(|elem| match elem { + // &vkxml::RegistryElement::Extensions(ref extensions) => Some(extensions), + // _ => None, + // }) + // .flat_map(|extensions| extensions.elements.iter().map(|extension| extension)) + // .collect(); let definitions: Vec<&vkxml::DefinitionsElement> = spec .elements @@ -1313,10 +1409,10 @@ pub fn write_source_code(spec: &vkxml::Registry) { .map(|feature| generate_feature(feature, &commands)) .collect(); - let extension_code: Vec<_> = extensions - .iter() - .map(|ext| generate_extension(ext, &commands)) - .collect(); + // let extension_code: Vec<_> = extensions + // .iter() + // .map(|ext| generate_extension(ext, &commands)) + // .collect(); let mut file = File::create("../ash/src/vk.rs").expect("vk"); let bitflags_macro = vk_bitflags_wrapped_macro(); let handle_nondispatchable_macro = handle_nondispatchable_macro(); @@ -1335,7 +1431,7 @@ pub fn write_source_code(spec: &vkxml::Registry) { #(#enum_code)* #(#bitflags_code)* #(#constants_code)* - #(#extension_code)* + //#(#extension_code)* }; write!(&mut file, "{}", source_code); } From 207f468f4b32191a1908ce28e2acf6de2469a651 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 29 Jul 2018 22:39:21 +0200 Subject: [PATCH 024/122] Switch to Vulkan-Headers --- .gitmodules | 3 + generator/New-Vulkan-XML-Format | 1 - generator/Vulkan-Docs | 1 - generator/vk.xml | 8830 ------------------------------- 4 files changed, 3 insertions(+), 8832 deletions(-) create mode 100644 .gitmodules delete mode 160000 generator/New-Vulkan-XML-Format delete mode 160000 generator/Vulkan-Docs delete mode 100644 generator/vk.xml diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..8673d0a --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "generator/Vulkan-Headers"] + path = generator/Vulkan-Headers + url = https://github.com/KhronosGroup/Vulkan-Headers diff --git a/generator/New-Vulkan-XML-Format b/generator/New-Vulkan-XML-Format deleted file mode 160000 index 460746d..0000000 --- a/generator/New-Vulkan-XML-Format +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 460746da3c2dfd1d247b12a619f47f2078a4374b diff --git a/generator/Vulkan-Docs b/generator/Vulkan-Docs deleted file mode 160000 index ee13fc3..0000000 --- a/generator/Vulkan-Docs +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ee13fc355fae06ffcd36ee09a98f12132d95dfc0 diff --git a/generator/vk.xml b/generator/vk.xml deleted file mode 100644 index 7018bbe..0000000 --- a/generator/vk.xml +++ /dev/null @@ -1,8830 +0,0 @@ - - - -Copyright (c) 2015-2018 The Khronos Group Inc. - -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. - ----- Exceptions to the Apache 2.0 License: ---- - -As an exception, if you use this Software to generate code and portions of -this Software are embedded into the generated code as a result, you may -redistribute such product without providing attribution as would otherwise -be required by Sections 4(a), 4(b) and 4(d) of the License. - -In addition, if you combine or link code generated by this Software with -software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1 -("`Combined Software`") and if a court of competent jurisdiction determines -that the patent provision (Section 3), the indemnity provision (Section 9) -or other Section of the License conflicts with the conditions of the -applicable GPL or LGPL license, you may retroactively and prospectively -choose to deem waived or otherwise exclude such Section(s) of the License, -but only in their entirety and only with respect to the Combined Software. - - - -This file, vk.xml, is the Vulkan API Registry. It is a critically important -and normative part of the Vulkan Specification, including a canonical -machine-readable definition of the API, parameter and member validation -language incorporated into the Specification and reference pages, and other -material which is registered by Khronos, such as tags used by extension and -layer authors. The authoritative public version of vk.xml is maintained in -the master branch of the Khronos Vulkan GitHub project. The authoritative -private version is maintained in the master branch of the member gitlab -server. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "vk_platform.h" - - WSI extensions - - - - - - - - - In the current header structure, each platform's interfaces - are confined to a platform-specific header (vulkan_xlib.h, - vulkan_win32.h, etc.). These headers are not self-contained, - and should not include native headers (X11/Xlib.h, - windows.h, etc.). Code should either include vulkan.h after - defining the appropriate VK_USE_PLATFORM_platform_KHR - macros, or include the required native headers prior to - explicitly including the corresponding platform header. - - To accomplish this, the dependencies of native types require - native headers, but the XML defines the content for those - native headers as empty. The actual native header includes - can be restored by modifying the native header tags above - to #include the header file in the 'name' attribute. - - - - - - - - - - - - - - - - - - - - - #define VK_MAKE_VERSION(major, minor, patch) \ - (((major) << 22) | ((minor) << 12) | (patch)) - #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) - #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) - #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) - - // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. -//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 - // Vulkan 1.0 version number -#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 - // Vulkan 1.1 version number -#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 - // Version of this file -#define VK_HEADER_VERSION 76 - - -#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; - - -#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) -#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; -#else - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; -#endif -#endif - - - -#define VK_NULL_HANDLE 0 - - - struct ANativeWindow; - struct AHardwareBuffer; - - typedef uint32_t VkSampleMask; - typedef uint32_t VkBool32; - typedef uint32_t VkFlags; - typedef uint64_t VkDeviceSize; - - Basic C types, pulled in via vk_platform.h - - - - - - - - - - - Bitmask types - typedef VkFlags VkFramebufferCreateFlags; - typedef VkFlags VkQueryPoolCreateFlags; - typedef VkFlags VkRenderPassCreateFlags; - typedef VkFlags VkSamplerCreateFlags; - typedef VkFlags VkPipelineLayoutCreateFlags; - typedef VkFlags VkPipelineCacheCreateFlags; - typedef VkFlags VkPipelineDepthStencilStateCreateFlags; - typedef VkFlags VkPipelineDynamicStateCreateFlags; - typedef VkFlags VkPipelineColorBlendStateCreateFlags; - typedef VkFlags VkPipelineMultisampleStateCreateFlags; - typedef VkFlags VkPipelineRasterizationStateCreateFlags; - typedef VkFlags VkPipelineViewportStateCreateFlags; - typedef VkFlags VkPipelineTessellationStateCreateFlags; - typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; - typedef VkFlags VkPipelineVertexInputStateCreateFlags; - typedef VkFlags VkPipelineShaderStageCreateFlags; - typedef VkFlags VkDescriptorSetLayoutCreateFlags; - typedef VkFlags VkBufferViewCreateFlags; - typedef VkFlags VkInstanceCreateFlags; - typedef VkFlags VkDeviceCreateFlags; - typedef VkFlags VkDeviceQueueCreateFlags; - typedef VkFlags VkQueueFlags; - typedef VkFlags VkMemoryPropertyFlags; - typedef VkFlags VkMemoryHeapFlags; - typedef VkFlags VkAccessFlags; - typedef VkFlags VkBufferUsageFlags; - typedef VkFlags VkBufferCreateFlags; - typedef VkFlags VkShaderStageFlags; - typedef VkFlags VkImageUsageFlags; - typedef VkFlags VkImageCreateFlags; - typedef VkFlags VkImageViewCreateFlags; - typedef VkFlags VkPipelineCreateFlags; - typedef VkFlags VkColorComponentFlags; - typedef VkFlags VkFenceCreateFlags; - typedef VkFlags VkSemaphoreCreateFlags; - typedef VkFlags VkFormatFeatureFlags; - typedef VkFlags VkQueryControlFlags; - typedef VkFlags VkQueryResultFlags; - typedef VkFlags VkShaderModuleCreateFlags; - typedef VkFlags VkEventCreateFlags; - typedef VkFlags VkCommandPoolCreateFlags; - typedef VkFlags VkCommandPoolResetFlags; - typedef VkFlags VkCommandBufferResetFlags; - typedef VkFlags VkCommandBufferUsageFlags; - typedef VkFlags VkQueryPipelineStatisticFlags; - typedef VkFlags VkMemoryMapFlags; - typedef VkFlags VkImageAspectFlags; - typedef VkFlags VkSparseMemoryBindFlags; - typedef VkFlags VkSparseImageFormatFlags; - typedef VkFlags VkSubpassDescriptionFlags; - typedef VkFlags VkPipelineStageFlags; - typedef VkFlags VkSampleCountFlags; - typedef VkFlags VkAttachmentDescriptionFlags; - typedef VkFlags VkStencilFaceFlags; - typedef VkFlags VkCullModeFlags; - typedef VkFlags VkDescriptorPoolCreateFlags; - typedef VkFlags VkDescriptorPoolResetFlags; - typedef VkFlags VkDependencyFlags; - typedef VkFlags VkSubgroupFeatureFlags; - typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; - typedef VkFlags VkObjectEntryUsageFlagsNVX; - - typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; - - - WSI extensions - typedef VkFlags VkCompositeAlphaFlagsKHR; - typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; - typedef VkFlags VkSurfaceTransformFlagsKHR; - typedef VkFlags VkSwapchainCreateFlagsKHR; - typedef VkFlags VkDisplayModeCreateFlagsKHR; - typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; - typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; - typedef VkFlags VkMirSurfaceCreateFlagsKHR; - typedef VkFlags VkViSurfaceCreateFlagsNN; - typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; - typedef VkFlags VkWin32SurfaceCreateFlagsKHR; - typedef VkFlags VkXlibSurfaceCreateFlagsKHR; - typedef VkFlags VkXcbSurfaceCreateFlagsKHR; - typedef VkFlags VkIOSSurfaceCreateFlagsMVK; - typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; - typedef VkFlags VkPeerMemoryFeatureFlags; - - typedef VkFlags VkMemoryAllocateFlags; - - typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; - - typedef VkFlags VkDebugReportFlagsEXT; - typedef VkFlags VkCommandPoolTrimFlags; - - typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; - typedef VkFlags VkExternalMemoryFeatureFlagsNV; - typedef VkFlags VkExternalMemoryHandleTypeFlags; - - typedef VkFlags VkExternalMemoryFeatureFlags; - - typedef VkFlags VkExternalSemaphoreHandleTypeFlags; - - typedef VkFlags VkExternalSemaphoreFeatureFlags; - - typedef VkFlags VkSemaphoreImportFlags; - - typedef VkFlags VkExternalFenceHandleTypeFlags; - - typedef VkFlags VkExternalFenceFeatureFlags; - - typedef VkFlags VkFenceImportFlags; - - typedef VkFlags VkSurfaceCounterFlagsEXT; - typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; - typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; - typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; - typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; - typedef VkFlags VkValidationCacheCreateFlagsEXT; - typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; - typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; - typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; - typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; - typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; - typedef VkFlags VkDescriptorBindingFlagsEXT; - - Types which can be void pointers or class pointers, selected at compile time - VK_DEFINE_HANDLE(VkInstance) - VK_DEFINE_HANDLE(VkPhysicalDevice) - VK_DEFINE_HANDLE(VkDevice) - VK_DEFINE_HANDLE(VkQueue) - VK_DEFINE_HANDLE(VkCommandBuffer) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) - - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) - - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) - - WSI extensions - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) - - Types generated from corresponding enums tags below - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Extensions - - - - - - - - - - - - - - - - - - WSI extensions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - The PFN_vk*Function types are used by VkAllocationCallbacks below - typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( - void* pUserData, - void* pOriginal, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - typedef void (VKAPI_PTR *PFN_vkFreeFunction)( - void* pUserData, - void* pMemory); - - The PFN_vkVoidFunction type are used by VkGet*ProcAddr below - typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); - - The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension - typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage, - void* pUserData); - - The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension - typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData); - - Struct types - - VkStructureType sType - struct VkBaseOutStructure* pNext - - - VkStructureType sType - const struct VkBaseInStructure* pNext - - - int32_t x - int32_t y - - - int32_t x - int32_t y - int32_t z - - - uint32_t width - uint32_t height - - - uint32_t width - uint32_t height - uint32_t depth - - - float x - float y - float width - float height - float minDepth - float maxDepth - - - VkOffset2D offset - VkExtent2D extent - - - VkRect2D rect - uint32_t baseArrayLayer - uint32_t layerCount - - - VkComponentSwizzle r - VkComponentSwizzle g - VkComponentSwizzle b - VkComponentSwizzle a - - - uint32_t apiVersion - uint32_t driverVersion - uint32_t vendorID - uint32_t deviceID - VkPhysicalDeviceType deviceType - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] - uint8_t pipelineCacheUUID[VK_UUID_SIZE] - VkPhysicalDeviceLimits limits - VkPhysicalDeviceSparseProperties sparseProperties - - - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]extension name - uint32_t specVersionversion of the extension specification implemented - - - char layerName[VK_MAX_EXTENSION_NAME_SIZE]layer name - uint32_t specVersionversion of the layer specification implemented - uint32_t implementationVersionbuild or release version of the layer's library - char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the layer - - - VkStructureType sType - const void* pNext - const char* pApplicationName - uint32_t applicationVersion - const char* pEngineName - uint32_t engineVersion - uint32_t apiVersion - - - void* pUserData - PFN_vkAllocationFunction pfnAllocation - PFN_vkReallocationFunction pfnReallocation - PFN_vkFreeFunction pfnFree - PFN_vkInternalAllocationNotification pfnInternalAllocation - PFN_vkInternalFreeNotification pfnInternalFree - - - VkStructureType sType - const void* pNext - VkDeviceQueueCreateFlags flags - uint32_t queueFamilyIndex - uint32_t queueCount - const float* pQueuePriorities - - - VkStructureType sType - const void* pNext - VkDeviceCreateFlags flags - uint32_t queueCreateInfoCount - const VkDeviceQueueCreateInfo* pQueueCreateInfos - uint32_t enabledLayerCount - const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled - uint32_t enabledExtensionCount - const char* const* ppEnabledExtensionNames - const VkPhysicalDeviceFeatures* pEnabledFeatures - - - VkStructureType sType - const void* pNext - VkInstanceCreateFlags flags - const VkApplicationInfo* pApplicationInfo - uint32_t enabledLayerCount - const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled - uint32_t enabledExtensionCount - const char* const* ppEnabledExtensionNamesExtension names to be enabled - - - VkQueueFlags queueFlagsQueue flags - uint32_t queueCount - uint32_t timestampValidBits - VkExtent3D minImageTransferGranularityMinimum alignment requirement for image transfers - - - uint32_t memoryTypeCount - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES] - uint32_t memoryHeapCount - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] - - - VkStructureType sType - const void* pNext - VkDeviceSize allocationSizeSize of memory allocation - uint32_t memoryTypeIndexIndex of the of the memory type to allocate from - - - VkDeviceSize sizeSpecified in bytes - VkDeviceSize alignmentSpecified in bytes - uint32_t memoryTypeBitsBitmask of the allowed memory type indices into memoryTypes[] for this object - - - VkImageAspectFlags aspectMask - VkExtent3D imageGranularity - VkSparseImageFormatFlags flags - - - VkSparseImageFormatProperties formatProperties - uint32_t imageMipTailFirstLod - VkDeviceSize imageMipTailSizeSpecified in bytes, must be a multiple of sparse block size in bytes / alignment - VkDeviceSize imageMipTailOffsetSpecified in bytes, must be a multiple of sparse block size in bytes / alignment - VkDeviceSize imageMipTailStrideSpecified in bytes, must be a multiple of sparse block size in bytes / alignment - - - VkMemoryPropertyFlags propertyFlagsMemory properties of this memory type - uint32_t heapIndexIndex of the memory heap allocations of this memory type are taken from - - - VkDeviceSize sizeAvailable memory in the heap - VkMemoryHeapFlags flagsFlags for the heap - - - VkStructureType sType - const void* pNext - VkDeviceMemory memoryMapped memory object - VkDeviceSize offsetOffset within the memory object where the range starts - VkDeviceSize sizeSize of the range within the memory object - - - VkFormatFeatureFlags linearTilingFeaturesFormat features in case of linear tiling - VkFormatFeatureFlags optimalTilingFeaturesFormat features in case of optimal tiling - VkFormatFeatureFlags bufferFeaturesFormat features supported by buffers - - - VkExtent3D maxExtentmax image dimensions for this resource type - uint32_t maxMipLevelsmax number of mipmap levels for this resource type - uint32_t maxArrayLayersmax array size for this resource type - VkSampleCountFlags sampleCountssupported sample counts for this resource type - VkDeviceSize maxResourceSizemax size (in bytes) of this resource type - - - VkBuffer bufferBuffer used for this descriptor slot when the descriptor is UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC]. VK_NULL_HANDLE otherwise. - VkDeviceSize offsetBase offset from buffer start in bytes to update in the descriptor set. - VkDeviceSize rangeSize in bytes of the buffer resource for this descriptor update. - - - VkSampler samplerSampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise. - VkImageView imageViewImage view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise. - VkImageLayout imageLayoutLayout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE). - - - VkStructureType sType - const void* pNext - VkDescriptorSet dstSetDestination descriptor set - uint32_t dstBindingBinding within the destination descriptor set to write - uint32_t dstArrayElementArray element within the destination binding to write - uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) - VkDescriptorType descriptorTypeDescriptor type to write (determines which members of the array pointed by pDescriptors are going to be used) - const VkDescriptorImageInfo* pImageInfoSampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types. - const VkDescriptorBufferInfo* pBufferInfoRaw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types. - const VkBufferView* pTexelBufferViewBuffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types. - - - VkStructureType sType - const void* pNext - VkDescriptorSet srcSetSource descriptor set - uint32_t srcBindingBinding within the source descriptor set to copy from - uint32_t srcArrayElementArray element within the source binding to copy from - VkDescriptorSet dstSetDestination descriptor set - uint32_t dstBindingBinding within the destination descriptor set to copy to - uint32_t dstArrayElementArray element within the destination binding to copy to - uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) - - - VkStructureType sType - const void* pNext - VkBufferCreateFlags flagsBuffer creation flags - VkDeviceSize sizeSpecified in bytes - VkBufferUsageFlags usageBuffer usage flags - VkSharingMode sharingMode - uint32_t queueFamilyIndexCount - const uint32_t* pQueueFamilyIndices - - - VkStructureType sType - const void* pNext - VkBufferViewCreateFlagsflags - VkBuffer buffer - VkFormat formatOptionally specifies format of elements - VkDeviceSize offsetSpecified in bytes - VkDeviceSize rangeView size specified in bytes - - - VkImageAspectFlags aspectMask - uint32_t mipLevel - uint32_t arrayLayer - - - VkImageAspectFlags aspectMask - uint32_t mipLevel - uint32_t baseArrayLayer - uint32_t layerCount - - - VkImageAspectFlags aspectMask - uint32_t baseMipLevel - uint32_t levelCount - uint32_t baseArrayLayer - uint32_t layerCount - - - VkStructureType sType - const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - - - VkStructureType sType - const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - uint32_t srcQueueFamilyIndexQueue family to transition ownership from - uint32_t dstQueueFamilyIndexQueue family to transition ownership to - VkBuffer bufferBuffer to sync - VkDeviceSize offsetOffset within the buffer to sync - VkDeviceSize sizeAmount of bytes to sync - - - VkStructureType sType - const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - VkImageLayout oldLayoutCurrent layout of the image - VkImageLayout newLayoutNew layout to transition the image to - uint32_t srcQueueFamilyIndexQueue family to transition ownership from - uint32_t dstQueueFamilyIndexQueue family to transition ownership to - VkImage imageImage to sync - VkImageSubresourceRange subresourceRangeSubresource range to sync - - - VkStructureType sType - const void* pNext - VkImageCreateFlags flagsImage creation flags - VkImageType imageType - VkFormat format - VkExtent3D extent - uint32_t mipLevels - uint32_t arrayLayers - VkSampleCountFlagBits samples - VkImageTiling tiling - VkImageUsageFlags usageImage usage flags - VkSharingMode sharingModeCross-queue-family sharing mode - uint32_t queueFamilyIndexCountNumber of queue families to share across - const uint32_t* pQueueFamilyIndicesArray of queue family indices to share across - VkImageLayout initialLayoutInitial image layout for all subresources - - - VkDeviceSize offsetSpecified in bytes - VkDeviceSize sizeSpecified in bytes - VkDeviceSize rowPitchSpecified in bytes - VkDeviceSize arrayPitchSpecified in bytes - VkDeviceSize depthPitchSpecified in bytes - - - VkStructureType sType - const void* pNext - VkImageViewCreateFlags flags - VkImage image - VkImageViewType viewType - VkFormat format - VkComponentMapping components - VkImageSubresourceRange subresourceRange - - - VkDeviceSize srcOffsetSpecified in bytes - VkDeviceSize dstOffsetSpecified in bytes - VkDeviceSize sizeSpecified in bytes - - - VkDeviceSize resourceOffsetSpecified in bytes - VkDeviceSize sizeSpecified in bytes - VkDeviceMemory memory - VkDeviceSize memoryOffsetSpecified in bytes - VkSparseMemoryBindFlagsflags - - - VkImageSubresource subresource - VkOffset3D offset - VkExtent3D extent - VkDeviceMemory memory - VkDeviceSize memoryOffsetSpecified in bytes - VkSparseMemoryBindFlagsflags - - - VkBuffer buffer - uint32_t bindCount - const VkSparseMemoryBind* pBinds - - - VkImage image - uint32_t bindCount - const VkSparseMemoryBind* pBinds - - - VkImage image - uint32_t bindCount - const VkSparseImageMemoryBind* pBinds - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - uint32_t bufferBindCount - const VkSparseBufferMemoryBindInfo* pBufferBinds - uint32_t imageOpaqueBindCount - const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds - uint32_t imageBindCount - const VkSparseImageMemoryBindInfo* pImageBinds - uint32_t signalSemaphoreCount - const VkSemaphore* pSignalSemaphores - - - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images - VkExtent3D extentSpecified in pixels for both compressed and uncompressed images - - - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images - - - VkDeviceSize bufferOffsetSpecified in bytes - uint32_t bufferRowLengthSpecified in texels - uint32_t bufferImageHeight - VkImageSubresourceLayers imageSubresource - VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images - VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images - - - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffset - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffset - VkExtent3D extent - - - VkStructureType sType - const void* pNext - VkShaderModuleCreateFlags flags - size_t codeSizeSpecified in bytes - const uint32_t* pCodeBinary code of size codeSize - - - uint32_t bindingBinding number for this entry - VkDescriptorType descriptorTypeType of the descriptors in this binding - uint32_t descriptorCountNumber of descriptors in this binding - VkShaderStageFlags stageFlagsShader stages this binding is visible to - const VkSampler* pImmutableSamplersImmutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements) - - - VkStructureType sType - const void* pNext - VkDescriptorSetLayoutCreateFlags flags - uint32_t bindingCountNumber of bindings in the descriptor set layout - const VkDescriptorSetLayoutBinding* pBindingsArray of descriptor set layout bindings - - - VkDescriptorType type - uint32_t descriptorCount - - - VkStructureType sType - const void* pNext - VkDescriptorPoolCreateFlags flags - uint32_t maxSets - uint32_t poolSizeCount - const VkDescriptorPoolSize* pPoolSizes - - - VkStructureType sType - const void* pNext - VkDescriptorPool descriptorPool - uint32_t descriptorSetCount - const VkDescriptorSetLayout* pSetLayouts - - - uint32_t constantIDThe SpecConstant ID specified in the BIL - uint32_t offsetOffset of the value in the data block - size_t sizeSize in bytes of the SpecConstant - - - uint32_t mapEntryCountNumber of entries in the map - const VkSpecializationMapEntry* pMapEntriesArray of map entries - size_t dataSizeSize in bytes of pData - const void* pDataPointer to SpecConstant data - - - VkStructureType sType - const void* pNext - VkPipelineShaderStageCreateFlags flags - VkShaderStageFlagBits stageShader stage - VkShaderModule moduleModule containing entry point - const char* pNameNull-terminated entry point name - const VkSpecializationInfo* pSpecializationInfo - - - VkStructureType sType - const void* pNext - VkPipelineCreateFlags flagsPipeline creation flags - VkPipelineShaderStageCreateInfo stage - VkPipelineLayout layoutInterface layout of the pipeline - VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of - int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of - - - uint32_t bindingVertex buffer binding id - uint32_t strideDistance between vertices in bytes (0 = no advancement) - VkVertexInputRate inputRateThe rate at which the vertex data is consumed - - - uint32_t locationlocation of the shader vertex attrib - uint32_t bindingVertex buffer binding id - VkFormat formatformat of source data - uint32_t offsetOffset of first element in bytes from base of vertex - - - VkStructureType sType - const void* pNext - VkPipelineVertexInputStateCreateFlags flags - uint32_t vertexBindingDescriptionCountnumber of bindings - const VkVertexInputBindingDescription* pVertexBindingDescriptions - uint32_t vertexAttributeDescriptionCountnumber of attributes - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions - - - VkStructureType sType - const void* pNext - VkPipelineInputAssemblyStateCreateFlags flags - VkPrimitiveTopology topology - VkBool32 primitiveRestartEnable - - - VkStructureType sType - const void* pNext - VkPipelineTessellationStateCreateFlags flags - uint32_t patchControlPoints - - - VkStructureType sType - const void* pNext - VkPipelineViewportStateCreateFlags flags - uint32_t viewportCount - const VkViewport* pViewports - uint32_t scissorCount - const VkRect2D* pScissors - - - VkStructureType sType - const void* pNext - VkPipelineRasterizationStateCreateFlags flags - VkBool32 depthClampEnable - VkBool32 rasterizerDiscardEnable - VkPolygonMode polygonModeoptional (GL45) - VkCullModeFlags cullMode - VkFrontFace frontFace - VkBool32 depthBiasEnable - float depthBiasConstantFactor - float depthBiasClamp - float depthBiasSlopeFactor - float lineWidth - - - VkStructureType sType - const void* pNext - VkPipelineMultisampleStateCreateFlags flags - VkSampleCountFlagBits rasterizationSamplesNumber of samples used for rasterization - VkBool32 sampleShadingEnableoptional (GL45) - float minSampleShadingoptional (GL45) - const VkSampleMask* pSampleMaskArray of sampleMask words - VkBool32 alphaToCoverageEnable - VkBool32 alphaToOneEnable - - - VkBool32 blendEnable - VkBlendFactor srcColorBlendFactor - VkBlendFactor dstColorBlendFactor - VkBlendOp colorBlendOp - VkBlendFactor srcAlphaBlendFactor - VkBlendFactor dstAlphaBlendFactor - VkBlendOp alphaBlendOp - VkColorComponentFlags colorWriteMask - - - VkStructureType sType - const void* pNext - VkPipelineColorBlendStateCreateFlags flags - VkBool32 logicOpEnable - VkLogicOp logicOp - uint32_t attachmentCount# of pAttachments - const VkPipelineColorBlendAttachmentState* pAttachments - float blendConstants[4] - - - VkStructureType sType - const void* pNext - VkPipelineDynamicStateCreateFlags flags - uint32_t dynamicStateCount - const VkDynamicState* pDynamicStates - - - VkStencilOp failOp - VkStencilOp passOp - VkStencilOp depthFailOp - VkCompareOp compareOp - uint32_t compareMask - uint32_t writeMask - uint32_t reference - - - VkStructureType sType - const void* pNext - VkPipelineDepthStencilStateCreateFlags flags - VkBool32 depthTestEnable - VkBool32 depthWriteEnable - VkCompareOp depthCompareOp - VkBool32 depthBoundsTestEnableoptional (depth_bounds_test) - VkBool32 stencilTestEnable - VkStencilOpState front - VkStencilOpState back - float minDepthBounds - float maxDepthBounds - - - VkStructureType sType - const void* pNext - VkPipelineCreateFlags flagsPipeline creation flags - uint32_t stageCount - const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage - const VkPipelineVertexInputStateCreateInfo* pVertexInputState - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState - const VkPipelineTessellationStateCreateInfo* pTessellationState - const VkPipelineViewportStateCreateInfo* pViewportState - const VkPipelineRasterizationStateCreateInfo* pRasterizationState - const VkPipelineMultisampleStateCreateInfo* pMultisampleState - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState - const VkPipelineColorBlendStateCreateInfo* pColorBlendState - const VkPipelineDynamicStateCreateInfo* pDynamicState - VkPipelineLayout layoutInterface layout of the pipeline - VkRenderPass renderPass - uint32_t subpass - VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of - int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of - - - VkStructureType sType - const void* pNext - VkPipelineCacheCreateFlags flags - size_t initialDataSizeSize of initial data to populate cache, in bytes - const void* pInitialDataInitial data to populate cache - - - VkShaderStageFlags stageFlagsWhich stages use the range - uint32_t offsetStart of the range, in bytes - uint32_t sizeSize of the range, in bytes - - - VkStructureType sType - const void* pNext - VkPipelineLayoutCreateFlags flags - uint32_t setLayoutCountNumber of descriptor sets interfaced by the pipeline - const VkDescriptorSetLayout* pSetLayoutsArray of setCount number of descriptor set layout objects defining the layout of the - uint32_t pushConstantRangeCountNumber of push-constant ranges used by the pipeline - const VkPushConstantRange* pPushConstantRangesArray of pushConstantRangeCount number of ranges used by various shader stages - - - VkStructureType sType - const void* pNext - VkSamplerCreateFlags flags - VkFilter magFilterFilter mode for magnification - VkFilter minFilterFilter mode for minifiation - VkSamplerMipmapMode mipmapModeMipmap selection mode - VkSamplerAddressMode addressModeU - VkSamplerAddressMode addressModeV - VkSamplerAddressMode addressModeW - float mipLodBias - VkBool32 anisotropyEnable - float maxAnisotropy - VkBool32 compareEnable - VkCompareOp compareOp - float minLod - float maxLod - VkBorderColor borderColor - VkBool32 unnormalizedCoordinates - - - VkStructureType sType - const void* pNext - VkCommandPoolCreateFlags flagsCommand pool creation flags - uint32_t queueFamilyIndex - - - VkStructureType sType - const void* pNext - VkCommandPool commandPool - VkCommandBufferLevel level - uint32_t commandBufferCount - - - VkStructureType sType - const void* pNext - VkRenderPass renderPassRender pass for secondary command buffers - uint32_t subpass - VkFramebuffer framebufferFramebuffer for secondary command buffers - VkBool32 occlusionQueryEnableWhether this secondary command buffer may be executed during an occlusion query - VkQueryControlFlags queryFlagsQuery flags used by this secondary command buffer, if executed during an occlusion query - VkQueryPipelineStatisticFlags pipelineStatisticsPipeline statistics that may be counted for this secondary command buffer - - - VkStructureType sType - const void* pNext - VkCommandBufferUsageFlags flagsCommand buffer usage flags - const VkCommandBufferInheritanceInfo* pInheritanceInfoPointer to inheritance info for secondary command buffers - - - VkStructureType sType - const void* pNext - VkRenderPass renderPass - VkFramebuffer framebuffer - VkRect2D renderArea - uint32_t clearValueCount - const VkClearValue* pClearValues - - - float float32[4] - int32_t int32[4] - uint32_t uint32[4] - - - float depth - uint32_t stencil - - - VkClearColorValue color - VkClearDepthStencilValue depthStencil - - - VkImageAspectFlags aspectMask - uint32_t colorAttachment - VkClearValue clearValue - - - VkAttachmentDescriptionFlags flags - VkFormat format - VkSampleCountFlagBits samples - VkAttachmentLoadOp loadOpLoad operation for color or depth data - VkAttachmentStoreOp storeOpStore operation for color or depth data - VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data - VkAttachmentStoreOp stencilStoreOpStore operation for stencil data - VkImageLayout initialLayout - VkImageLayout finalLayout - - - uint32_t attachment - VkImageLayout layout - - - VkSubpassDescriptionFlags flags - VkPipelineBindPoint pipelineBindPointMust be VK_PIPELINE_BIND_POINT_GRAPHICS for now - uint32_t inputAttachmentCount - const VkAttachmentReference* pInputAttachments - uint32_t colorAttachmentCount - const VkAttachmentReference* pColorAttachments - const VkAttachmentReference* pResolveAttachments - const VkAttachmentReference* pDepthStencilAttachment - uint32_t preserveAttachmentCount - const uint32_t* pPreserveAttachments - - - uint32_t srcSubpass - uint32_t dstSubpass - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - VkDependencyFlags dependencyFlags - - - VkStructureType sType - const void* pNext - VkRenderPassCreateFlags flags - uint32_t attachmentCount - const VkAttachmentDescription* pAttachments - uint32_t subpassCount - const VkSubpassDescription* pSubpasses - uint32_t dependencyCount - const VkSubpassDependency* pDependencies - - - VkStructureType sType - const void* pNext - VkEventCreateFlags flagsEvent creation flags - - - VkStructureType sType - const void* pNext - VkFenceCreateFlags flagsFence creation flags - - - VkBool32 robustBufferAccessout of bounds buffer accesses are well defined - VkBool32 fullDrawIndexUint32full 32-bit range of indices for indexed draw calls - VkBool32 imageCubeArrayimage views which are arrays of cube maps - VkBool32 independentBlendblending operations are controlled per-attachment - VkBool32 geometryShadergeometry stage - VkBool32 tessellationShadertessellation control and evaluation stage - VkBool32 sampleRateShadingper-sample shading and interpolation - VkBool32 dualSrcBlendblend operations which take two sources - VkBool32 logicOplogic operations - VkBool32 multiDrawIndirectmulti draw indirect - VkBool32 drawIndirectFirstInstanceindirect draws can use non-zero firstInstance - VkBool32 depthClampdepth clamping - VkBool32 depthBiasClampdepth bias clamping - VkBool32 fillModeNonSolidpoint and wireframe fill modes - VkBool32 depthBoundsdepth bounds test - VkBool32 wideLineslines with width greater than 1 - VkBool32 largePointspoints with size greater than 1 - VkBool32 alphaToOnethe fragment alpha component can be forced to maximum representable alpha value - VkBool32 multiViewportviewport arrays - VkBool32 samplerAnisotropyanisotropic sampler filtering - VkBool32 textureCompressionETC2ETC texture compression formats - VkBool32 textureCompressionASTC_LDRASTC LDR texture compression formats - VkBool32 textureCompressionBCBC1-7 texture compressed formats - VkBool32 occlusionQueryPreciseprecise occlusion queries returning actual sample counts - VkBool32 pipelineStatisticsQuerypipeline statistics query - VkBool32 vertexPipelineStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages - VkBool32 fragmentStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in the fragment stage - VkBool32 shaderTessellationAndGeometryPointSizetessellation and geometry stages can export point size - VkBool32 shaderImageGatherExtendedimage gather with run-time values and independent offsets - VkBool32 shaderStorageImageExtendedFormatsthe extended set of formats can be used for storage images - VkBool32 shaderStorageImageMultisamplemultisample images can be used for storage images - VkBool32 shaderStorageImageReadWithoutFormatread from storage image does not require format qualifier - VkBool32 shaderStorageImageWriteWithoutFormatwrite to storage image does not require format qualifier - VkBool32 shaderUniformBufferArrayDynamicIndexingarrays of uniform buffers can be accessed with dynamically uniform indices - VkBool32 shaderSampledImageArrayDynamicIndexingarrays of sampled images can be accessed with dynamically uniform indices - VkBool32 shaderStorageBufferArrayDynamicIndexingarrays of storage buffers can be accessed with dynamically uniform indices - VkBool32 shaderStorageImageArrayDynamicIndexingarrays of storage images can be accessed with dynamically uniform indices - VkBool32 shaderClipDistanceclip distance in shaders - VkBool32 shaderCullDistancecull distance in shaders - VkBool32 shaderFloat6464-bit floats (doubles) in shaders - VkBool32 shaderInt6464-bit integers in shaders - VkBool32 shaderInt1616-bit integers in shaders - VkBool32 shaderResourceResidencyshader can use texture operations that return resource residency information (requires sparseNonResident support) - VkBool32 shaderResourceMinLodshader can use texture operations that specify minimum resource LOD - VkBool32 sparseBindingSparse resources support: Resource memory can be managed at opaque page level rather than object level - VkBool32 sparseResidencyBufferSparse resources support: GPU can access partially resident buffers - VkBool32 sparseResidencyImage2DSparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images - VkBool32 sparseResidencyImage3DSparse resources support: GPU can access partially resident 3D images - VkBool32 sparseResidency2SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 2 samples - VkBool32 sparseResidency4SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 4 samples - VkBool32 sparseResidency8SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 8 samples - VkBool32 sparseResidency16SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 16 samples - VkBool32 sparseResidencyAliasedSparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) - VkBool32 variableMultisampleRatemultisample rate must be the same for all pipelines in a subpass - VkBool32 inheritedQueriesQueries may be inherited from primary to secondary command buffers - - - VkBool32 residencyStandard2DBlockShapeSparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format) - VkBool32 residencyStandard2DMultisampleBlockShapeSparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format) - VkBool32 residencyStandard3DBlockShapeSparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format) - VkBool32 residencyAlignedMipSizeSparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail - VkBool32 residencyNonResidentStrictSparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded - - - resource maximum sizes - uint32_t maxImageDimension1Dmax 1D image dimension - uint32_t maxImageDimension2Dmax 2D image dimension - uint32_t maxImageDimension3Dmax 3D image dimension - uint32_t maxImageDimensionCubemax cubemap image dimension - uint32_t maxImageArrayLayersmax layers for image arrays - uint32_t maxTexelBufferElementsmax texel buffer size (fstexels) - uint32_t maxUniformBufferRangemax uniform buffer range (bytes) - uint32_t maxStorageBufferRangemax storage buffer range (bytes) - uint32_t maxPushConstantsSizemax size of the push constants pool (bytes) - memory limits - uint32_t maxMemoryAllocationCountmax number of device memory allocations supported - uint32_t maxSamplerAllocationCountmax number of samplers that can be allocated on a device - VkDeviceSize bufferImageGranularityGranularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage - VkDeviceSize sparseAddressSpaceSizeTotal address space available for sparse allocations (bytes) - descriptor set limits - uint32_t maxBoundDescriptorSetsmax number of descriptors sets that can be bound to a pipeline - uint32_t maxPerStageDescriptorSamplersmax number of samplers allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorUniformBuffersmax number of uniform buffers allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorStorageBuffersmax number of storage buffers allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorSampledImagesmax number of sampled images allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorStorageImagesmax number of storage images allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorInputAttachmentsmax number of input attachments allowed per-stage in a descriptor set - uint32_t maxPerStageResourcesmax number of resources allowed by a single stage - uint32_t maxDescriptorSetSamplersmax number of samplers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetUniformBuffersmax number of uniform buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetUniformBuffersDynamicmax number of dynamic uniform buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetStorageBuffersmax number of storage buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetStorageBuffersDynamicmax number of dynamic storage buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetSampledImagesmax number of sampled images allowed in all stages in a descriptor set - uint32_t maxDescriptorSetStorageImagesmax number of storage images allowed in all stages in a descriptor set - uint32_t maxDescriptorSetInputAttachmentsmax number of input attachments allowed in all stages in a descriptor set - vertex stage limits - uint32_t maxVertexInputAttributesmax number of vertex input attribute slots - uint32_t maxVertexInputBindingsmax number of vertex input binding slots - uint32_t maxVertexInputAttributeOffsetmax vertex input attribute offset added to vertex buffer offset - uint32_t maxVertexInputBindingStridemax vertex input binding stride - uint32_t maxVertexOutputComponentsmax number of output components written by vertex shader - tessellation control stage limits - uint32_t maxTessellationGenerationLevelmax level supported by tessellation primitive generator - uint32_t maxTessellationPatchSizemax patch size (vertices) - uint32_t maxTessellationControlPerVertexInputComponentsmax number of input components per-vertex in TCS - uint32_t maxTessellationControlPerVertexOutputComponentsmax number of output components per-vertex in TCS - uint32_t maxTessellationControlPerPatchOutputComponentsmax number of output components per-patch in TCS - uint32_t maxTessellationControlTotalOutputComponentsmax total number of per-vertex and per-patch output components in TCS - tessellation evaluation stage limits - uint32_t maxTessellationEvaluationInputComponentsmax number of input components per vertex in TES - uint32_t maxTessellationEvaluationOutputComponentsmax number of output components per vertex in TES - geometry stage limits - uint32_t maxGeometryShaderInvocationsmax invocation count supported in geometry shader - uint32_t maxGeometryInputComponentsmax number of input components read in geometry stage - uint32_t maxGeometryOutputComponentsmax number of output components written in geometry stage - uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage - uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage - fragment stage limits - uint32_t maxFragmentInputComponentsmax number of input components read in fragment stage - uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage - uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending - uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers - compute stage limits - uint32_t maxComputeSharedMemorySizemax total storage size of work group local storage (bytes) - uint32_t maxComputeWorkGroupCount[3]max num of compute work groups that may be dispatched by a single command (x,y,z) - uint32_t maxComputeWorkGroupInvocationsmax total compute invocations in a single local work group - uint32_t maxComputeWorkGroupSize[3]max local size of a compute work group (x,y,z) - uint32_t subPixelPrecisionBitsnumber bits of subpixel precision in screen x and y - uint32_t subTexelPrecisionBitsnumber bits of precision for selecting texel weights - uint32_t mipmapPrecisionBitsnumber bits of precision for selecting mipmap weights - uint32_t maxDrawIndexedIndexValuemax index value for indexed draw calls (for 32-bit indices) - uint32_t maxDrawIndirectCountmax draw count for indirect draw calls - float maxSamplerLodBiasmax absolute sampler LOD bias - float maxSamplerAnisotropymax degree of sampler anisotropy - uint32_t maxViewportsmax number of active viewports - uint32_t maxViewportDimensions[2]max viewport dimensions (x,y) - float viewportBoundsRange[2]viewport bounds range (min,max) - uint32_t viewportSubPixelBitsnumber bits of subpixel precision for viewport - size_t minMemoryMapAlignmentmin required alignment of pointers returned by MapMemory (bytes) - VkDeviceSize minTexelBufferOffsetAlignmentmin required alignment for texel buffer offsets (bytes) - VkDeviceSize minUniformBufferOffsetAlignmentmin required alignment for uniform buffer sizes and offsets (bytes) - VkDeviceSize minStorageBufferOffsetAlignmentmin required alignment for storage buffer offsets (bytes) - int32_t minTexelOffsetmin texel offset for OpTextureSampleOffset - uint32_t maxTexelOffsetmax texel offset for OpTextureSampleOffset - int32_t minTexelGatherOffsetmin texel offset for OpTextureGatherOffset - uint32_t maxTexelGatherOffsetmax texel offset for OpTextureGatherOffset - float minInterpolationOffsetfurthest negative offset for interpolateAtOffset - float maxInterpolationOffsetfurthest positive offset for interpolateAtOffset - uint32_t subPixelInterpolationOffsetBitsnumber of subpixel bits for interpolateAtOffset - uint32_t maxFramebufferWidthmax width for a framebuffer - uint32_t maxFramebufferHeightmax height for a framebuffer - uint32_t maxFramebufferLayersmax layer count for a layered framebuffer - VkSampleCountFlags framebufferColorSampleCountssupported color sample counts for a framebuffer - VkSampleCountFlags framebufferDepthSampleCountssupported depth sample counts for a framebuffer - VkSampleCountFlags framebufferStencilSampleCountssupported stencil sample counts for a framebuffer - VkSampleCountFlags framebufferNoAttachmentsSampleCountssupported sample counts for a framebuffer with no attachments - uint32_t maxColorAttachmentsmax number of color attachments per subpass - VkSampleCountFlags sampledImageColorSampleCountssupported color sample counts for a non-integer sampled image - VkSampleCountFlags sampledImageIntegerSampleCountssupported sample counts for an integer image - VkSampleCountFlags sampledImageDepthSampleCountssupported depth sample counts for a sampled image - VkSampleCountFlags sampledImageStencilSampleCountssupported stencil sample counts for a sampled image - VkSampleCountFlags storageImageSampleCountssupported sample counts for a storage image - uint32_t maxSampleMaskWordsmax number of sample mask words - VkBool32 timestampComputeAndGraphicstimestamps on graphics and compute queues - float timestampPeriodnumber of nanoseconds it takes for timestamp query value to increment by 1 - uint32_t maxClipDistancesmax number of clip distances - uint32_t maxCullDistancesmax number of cull distances - uint32_t maxCombinedClipAndCullDistancesmax combined number of user clipping - uint32_t discreteQueuePrioritiesdistinct queue priorities available - float pointSizeRange[2]range (min,max) of supported point sizes - float lineWidthRange[2]range (min,max) of supported line widths - float pointSizeGranularitygranularity of supported point sizes - float lineWidthGranularitygranularity of supported line widths - VkBool32 strictLinesline rasterization follows preferred rules - VkBool32 standardSampleLocationssupports standard sample locations for all supported sample counts - VkDeviceSize optimalBufferCopyOffsetAlignmentoptimal offset of buffer copies - VkDeviceSize optimalBufferCopyRowPitchAlignmentoptimal pitch of buffer copies - VkDeviceSize nonCoherentAtomSizeminimum size and alignment for non-coherent host-mapped device memory access - - - VkStructureType sType - const void* pNext - VkSemaphoreCreateFlags flagsSemaphore creation flags - - - VkStructureType sType - const void* pNext - VkQueryPoolCreateFlags flags - VkQueryType queryType - uint32_t queryCount - VkQueryPipelineStatisticFlags pipelineStatisticsOptional - - - VkStructureType sType - const void* pNext - VkFramebufferCreateFlags flags - VkRenderPass renderPass - uint32_t attachmentCount - const VkImageView* pAttachments - uint32_t width - uint32_t height - uint32_t layers - - - uint32_t vertexCount - uint32_t instanceCount - uint32_t firstVertex - uint32_t firstInstance - - - uint32_t indexCount - uint32_t instanceCount - uint32_t firstIndex - int32_t vertexOffset - uint32_t firstInstance - - - uint32_t x - uint32_t y - uint32_t z - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - const VkPipelineStageFlags* pWaitDstStageMask - uint32_t commandBufferCount - const VkCommandBuffer* pCommandBuffers - uint32_t signalSemaphoreCount - const VkSemaphore* pSignalSemaphores - - WSI extensions - - VkDisplayKHR displayHandle of the display object - const char* displayNameName of the display - VkExtent2D physicalDimensionsIn millimeters? - VkExtent2D physicalResolutionMax resolution for CRT? - VkSurfaceTransformFlagsKHR supportedTransformsone or more bits from VkSurfaceTransformFlagsKHR - VkBool32 planeReorderPossibleVK_TRUE if the overlay plane's z-order can be changed on this display. - VkBool32 persistentContentVK_TRUE if this is a "smart" display that supports self-refresh/internal buffering. - - - VkDisplayKHR currentDisplayDisplay the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use. - uint32_t currentStackIndexCurrent z-order of the plane. - - - VkExtent2D visibleRegionVisible scanout region. - uint32_t refreshRateNumber of times per second the display is updated. - - - VkDisplayModeKHR displayModeHandle of this display mode. - VkDisplayModeParametersKHR parametersThe parameters this mode uses. - - - VkStructureType sType - const void* pNext - VkDisplayModeCreateFlagsKHR flags - VkDisplayModeParametersKHR parametersThe parameters this mode uses. - - - VkDisplayPlaneAlphaFlagsKHR supportedAlphaTypes of alpha blending supported, if any. - VkOffset2D minSrcPositionDoes the plane have any position and extent restrictions? - VkOffset2D maxSrcPosition - VkExtent2D minSrcExtent - VkExtent2D maxSrcExtent - VkOffset2D minDstPosition - VkOffset2D maxDstPosition - VkExtent2D minDstExtent - VkExtent2D maxDstExtent - - - VkStructureType sType - const void* pNext - VkDisplaySurfaceCreateFlagsKHR flags - VkDisplayModeKHR displayModeThe mode to use when displaying this surface - uint32_t planeIndexThe plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount. - uint32_t planeStackIndexThe z-order of the plane. - VkSurfaceTransformFlagBitsKHR transformTransform to apply to the images as part of the scanout operation - float globalAlphaGlobal alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR - VkDisplayPlaneAlphaFlagBitsKHR alphaModeWhat type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha. - VkExtent2D imageExtentsize of the images to use with this surface - - - VkStructureType sType - const void* pNext - VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display. - VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in. - VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. - - - uint32_t minImageCountSupported minimum number of images for the surface - uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited - VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined - VkExtent2D minImageExtentSupported minimum image width and height for the surface - VkExtent2D maxImageExtentSupported maximum image width and height for the surface - uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface - VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported - VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation - VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported - VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface - - - VkStructureType sType - const void* pNext - VkAndroidSurfaceCreateFlagsKHR flags - struct ANativeWindow* window - - - VkStructureType sType - const void* pNext - VkMirSurfaceCreateFlagsKHR flags - MirConnection* connection - MirSurface* mirSurface - - - VkStructureType sType - const void* pNext - VkViSurfaceCreateFlagsNN flags - void* window - - - VkStructureType sType - const void* pNext - VkWaylandSurfaceCreateFlagsKHR flags - struct wl_display* display - struct wl_surface* surface - - - VkStructureType sType - const void* pNext - VkWin32SurfaceCreateFlagsKHR flags - HINSTANCE hinstance - HWND hwnd - - - VkStructureType sType - const void* pNext - VkXlibSurfaceCreateFlagsKHR flags - Display* dpy - Window window - - - VkStructureType sType - const void* pNext - VkXcbSurfaceCreateFlagsKHR flags - xcb_connection_t* connection - xcb_window_t window - - - VkFormat formatSupported pair of rendering format - VkColorSpaceKHR colorSpaceand color space for the surface - - - VkStructureType sType - const void* pNext - VkSwapchainCreateFlagsKHR flags - VkSurfaceKHR surfaceThe swapchain's target surface - uint32_t minImageCountMinimum number of presentation images the application needs - VkFormat imageFormatFormat of the presentation images - VkColorSpaceKHR imageColorSpaceColorspace of the presentation images - VkExtent2D imageExtentDimensions of the presentation images - uint32_t imageArrayLayersDetermines the number of views for multiview/stereo presentation - VkImageUsageFlags imageUsageBits indicating how the presentation images will be used - VkSharingMode imageSharingModeSharing mode used for the presentation images - uint32_t queueFamilyIndexCountNumber of queue families having access to the images in case of concurrent sharing mode - const uint32_t* pQueueFamilyIndicesArray of queue family indices having access to the images in case of concurrent sharing mode - VkSurfaceTransformFlagBitsKHR preTransformThe transform, relative to the device's natural orientation, applied to the image content prior to presentation - VkCompositeAlphaFlagBitsKHR compositeAlphaThe alpha blending mode used when compositing this surface with other surfaces in the window system - VkPresentModeKHR presentModeWhich presentation mode to use for presents on this swap chain - VkBool32 clippedSpecifies whether presentable images may be affected by window clip regions - VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCountNumber of semaphores to wait for before presenting - const VkSemaphore* pWaitSemaphoresSemaphores to wait for before presenting - uint32_t swapchainCountNumber of swapchains to present in this call - const VkSwapchainKHR* pSwapchainsSwapchains to present an image from - const uint32_t* pImageIndicesIndices of which presentable images to present - VkResult* pResultsOptional (i.e. if non-NULL) VkResult for each swapchain - - - VkStructureType sType - const void* pNext - VkDebugReportFlagsEXT flagsIndicates which events call this callback - PFN_vkDebugReportCallbackEXT pfnCallbackFunction pointer of a callback function - void* pUserDataUser data provided to callback function - - - VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT - const void* pNext - uint32_t disabledValidationCheckCountNumber of validation checks to disable - VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable - - - VkStructureType sType - const void* pNext - VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline - - - VkStructureType sType - const void* pNext - VkDebugReportObjectTypeEXT objectTypeThe type of the object - uint64_t objectThe handle of the object, cast to uint64_t - const char* pObjectNameName to apply to the object - - - VkStructureType sType - const void* pNext - VkDebugReportObjectTypeEXT objectTypeThe type of the object - uint64_t objectThe handle of the object, cast to uint64_t - uint64_t tagNameThe name of the tag to set on the object - size_t tagSizeThe length in bytes of the tag data - const void* pTagTag data to attach to the object - - - VkStructureType sType - const void* pNext - const char* pMarkerNameName of the debug marker - float color[4]Optional color for debug marker - - - VkStructureType sType - const void* pNext - VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation - - - VkStructureType sType - const void* pNext - VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation - - - VkStructureType sType - const void* pNext - VkImage imageImage that this allocation will be bound to - VkBuffer bufferBuffer that this allocation will be bound to - - - VkImageFormatProperties imageFormatProperties - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleType - HANDLE handle - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - - - VkStructureType sType - const void* pNext - uint32_t acquireCount - const VkDeviceMemory* pAcquireSyncs - const uint64_t* pAcquireKeys - const uint32_t* pAcquireTimeoutMilliseconds - uint32_t releaseCount - const VkDeviceMemory* pReleaseSyncs - const uint64_t* pReleaseKeys - - - VkStructureType sType - const void* pNext - VkBool32 computeBindingPointSupport - - - VkStructureType sType - const void* pNext - uint32_t maxIndirectCommandsLayoutTokenCount - uint32_t maxObjectEntryCounts - uint32_t minSequenceCountBufferOffsetAlignment - uint32_t minSequenceIndexBufferOffsetAlignment - uint32_t minCommandsTokenBufferOffsetAlignment - - - VkIndirectCommandsTokenTypeNVX tokenType - VkBuffer bufferbuffer containing tableEntries and additional data for indirectCommands - VkDeviceSize offsetoffset from the base address of the buffer - - - VkIndirectCommandsTokenTypeNVX tokenType - uint32_t bindingUnitBinding unit for vertex attribute / descriptor set, offset for pushconstants - uint32_t dynamicCountNumber of variable dynamic values for descriptor set / push constants - uint32_t divisorRate the which the array is advanced per element (must be power of 2, minimum 1) - - - VkStructureType sType - const void* pNext - VkPipelineBindPoint pipelineBindPoint - VkIndirectCommandsLayoutUsageFlagsNVX flags - uint32_t tokenCount - const VkIndirectCommandsLayoutTokenNVX* pTokens - - - VkStructureType sType - const void* pNext - VkObjectTableNVX objectTable - VkIndirectCommandsLayoutNVX indirectCommandsLayout - uint32_t indirectCommandsTokenCount - const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens - uint32_t maxSequencesCount - VkCommandBuffer targetCommandBuffer - VkBuffer sequencesCountBuffer - VkDeviceSize sequencesCountOffset - VkBuffer sequencesIndexBuffer - VkDeviceSize sequencesIndexOffset - - - VkStructureType sType - const void* pNext - VkObjectTableNVX objectTable - VkIndirectCommandsLayoutNVX indirectCommandsLayout - uint32_t maxSequencesCount - - - VkStructureType sType - const void* pNext - uint32_t objectCount - const VkObjectEntryTypeNVX* pObjectEntryTypes - const uint32_t* pObjectEntryCounts - const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags - - uint32_t maxUniformBuffersPerDescriptor - uint32_t maxStorageBuffersPerDescriptor - uint32_t maxStorageImagesPerDescriptor - uint32_t maxSampledImagesPerDescriptor - uint32_t maxPipelineLayouts - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipeline pipeline - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipelineLayout pipelineLayout - VkDescriptorSet descriptorSet - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkBuffer buffer - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkBuffer buffer - VkIndexType indexType - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipelineLayout pipelineLayout - VkShaderStageFlags stageFlags - - - VkStructureType sType - void* pNext - VkPhysicalDeviceFeatures features - - - - VkStructureType sType - void* pNext - VkPhysicalDeviceProperties properties - - - - VkStructureType sType - void* pNext - VkFormatProperties formatProperties - - - - VkStructureType sType - void* pNext - VkImageFormatProperties imageFormatProperties - - - - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags - - - - VkStructureType sType - void* pNext - VkQueueFamilyProperties queueFamilyProperties - - - - VkStructureType sType - void* pNext - VkPhysicalDeviceMemoryProperties memoryProperties - - - - VkStructureType sType - void* pNext - VkSparseImageFormatProperties properties - - - - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkSampleCountFlagBits samples - VkImageUsageFlags usage - VkImageTiling tiling - - - - VkStructureType sType - void* pNext - uint32_t maxPushDescriptors - - - VkStructureType sType - const void* pNext - uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount - const VkPresentRegionKHR* pRegionsThe regions that have changed - - - uint32_t rectangleCountNumber of rectangles in pRectangles - const VkRectLayerKHR* pRectanglesArray of rectangles that have changed in a swapchain's image(s) - - - VkOffset2D offsetupper-left corner of a rectangle that has not changed, in pixels of a presentation images - VkExtent2D extentDimensions of a rectangle that has not changed, in pixels of a presentation images - uint32_t layerLayer of a swapchain's image(s), for stereoscopic-3D images - - - VkStructureType sType - void* pNext - VkBool32 variablePointersStorageBuffer - VkBool32 variablePointers - - - - VkExternalMemoryFeatureFlags externalMemoryFeatures - VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlags compatibleHandleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalMemoryProperties externalMemoryProperties - - - - VkStructureType sType - const void* pNext - VkBufferCreateFlags flags - VkBufferUsageFlags usage - VkExternalMemoryHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalMemoryProperties externalMemoryProperties - - - - VkStructureType sType - void* pNext - uint8_t deviceUUID[VK_UUID_SIZE] - uint8_t driverUUID[VK_UUID_SIZE] - uint8_t deviceLUID[VK_LUID_SIZE] - uint32_t deviceNodeMask - VkBool32 deviceLUIDValid - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - HANDLE handle - LPCWSTR name - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - LPCWSTR name - - - VkStructureType sType - void* pNext - uint32_t memoryTypeBits - - - VkStructureType sType - const void* pNext - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - int fd - - - VkStructureType sType - void* pNext - uint32_t memoryTypeBits - - - VkStructureType sType - const void* pNext - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - uint32_t acquireCount - const VkDeviceMemory* pAcquireSyncs - const uint64_t* pAcquireKeys - const uint32_t* pAcquireTimeouts - uint32_t releaseCount - const VkDeviceMemory* pReleaseSyncs - const uint64_t* pReleaseKeys - - - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures - - - - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkSemaphoreImportFlags flags - VkExternalSemaphoreHandleTypeFlagBits handleType - HANDLE handle - LPCWSTR name - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - LPCWSTR name - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreValuesCount - const uint64_t* pWaitSemaphoreValues - uint32_t signalSemaphoreValuesCount - const uint64_t* pSignalSemaphoreValues - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkSemaphoreImportFlags flags - VkExternalSemaphoreHandleTypeFlagBits handleType - int fd - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes - VkExternalFenceHandleTypeFlags compatibleHandleTypes - VkExternalFenceFeatureFlags externalFenceFeatures - - - - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkFence fence - VkFenceImportFlags flags - VkExternalFenceHandleTypeFlagBits handleType - HANDLE handle - LPCWSTR name - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - LPCWSTR name - - - VkStructureType sType - const void* pNext - VkFence fence - VkExternalFenceHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkFence fence - VkFenceImportFlags flags - VkExternalFenceHandleTypeFlagBits handleType - int fd - - - VkStructureType sType - const void* pNext - VkFence fence - VkExternalFenceHandleTypeFlagBits handleType - - - VkStructureType sType - void* pNext - VkBool32 multiviewMultiple views in a renderpass - VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader - VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader - - - - VkStructureType sType - void* pNext - uint32_t maxMultiviewViewCountmax number of views in a subpass - uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass - - - - VkStructureType sType - const void* pNext - uint32_t subpassCount - const uint32_t* pViewMasks - uint32_t dependencyCount - const int32_t* pViewOffsets - uint32_t correlationMaskCount - const uint32_t* pCorrelationMasks - - - - VkStructureType sType - void* pNext - uint32_t minImageCountSupported minimum number of images for the surface - uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited - VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined - VkExtent2D minImageExtentSupported minimum image width and height for the surface - VkExtent2D maxImageExtentSupported maximum image width and height for the surface - uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface - VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported - VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation - VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported - VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface - VkSurfaceCounterFlagsEXT supportedSurfaceCounters - - - VkStructureType sType - const void* pNext - VkDisplayPowerStateEXT powerState - - - VkStructureType sType - const void* pNext - VkDeviceEventTypeEXT deviceEvent - - - VkStructureType sType - const void* pNext - VkDisplayEventTypeEXT displayEvent - - - VkStructureType sType - const void* pNext - VkSurfaceCounterFlagsEXT surfaceCounters - - - VkStructureType sType - void* pNext - uint32_t physicalDeviceCount - VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE] - VkBool32 subsetAllocation - - - - VkStructureType sType - const void* pNext - VkMemoryAllocateFlags flags - uint32_t deviceMask - - - - VkStructureType sType - const void* pNext - VkBuffer buffer - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - - VkStructureType sType - const void* pNext - uint32_t deviceIndexCount - const uint32_t* pDeviceIndices - - - - VkStructureType sType - const void* pNext - VkImage image - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - - VkStructureType sType - const void* pNext - uint32_t deviceIndexCount - const uint32_t* pDeviceIndices - uint32_t splitInstanceBindRegionCount - const VkRect2D* pSplitInstanceBindRegions - - - - VkStructureType sType - const void* pNext - uint32_t deviceMask - uint32_t deviceRenderAreaCount - const VkRect2D* pDeviceRenderAreas - - - - VkStructureType sType - const void* pNext - uint32_t deviceMask - - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCount - const uint32_t* pWaitSemaphoreDeviceIndices - uint32_t commandBufferCount - const uint32_t* pCommandBufferDeviceMasks - uint32_t signalSemaphoreCount - const uint32_t* pSignalSemaphoreDeviceIndices - - - - VkStructureType sType - const void* pNext - uint32_t resourceDeviceIndex - uint32_t memoryDeviceIndex - - - - VkStructureType sType - const void* pNext - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE] - VkDeviceGroupPresentModeFlagsKHR modes - - - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - - - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - uint32_t imageIndex - - - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - uint64_t timeout - VkSemaphore semaphore - VkFence fence - uint32_t deviceMask - - - VkStructureType sType - const void* pNext - uint32_t swapchainCount - const uint32_t* pDeviceMasks - VkDeviceGroupPresentModeFlagBitsKHR mode - - - VkStructureType sType - const void* pNext - uint32_t physicalDeviceCount - const VkPhysicalDevice* pPhysicalDevices - - - - VkStructureType sType - const void* pNext - VkDeviceGroupPresentModeFlagsKHR modes - - - uint32_t dstBindingBinding within the destination descriptor set to write - uint32_t dstArrayElementArray element within the destination binding to write - uint32_t descriptorCountNumber of descriptors to write - VkDescriptorType descriptorTypeDescriptor type to write - size_t offsetOffset into pData where the descriptors to update are stored - size_t strideStride between two descriptors in pData when writing more than one descriptor - - - - VkStructureType sType - void* pNext - VkDescriptorUpdateTemplateCreateFlags flags - uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template - VkDescriptorUpdateTemplateType templateType - VkDescriptorSetLayout descriptorSetLayout - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayoutpipelineLayoutIf used for push descriptors, this is the only allowed layout - uint32_t set - - - - float x - float y - - - Display primary in chromaticity coordinates - VkStructureType sType - const void* pNext - From SMPTE 2086 - VkXYColorEXT displayPrimaryRedDisplay primary's Red - VkXYColorEXT displayPrimaryGreenDisplay primary's Green - VkXYColorEXT displayPrimaryBlueDisplay primary's Blue - VkXYColorEXT whitePointDisplay primary's Blue - float maxLuminanceDisplay maximum luminance - float minLuminanceDisplay minimum luminance - From CTA 861.3 - float maxContentLightLevelContent maximum luminance - float maxFrameAverageLightLevel - - - uint64_t refreshDurationNumber of nanoseconds from the start of one refresh cycle to the next - - - uint32_t presentIDApplication-provided identifier, previously given to vkQueuePresentKHR - uint64_t desiredPresentTimeEarliest time an image should have been presented, previously given to vkQueuePresentKHR - uint64_t actualPresentTimeTime the image was actually displayed - uint64_t earliestPresentTimeEarliest time the image could have been displayed - uint64_t presentMarginHow early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime - - - VkStructureType sType - const void* pNext - uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount - const VkPresentTimeGOOGLE* pTimesThe earliest times to present images - - - uint32_t presentIDApplication-provided identifier - uint64_t desiredPresentTimeEarliest time an image should be presented - - - VkStructureType sType - const void* pNext - VkIOSSurfaceCreateFlagsMVK flags - const void* pView - - - VkStructureType sType - const void* pNext - VkMacOSSurfaceCreateFlagsMVK flags - const void* pView - - - float xcoeff - float ycoeff - - - VkStructureType sType - const void* pNext - VkBool32 viewportWScalingEnable - uint32_t viewportCount - const VkViewportWScalingNV* pViewportWScalings - - - VkViewportCoordinateSwizzleNV x - VkViewportCoordinateSwizzleNV y - VkViewportCoordinateSwizzleNV z - VkViewportCoordinateSwizzleNV w - - - VkStructureType sType - const void* pNext - VkPipelineViewportSwizzleStateCreateFlagsNV flags - uint32_t viewportCount - const VkViewportSwizzleNV* pViewportSwizzles - - - VkStructureType sType - void* pNext - uint32_t maxDiscardRectanglesmax number of active discard rectangles - - - VkStructureType sType - const void* pNext - VkPipelineDiscardRectangleStateCreateFlagsEXT flags - VkDiscardRectangleModeEXT discardRectangleMode - uint32_t discardRectangleCount - const VkRect2D* pDiscardRectangles - - - VkStructureType sType - void* pNext - VkBool32 perViewPositionAllComponents - - - uint32_t subpass - uint32_t inputAttachmentIndex - VkImageAspectFlags aspectMask - - - - VkStructureType sType - const void* pNext - uint32_t aspectReferenceCount - const VkInputAttachmentAspectReference* pAspectReferences - - - - VkStructureType sType - const void* pNext - VkSurfaceKHR surface - - - VkStructureType sType - void* pNext - VkSurfaceCapabilitiesKHR surfaceCapabilities - - - VkStructureType sType - void* pNext - VkSurfaceFormatKHR surfaceFormat - - - VkStructureType sType - void* pNext - VkDisplayPropertiesKHR displayProperties - - - VkStructureType sType - void* pNext - VkDisplayPlanePropertiesKHR displayPlaneProperties - - - VkStructureType sType - void* pNext - VkDisplayModePropertiesKHR displayModeProperties - - - VkStructureType sType - const void* pNext - VkDisplayModeKHR mode - uint32_t planeIndex - - - VkStructureType sType - void* pNext - VkDisplayPlaneCapabilitiesKHR capabilities - - - VkStructureType sType - void* pNext - VkImageUsageFlags sharedPresentSupportedUsageFlagsSupported image usage flags if swapchain created using a shared present mode - - - VkStructureType sType - void* pNext - VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock - VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block - VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant - VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs - - - - VkStructureType sType - void* pNext - uint32_t subgroupSizeThe size of a subgroup for this queue. - VkShaderStageFlags supportedStagesBitfield of what shader stages support subgroup operations - VkSubgroupFeatureFlags supportedOperationsBitfield of what subgroup operations are supported. - VkBool32 quadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. - - - VkStructureType sType - const void* pNext - VkBuffer buffer - - - - VkStructureType sType - const void* pNext - VkImage image - - - - VkStructureType sType - const void* pNext - VkImage image - - - - VkStructureType sType - void* pNext - VkMemoryRequirements memoryRequirements - - - - VkStructureType sType - void* pNext - VkSparseImageMemoryRequirements memoryRequirements - - - - VkStructureType sType - void* pNext - VkPointClippingBehavior pointClippingBehavior - - - - VkStructureType sType - void* pNext - VkBool32 prefersDedicatedAllocation - VkBool32 requiresDedicatedAllocation - - - - VkStructureType sType - const void* pNext - VkImage imageImage that this allocation will be bound to - VkBuffer bufferBuffer that this allocation will be bound to - - - - VkStructureType sType - const void* pNext - VkImageUsageFlags usage - - - - VkStructureType sType - const void* pNext - VkTessellationDomainOrigin domainOrigin - - - - VkStructureType sType - const void* pNext - VkSamplerYcbcrConversion conversion - - - - VkStructureType sType - const void* pNext - VkFormat format - VkSamplerYcbcrModelConversion ycbcrModel - VkSamplerYcbcrRange ycbcrRange - VkComponentMapping components - VkChromaLocation xChromaOffset - VkChromaLocation yChromaOffset - VkFilter chromaFilter - VkBool32 forceExplicitReconstruction - - - - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect - - - - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect - - - - VkStructureType sType - void* pNext - VkBool32 samplerYcbcrConversionSampler color conversion supported - - - - VkStructureType sType - void* pNext - uint32_t combinedImageSamplerDescriptorCount - - - - VkStructureType sType - void* pNext - VkBool32 supportsTextureGatherLODBiasAMD - - - VkStructureType sType - const void* pNext - VkBool32 protectedSubmitSubmit protected command buffers - - - VkStructureType sType - void* pNext - VkBool32 protectedMemory - - - VkStructureType sType - void* pNext - VkBool32 protectedNoFault - - - VkStructureType sType - const void* pNext - VkDeviceQueueCreateFlags flags - uint32_t queueFamilyIndex - uint32_t queueIndex - - - VkStructureType sType - const void* pNext - VkPipelineCoverageToColorStateCreateFlagsNV flags - VkBool32 coverageToColorEnable - uint32_t coverageToColorLocation - - - VkStructureType sType - void* pNext - VkBool32 filterMinmaxSingleComponentFormats - VkBool32 filterMinmaxImageComponentMapping - - - float x - float y - - - VkStructureType sType - const void* pNext - VkSampleCountFlagBits sampleLocationsPerPixel - VkExtent2D sampleLocationGridSize - uint32_t sampleLocationsCount - const VkSampleLocationEXT* pSampleLocations - - - uint32_t attachmentIndex - VkSampleLocationsInfoEXT sampleLocationsInfo - - - uint32_t subpassIndex - VkSampleLocationsInfoEXT sampleLocationsInfo - - - VkStructureType sType - const void* pNext - uint32_t attachmentInitialSampleLocationsCount - const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations - uint32_t postSubpassSampleLocationsCount - const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations - - - VkStructureType sType - const void* pNext - VkBool32 sampleLocationsEnable - VkSampleLocationsInfoEXT sampleLocationsInfo - - - VkStructureType sType - void* pNext - VkSampleCountFlags sampleLocationSampleCounts - VkExtent2D maxSampleLocationGridSize - float sampleLocationCoordinateRange[2] - uint32_t sampleLocationSubPixelBits - VkBool32 variableSampleLocations - - - VkStructureType sType - void* pNext - VkExtent2D maxSampleLocationGridSize - - - VkStructureType sType - const void* pNext - VkSamplerReductionModeEXT reductionMode - - - VkStructureType sType - void* pNext - VkBool32 advancedBlendCoherentOperations - - - VkStructureType sType - void* pNext - uint32_t advancedBlendMaxColorAttachments - VkBool32 advancedBlendIndependentBlend - VkBool32 advancedBlendNonPremultipliedSrcColor - VkBool32 advancedBlendNonPremultipliedDstColor - VkBool32 advancedBlendCorrelatedOverlap - VkBool32 advancedBlendAllOperations - - - VkStructureType sType - const void* pNext - VkBool32 srcPremultiplied - VkBool32 dstPremultiplied - VkBlendOverlapEXT blendOverlap - - - VkStructureType sType - const void* pNext - VkPipelineCoverageModulationStateCreateFlagsNV flags - VkCoverageModulationModeNV coverageModulationMode - VkBool32 coverageModulationTableEnable - uint32_t coverageModulationTableCount - const float* pCoverageModulationTable - - - VkStructureType sType - const void* pNext - uint32_t viewFormatCount - const VkFormat* pViewFormats - - - VkStructureType sType - const void* pNext - VkValidationCacheCreateFlagsEXT flags - size_t initialDataSize - const void* pInitialData - - - VkStructureType sType - const void* pNext - VkValidationCacheEXT validationCache - - - VkStructureType sType - void* pNext - uint32_t maxPerSetDescriptors - VkDeviceSize maxMemoryAllocationSize - - - - VkStructureType sType - void* pNext - VkBool32 supported - - - - VkStructureType sType - void* pNext - VkBool32 shaderDrawParameters - - - VkStructureType sType - const void* pNext - const void* handle - int stride - int format - int usage - - - uint32_t numUsedVgprs - uint32_t numUsedSgprs - uint32_t ldsSizePerLocalWorkGroup - size_t ldsUsageSizeInBytes - size_t scratchMemUsageInBytes - - - VkShaderStageFlags shaderStageMask - VkShaderResourceUsageAMD resourceUsage - uint32_t numPhysicalVgprs - uint32_t numPhysicalSgprs - uint32_t numAvailableVgprs - uint32_t numAvailableSgprs - uint32_t computeWorkGroupSize[3] - - - VkStructureType sType - const void* pNext - VkQueueGlobalPriorityEXT globalPriority - - - VkStructureType sType - const void* pNext - VkObjectType objectType - uint64_t objectHandle - const char* pObjectName - - - VkStructureType sType - const void* pNext - VkObjectType objectType - uint64_t objectHandle - uint64_t tagName - size_t tagSize - const void* pTag - - - VkStructureType sType - const void* pNext - const char* pLabelName - float color[4] - - - VkStructureType sType - const void* pNext - VkDebugUtilsMessengerCreateFlagsEXT flags - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity - VkDebugUtilsMessageTypeFlagsEXT messageType - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback - void* pUserData - - - VkStructureType sType - const void* pNext - VkDebugUtilsMessengerCallbackDataFlagsEXT flags - const char* pMessageIdName - int32_t messageIdNumber - const char* pMessage - uint32_t queueLabelCount - VkDebugUtilsLabelEXT* pQueueLabels - uint32_t cmdBufLabelCount - VkDebugUtilsLabelEXT* pCmdBufLabels - uint32_t objectCount - VkDebugUtilsObjectNameInfoEXT* pObjects - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - void* pHostPointer - - - VkStructureType sType - void* pNext - uint32_t memoryTypeBits - - - VkStructureType sType - void* pNext - VkDeviceSize minImportedHostPointerAlignment - - - VkStructureType sType - void* pNextPointer to next structure - float primitiveOverestimationSizeThe size in pixels the primitive is enlarged at each edge during conservative rasterization - float maxExtraPrimitiveOverestimationSizeThe maximum additional overestimation the client can specify in the pipeline state - float extraPrimitiveOverestimationSizeGranularityThe granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize - VkBool32 primitiveUnderestimationtrue if the implementation supports conservative rasterization underestimation mode - VkBool32 conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines - VkBool32 degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized - VkBool32 degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized - VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable - VkBool32 conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask - - - VkStructureType sType - void* pNextPointer to next structure - uint32_t shaderEngineCountnumber of shader engines - uint32_t shaderArraysPerEngineCountnumber of shader arrays - uint32_t computeUnitsPerShaderArraynumber of CUs per shader array - uint32_t simdPerComputeUnitnumber of SIMDs per compute unit - uint32_t wavefrontsPerSimdnumber of wavefront slots in each SIMD - uint32_t wavefrontSizenumber of threads per wavefront - uint32_t sgprsPerSimdnumber of physical SGPRs per SIMD - uint32_t minSgprAllocationminimum number of SGPRs that can be allocated by a wave - uint32_t maxSgprAllocationnumber of available SGPRs - uint32_t sgprAllocationGranularitySGPRs are allocated in groups of this size - uint32_t vgprsPerSimdnumber of physical VGPRs per SIMD - uint32_t minVgprAllocationminimum number of VGPRs that can be allocated by a wave - uint32_t maxVgprAllocationnumber of available VGPRs - uint32_t vgprAllocationGranularityVGPRs are allocated in groups of this size - - - VkStructureType sType - const void* pNext - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags - VkConservativeRasterizationModeEXT conservativeRasterizationMode - float extraPrimitiveOverestimationSize - - - VkStructureType sType - void* pNext - VkBool32 shaderInputAttachmentArrayDynamicIndexing - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing - VkBool32 shaderUniformBufferArrayNonUniformIndexing - VkBool32 shaderSampledImageArrayNonUniformIndexing - VkBool32 shaderStorageBufferArrayNonUniformIndexing - VkBool32 shaderStorageImageArrayNonUniformIndexing - VkBool32 shaderInputAttachmentArrayNonUniformIndexing - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing - VkBool32 descriptorBindingUniformBufferUpdateAfterBind - VkBool32 descriptorBindingSampledImageUpdateAfterBind - VkBool32 descriptorBindingStorageImageUpdateAfterBind - VkBool32 descriptorBindingStorageBufferUpdateAfterBind - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind - VkBool32 descriptorBindingUpdateUnusedWhilePending - VkBool32 descriptorBindingPartiallyBound - VkBool32 descriptorBindingVariableDescriptorCount - VkBool32 runtimeDescriptorArray - - - VkStructureType sType - void* pNext - uint32_t maxUpdateAfterBindDescriptorsInAllPools - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative - VkBool32 shaderSampledImageArrayNonUniformIndexingNative - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative - VkBool32 shaderStorageImageArrayNonUniformIndexingNative - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative - VkBool32 robustBufferAccessUpdateAfterBind - VkBool32 quadDivergentImplicitLod - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments - uint32_t maxPerStageUpdateAfterBindResources - uint32_t maxDescriptorSetUpdateAfterBindSamplers - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic - uint32_t maxDescriptorSetUpdateAfterBindSampledImages - uint32_t maxDescriptorSetUpdateAfterBindStorageImages - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments - - - VkStructureType sType - const void* pNext - uint32_t bindingCount - const VkDescriptorBindingFlagsEXT* pBindingFlags - - - VkStructureType sType - const void* pNext - uint32_t descriptorSetCount - const uint32_t* pDescriptorCounts - - - VkStructureType sType - void* pNext - uint32_t maxVariableDescriptorCount - - - uint32_t binding - uint32_t divisor - - - VkStructureType sType - const void* pNext - uint32_t vertexBindingDivisorCount - const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors - - - VkStructureType sType - void* pNext - uint32_t maxVertexAttribDivisormax value of vertex attribute divisor - - - VkStructureType sType - const void* pNext - struct AHardwareBuffer* buffer - - - VkStructureType sType - void* pNext - uint64_t androidHardwareBufferUsage - - - VkStructureType sType - void* pNext - VkDeviceSize allocationSize - uint32_t memoryTypeBits - - - VkStructureType sType - const void* pNext - VkDeviceMemory memory - - - VkStructureType sType - void* pNext - VkFormat format - uint64_t externalFormat - VkFormatFeatureFlags formatFeatures - VkComponentMapping samplerYcbcrConversionComponents - VkSamplerYcbcrModelConversion suggestedYcbcrModel - VkSamplerYcbcrRange suggestedYcbcrRange - VkChromaLocation suggestedXChromaOffset - VkChromaLocation suggestedYChromaOffset - - - VkStructureType sType - void* pNext - uint64_t externalFormat - - - - Vulkan enumerant (token) definitions - - - - - - - - - - - - - - - - - - - - - - - - - - - - Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in - their own numeric namespaces. The "name" attribute is the C enum - type name, and is pulled in from a type tag definition above - (slightly clunky, but retains the type / enum distinction). "type" - attributes of "enum" or "bitmask" indicate that these values should - be generated inside an appropriate definition. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge - enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not - alias! - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Return codes (positive values) - - - - - - - Error codes (negative values) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Flags - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - WSI Extensions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - VkResult vkCreateInstance - const VkInstanceCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkInstance* pInstance - - - void vkDestroyInstance - VkInstance instance - const VkAllocationCallbacks* pAllocator - - - VkResult vkEnumeratePhysicalDevices - VkInstance instance - uint32_t* pPhysicalDeviceCount - VkPhysicalDevice* pPhysicalDevices - - - PFN_vkVoidFunction vkGetDeviceProcAddr - VkDevice device - const char* pName - - - PFN_vkVoidFunction vkGetInstanceProcAddr - VkInstance instance - const char* pName - - - void vkGetPhysicalDeviceProperties - VkPhysicalDevice physicalDevice - VkPhysicalDeviceProperties* pProperties - - - void vkGetPhysicalDeviceQueueFamilyProperties - VkPhysicalDevice physicalDevice - uint32_t* pQueueFamilyPropertyCount - VkQueueFamilyProperties* pQueueFamilyProperties - - - void vkGetPhysicalDeviceMemoryProperties - VkPhysicalDevice physicalDevice - VkPhysicalDeviceMemoryProperties* pMemoryProperties - - - void vkGetPhysicalDeviceFeatures - VkPhysicalDevice physicalDevice - VkPhysicalDeviceFeatures* pFeatures - - - void vkGetPhysicalDeviceFormatProperties - VkPhysicalDevice physicalDevice - VkFormat format - VkFormatProperties* pFormatProperties - - - VkResult vkGetPhysicalDeviceImageFormatProperties - VkPhysicalDevice physicalDevice - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags - VkImageFormatProperties* pImageFormatProperties - - - VkResult vkCreateDevice - VkPhysicalDevice physicalDevice - const VkDeviceCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDevice* pDevice - - - void vkDestroyDevice - VkDevice device - const VkAllocationCallbacks* pAllocator - - - VkResult vkEnumerateInstanceVersion - uint32_t* pApiVersion - - - VkResult vkEnumerateInstanceLayerProperties - uint32_t* pPropertyCount - VkLayerProperties* pProperties - - - VkResult vkEnumerateInstanceExtensionProperties - const char* pLayerName - uint32_t* pPropertyCount - VkExtensionProperties* pProperties - - - VkResult vkEnumerateDeviceLayerProperties - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkLayerProperties* pProperties - - - VkResult vkEnumerateDeviceExtensionProperties - VkPhysicalDevice physicalDevice - const char* pLayerName - uint32_t* pPropertyCount - VkExtensionProperties* pProperties - - - void vkGetDeviceQueue - VkDevice device - uint32_t queueFamilyIndex - uint32_t queueIndex - VkQueue* pQueue - - - VkResult vkQueueSubmit - VkQueue queue - uint32_t submitCount - const VkSubmitInfo* pSubmits - VkFence fence - - - VkResult vkQueueWaitIdle - VkQueue queue - - - VkResult vkDeviceWaitIdle - VkDevice device - - all sname:VkQueue objects created from pname:device - - - - VkResult vkAllocateMemory - VkDevice device - const VkMemoryAllocateInfo* pAllocateInfo - const VkAllocationCallbacks* pAllocator - VkDeviceMemory* pMemory - - - void vkFreeMemory - VkDevice device - VkDeviceMemory memory - const VkAllocationCallbacks* pAllocator - - - VkResult vkMapMemory - VkDevice device - VkDeviceMemory memory - VkDeviceSize offset - VkDeviceSize size - VkMemoryMapFlags flags - void** ppData - - - void vkUnmapMemory - VkDevice device - VkDeviceMemory memory - - - VkResult vkFlushMappedMemoryRanges - VkDevice device - uint32_t memoryRangeCount - const VkMappedMemoryRange* pMemoryRanges - - - VkResult vkInvalidateMappedMemoryRanges - VkDevice device - uint32_t memoryRangeCount - const VkMappedMemoryRange* pMemoryRanges - - - void vkGetDeviceMemoryCommitment - VkDevice device - VkDeviceMemory memory - VkDeviceSize* pCommittedMemoryInBytes - - - void vkGetBufferMemoryRequirements - VkDevice device - VkBuffer buffer - VkMemoryRequirements* pMemoryRequirements - - - VkResult vkBindBufferMemory - VkDevice device - VkBuffer buffer - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - void vkGetImageMemoryRequirements - VkDevice device - VkImage image - VkMemoryRequirements* pMemoryRequirements - - - VkResult vkBindImageMemory - VkDevice device - VkImage image - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - void vkGetImageSparseMemoryRequirements - VkDevice device - VkImage image - uint32_t* pSparseMemoryRequirementCount - VkSparseImageMemoryRequirements* pSparseMemoryRequirements - - - void vkGetPhysicalDeviceSparseImageFormatProperties - VkPhysicalDevice physicalDevice - VkFormat format - VkImageType type - VkSampleCountFlagBits samples - VkImageUsageFlags usage - VkImageTiling tiling - uint32_t* pPropertyCount - VkSparseImageFormatProperties* pProperties - - - VkResult vkQueueBindSparse - VkQueue queue - uint32_t bindInfoCount - const VkBindSparseInfo* pBindInfo - VkFence fence - - - VkResult vkCreateFence - VkDevice device - const VkFenceCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkFence* pFence - - - void vkDestroyFence - VkDevice device - VkFence fence - const VkAllocationCallbacks* pAllocator - - - VkResult vkResetFences - VkDevice device - uint32_t fenceCount - const VkFence* pFences - - - VkResult vkGetFenceStatus - VkDevice device - VkFence fence - - - VkResult vkWaitForFences - VkDevice device - uint32_t fenceCount - const VkFence* pFences - VkBool32 waitAll - uint64_t timeout - - - VkResult vkCreateSemaphore - VkDevice device - const VkSemaphoreCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSemaphore* pSemaphore - - - void vkDestroySemaphore - VkDevice device - VkSemaphore semaphore - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateEvent - VkDevice device - const VkEventCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkEvent* pEvent - - - void vkDestroyEvent - VkDevice device - VkEvent event - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetEventStatus - VkDevice device - VkEvent event - - - VkResult vkSetEvent - VkDevice device - VkEvent event - - - VkResult vkResetEvent - VkDevice device - VkEvent event - - - VkResult vkCreateQueryPool - VkDevice device - const VkQueryPoolCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkQueryPool* pQueryPool - - - void vkDestroyQueryPool - VkDevice device - VkQueryPool queryPool - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetQueryPoolResults - VkDevice device - VkQueryPool queryPool - uint32_t firstQuery - uint32_t queryCount - size_t dataSize - void* pData - VkDeviceSize stride - VkQueryResultFlags flags - - - VkResult vkCreateBuffer - VkDevice device - const VkBufferCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkBuffer* pBuffer - - - void vkDestroyBuffer - VkDevice device - VkBuffer buffer - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateBufferView - VkDevice device - const VkBufferViewCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkBufferView* pView - - - void vkDestroyBufferView - VkDevice device - VkBufferView bufferView - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateImage - VkDevice device - const VkImageCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkImage* pImage - - - void vkDestroyImage - VkDevice device - VkImage image - const VkAllocationCallbacks* pAllocator - - - void vkGetImageSubresourceLayout - VkDevice device - VkImage image - const VkImageSubresource* pSubresource - VkSubresourceLayout* pLayout - - - VkResult vkCreateImageView - VkDevice device - const VkImageViewCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkImageView* pView - - - void vkDestroyImageView - VkDevice device - VkImageView imageView - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateShaderModule - VkDevice device - const VkShaderModuleCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkShaderModule* pShaderModule - - - void vkDestroyShaderModule - VkDevice device - VkShaderModule shaderModule - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreatePipelineCache - VkDevice device - const VkPipelineCacheCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkPipelineCache* pPipelineCache - - - void vkDestroyPipelineCache - VkDevice device - VkPipelineCache pipelineCache - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetPipelineCacheData - VkDevice device - VkPipelineCache pipelineCache - size_t* pDataSize - void* pData - - - VkResult vkMergePipelineCaches - VkDevice device - VkPipelineCache dstCache - uint32_t srcCacheCount - const VkPipelineCache* pSrcCaches - - - VkResult vkCreateGraphicsPipelines - VkDevice device - VkPipelineCache pipelineCache - uint32_t createInfoCount - const VkGraphicsPipelineCreateInfo* pCreateInfos - const VkAllocationCallbacks* pAllocator - VkPipeline* pPipelines - - - VkResult vkCreateComputePipelines - VkDevice device - VkPipelineCache pipelineCache - uint32_t createInfoCount - const VkComputePipelineCreateInfo* pCreateInfos - const VkAllocationCallbacks* pAllocator - VkPipeline* pPipelines - - - void vkDestroyPipeline - VkDevice device - VkPipeline pipeline - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreatePipelineLayout - VkDevice device - const VkPipelineLayoutCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkPipelineLayout* pPipelineLayout - - - void vkDestroyPipelineLayout - VkDevice device - VkPipelineLayout pipelineLayout - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateSampler - VkDevice device - const VkSamplerCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSampler* pSampler - - - void vkDestroySampler - VkDevice device - VkSampler sampler - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateDescriptorSetLayout - VkDevice device - const VkDescriptorSetLayoutCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDescriptorSetLayout* pSetLayout - - - void vkDestroyDescriptorSetLayout - VkDevice device - VkDescriptorSetLayout descriptorSetLayout - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateDescriptorPool - VkDevice device - const VkDescriptorPoolCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDescriptorPool* pDescriptorPool - - - void vkDestroyDescriptorPool - VkDevice device - VkDescriptorPool descriptorPool - const VkAllocationCallbacks* pAllocator - - - VkResult vkResetDescriptorPool - VkDevice device - VkDescriptorPool descriptorPool - VkDescriptorPoolResetFlags flags - - any sname:VkDescriptorSet objects allocated from pname:descriptorPool - - - - VkResult vkAllocateDescriptorSets - VkDevice device - const VkDescriptorSetAllocateInfo* pAllocateInfo - VkDescriptorSet* pDescriptorSets - - - VkResult vkFreeDescriptorSets - VkDevice device - VkDescriptorPool descriptorPool - uint32_t descriptorSetCount - const VkDescriptorSet* pDescriptorSets - - - void vkUpdateDescriptorSets - VkDevice device - uint32_t descriptorWriteCount - const VkWriteDescriptorSet* pDescriptorWrites - uint32_t descriptorCopyCount - const VkCopyDescriptorSet* pDescriptorCopies - - - VkResult vkCreateFramebuffer - VkDevice device - const VkFramebufferCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkFramebuffer* pFramebuffer - - - void vkDestroyFramebuffer - VkDevice device - VkFramebuffer framebuffer - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateRenderPass - VkDevice device - const VkRenderPassCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkRenderPass* pRenderPass - - - void vkDestroyRenderPass - VkDevice device - VkRenderPass renderPass - const VkAllocationCallbacks* pAllocator - - - void vkGetRenderAreaGranularity - VkDevice device - VkRenderPass renderPass - VkExtent2D* pGranularity - - - VkResult vkCreateCommandPool - VkDevice device - const VkCommandPoolCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkCommandPool* pCommandPool - - - void vkDestroyCommandPool - VkDevice device - VkCommandPool commandPool - const VkAllocationCallbacks* pAllocator - - - VkResult vkResetCommandPool - VkDevice device - VkCommandPool commandPool - VkCommandPoolResetFlags flags - - - VkResult vkAllocateCommandBuffers - VkDevice device - const VkCommandBufferAllocateInfo* pAllocateInfo - VkCommandBuffer* pCommandBuffers - - - void vkFreeCommandBuffers - VkDevice device - VkCommandPool commandPool - uint32_t commandBufferCount - const VkCommandBuffer* pCommandBuffers - - - VkResult vkBeginCommandBuffer - VkCommandBuffer commandBuffer - const VkCommandBufferBeginInfo* pBeginInfo - - the sname:VkCommandPool that pname:commandBuffer was allocated from - - - - VkResult vkEndCommandBuffer - VkCommandBuffer commandBuffer - - the sname:VkCommandPool that pname:commandBuffer was allocated from - - - - VkResult vkResetCommandBuffer - VkCommandBuffer commandBuffer - VkCommandBufferResetFlags flags - - - void vkCmdBindPipeline - VkCommandBuffer commandBuffer - VkPipelineBindPoint pipelineBindPoint - VkPipeline pipeline - - - void vkCmdSetViewport - VkCommandBuffer commandBuffer - uint32_t firstViewport - uint32_t viewportCount - const VkViewport* pViewports - - - void vkCmdSetScissor - VkCommandBuffer commandBuffer - uint32_t firstScissor - uint32_t scissorCount - const VkRect2D* pScissors - - - void vkCmdSetLineWidth - VkCommandBuffer commandBuffer - float lineWidth - - - void vkCmdSetDepthBias - VkCommandBuffer commandBuffer - float depthBiasConstantFactor - float depthBiasClamp - float depthBiasSlopeFactor - - - void vkCmdSetBlendConstants - VkCommandBuffer commandBuffer - const float blendConstants[4] - - - void vkCmdSetDepthBounds - VkCommandBuffer commandBuffer - float minDepthBounds - float maxDepthBounds - - - void vkCmdSetStencilCompareMask - VkCommandBuffer commandBuffer - VkStencilFaceFlags faceMask - uint32_t compareMask - - - void vkCmdSetStencilWriteMask - VkCommandBuffer commandBuffer - VkStencilFaceFlags faceMask - uint32_t writeMask - - - void vkCmdSetStencilReference - VkCommandBuffer commandBuffer - VkStencilFaceFlags faceMask - uint32_t reference - - - void vkCmdBindDescriptorSets - VkCommandBuffer commandBuffer - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayout layout - uint32_t firstSet - uint32_t descriptorSetCount - const VkDescriptorSet* pDescriptorSets - uint32_t dynamicOffsetCount - const uint32_t* pDynamicOffsets - - - void vkCmdBindIndexBuffer - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkIndexType indexType - - - void vkCmdBindVertexBuffers - VkCommandBuffer commandBuffer - uint32_t firstBinding - uint32_t bindingCount - const VkBuffer* pBuffers - const VkDeviceSize* pOffsets - - - void vkCmdDraw - VkCommandBuffer commandBuffer - uint32_t vertexCount - uint32_t instanceCount - uint32_t firstVertex - uint32_t firstInstance - - - void vkCmdDrawIndexed - VkCommandBuffer commandBuffer - uint32_t indexCount - uint32_t instanceCount - uint32_t firstIndex - int32_t vertexOffset - uint32_t firstInstance - - - void vkCmdDrawIndirect - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - uint32_t drawCount - uint32_t stride - - - void vkCmdDrawIndexedIndirect - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - uint32_t drawCount - uint32_t stride - - - void vkCmdDispatch - VkCommandBuffer commandBuffer - uint32_t groupCountX - uint32_t groupCountY - uint32_t groupCountZ - - - void vkCmdDispatchIndirect - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - - - void vkCmdCopyBuffer - VkCommandBuffer commandBuffer - VkBuffer srcBuffer - VkBuffer dstBuffer - uint32_t regionCount - const VkBufferCopy* pRegions - - - void vkCmdCopyImage - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkImageCopy* pRegions - - - void vkCmdBlitImage - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkImageBlit* pRegions - VkFilter filter - - - void vkCmdCopyBufferToImage - VkCommandBuffer commandBuffer - VkBuffer srcBuffer - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkBufferImageCopy* pRegions - - - void vkCmdCopyImageToBuffer - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkBuffer dstBuffer - uint32_t regionCount - const VkBufferImageCopy* pRegions - - - void vkCmdUpdateBuffer - VkCommandBuffer commandBuffer - VkBuffer dstBuffer - VkDeviceSize dstOffset - VkDeviceSize dataSize - const void* pData - - - void vkCmdFillBuffer - VkCommandBuffer commandBuffer - VkBuffer dstBuffer - VkDeviceSize dstOffset - VkDeviceSize size - uint32_t data - - - void vkCmdClearColorImage - VkCommandBuffer commandBuffer - VkImage image - VkImageLayout imageLayout - const VkClearColorValue* pColor - uint32_t rangeCount - const VkImageSubresourceRange* pRanges - - - void vkCmdClearDepthStencilImage - VkCommandBuffer commandBuffer - VkImage image - VkImageLayout imageLayout - const VkClearDepthStencilValue* pDepthStencil - uint32_t rangeCount - const VkImageSubresourceRange* pRanges - - - void vkCmdClearAttachments - VkCommandBuffer commandBuffer - uint32_t attachmentCount - const VkClearAttachment* pAttachments - uint32_t rectCount - const VkClearRect* pRects - - - void vkCmdResolveImage - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkImageResolve* pRegions - - - void vkCmdSetEvent - VkCommandBuffer commandBuffer - VkEvent event - VkPipelineStageFlags stageMask - - - void vkCmdResetEvent - VkCommandBuffer commandBuffer - VkEvent event - VkPipelineStageFlags stageMask - - - void vkCmdWaitEvents - VkCommandBuffer commandBuffer - uint32_t eventCount - const VkEvent* pEvents - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - uint32_t memoryBarrierCount - const VkMemoryBarrier* pMemoryBarriers - uint32_t bufferMemoryBarrierCount - const VkBufferMemoryBarrier* pBufferMemoryBarriers - uint32_t imageMemoryBarrierCount - const VkImageMemoryBarrier* pImageMemoryBarriers - - - void vkCmdPipelineBarrier - VkCommandBuffer commandBuffer - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - VkDependencyFlags dependencyFlags - uint32_t memoryBarrierCount - const VkMemoryBarrier* pMemoryBarriers - uint32_t bufferMemoryBarrierCount - const VkBufferMemoryBarrier* pBufferMemoryBarriers - uint32_t imageMemoryBarrierCount - const VkImageMemoryBarrier* pImageMemoryBarriers - - - void vkCmdBeginQuery - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t query - VkQueryControlFlags flags - - - void vkCmdEndQuery - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t query - - - void vkCmdResetQueryPool - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t firstQuery - uint32_t queryCount - - - void vkCmdWriteTimestamp - VkCommandBuffer commandBuffer - VkPipelineStageFlagBits pipelineStage - VkQueryPool queryPool - uint32_t query - - - void vkCmdCopyQueryPoolResults - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t firstQuery - uint32_t queryCount - VkBuffer dstBuffer - VkDeviceSize dstOffset - VkDeviceSize stride - VkQueryResultFlags flags - - - void vkCmdPushConstants - VkCommandBuffer commandBuffer - VkPipelineLayout layout - VkShaderStageFlags stageFlags - uint32_t offset - uint32_t size - const void* pValues - - - void vkCmdBeginRenderPass - VkCommandBuffer commandBuffer - const VkRenderPassBeginInfo* pRenderPassBegin - VkSubpassContents contents - - - void vkCmdNextSubpass - VkCommandBuffer commandBuffer - VkSubpassContents contents - - - void vkCmdEndRenderPass - VkCommandBuffer commandBuffer - - - void vkCmdExecuteCommands - VkCommandBuffer commandBuffer - uint32_t commandBufferCount - const VkCommandBuffer* pCommandBuffers - - - VkResult vkCreateAndroidSurfaceKHR - VkInstance instance - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkGetPhysicalDeviceDisplayPropertiesKHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayPropertiesKHR* pProperties - - - VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayPlanePropertiesKHR* pProperties - - - VkResult vkGetDisplayPlaneSupportedDisplaysKHR - VkPhysicalDevice physicalDevice - uint32_t planeIndex - uint32_t* pDisplayCount - VkDisplayKHR* pDisplays - - - VkResult vkGetDisplayModePropertiesKHR - VkPhysicalDevice physicalDevice - VkDisplayKHR display - uint32_t* pPropertyCount - VkDisplayModePropertiesKHR* pProperties - - - VkResult vkCreateDisplayModeKHR - VkPhysicalDevice physicalDevice - VkDisplayKHR display - const VkDisplayModeCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDisplayModeKHR* pMode - - - VkResult vkGetDisplayPlaneCapabilitiesKHR - VkPhysicalDevice physicalDevice - VkDisplayModeKHR mode - uint32_t planeIndex - VkDisplayPlaneCapabilitiesKHR* pCapabilities - - - VkResult vkCreateDisplayPlaneSurfaceKHR - VkInstance instance - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkCreateSharedSwapchainsKHR - VkDevice device - uint32_t swapchainCount - const VkSwapchainCreateInfoKHR* pCreateInfos - const VkAllocationCallbacks* pAllocator - VkSwapchainKHR* pSwapchains - - - VkResult vkCreateMirSurfaceKHR - VkInstance instance - const VkMirSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - MirConnection* connection - - - void vkDestroySurfaceKHR - VkInstance instance - VkSurfaceKHR surface - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetPhysicalDeviceSurfaceSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - VkSurfaceKHR surface - VkBool32* pSupported - - - VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities - - - VkResult vkGetPhysicalDeviceSurfaceFormatsKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - uint32_t* pSurfaceFormatCount - VkSurfaceFormatKHR* pSurfaceFormats - - - VkResult vkGetPhysicalDeviceSurfacePresentModesKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - uint32_t* pPresentModeCount - VkPresentModeKHR* pPresentModes - - - VkResult vkCreateSwapchainKHR - VkDevice device - const VkSwapchainCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSwapchainKHR* pSwapchain - - - void vkDestroySwapchainKHR - VkDevice device - VkSwapchainKHR swapchain - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetSwapchainImagesKHR - VkDevice device - VkSwapchainKHR swapchain - uint32_t* pSwapchainImageCount - VkImage* pSwapchainImages - - - VkResult vkAcquireNextImageKHR - VkDevice device - VkSwapchainKHR swapchain - uint64_t timeout - VkSemaphore semaphore - VkFence fence - uint32_t* pImageIndex - - - VkResult vkQueuePresentKHR - VkQueue queue - const VkPresentInfoKHR* pPresentInfo - - - VkResult vkCreateViSurfaceNN - VkInstance instance - const VkViSurfaceCreateInfoNN* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkCreateWaylandSurfaceKHR - VkInstance instance - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - struct wl_display* display - - - VkResult vkCreateWin32SurfaceKHR - VkInstance instance - const VkWin32SurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - - - VkResult vkCreateXlibSurfaceKHR - VkInstance instance - const VkXlibSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - Display* dpy - VisualID visualID - - - VkResult vkCreateXcbSurfaceKHR - VkInstance instance - const VkXcbSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - xcb_connection_t* connection - xcb_visualid_t visual_id - - - VkResult vkCreateDebugReportCallbackEXT - VkInstance instance - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDebugReportCallbackEXT* pCallback - - - void vkDestroyDebugReportCallbackEXT - VkInstance instance - VkDebugReportCallbackEXT callback - const VkAllocationCallbacks* pAllocator - - - void vkDebugReportMessageEXT - VkInstance instance - VkDebugReportFlagsEXT flags - VkDebugReportObjectTypeEXT objectType - uint64_t object - size_t location - int32_t messageCode - const char* pLayerPrefix - const char* pMessage - - - VkResult vkDebugMarkerSetObjectNameEXT - VkDevice device - const VkDebugMarkerObjectNameInfoEXT* pNameInfo - - - VkResult vkDebugMarkerSetObjectTagEXT - VkDevice device - const VkDebugMarkerObjectTagInfoEXT* pTagInfo - - - void vkCmdDebugMarkerBeginEXT - VkCommandBuffer commandBuffer - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo - - - void vkCmdDebugMarkerEndEXT - VkCommandBuffer commandBuffer - - - void vkCmdDebugMarkerInsertEXT - VkCommandBuffer commandBuffer - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo - - - VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV - VkPhysicalDevice physicalDevice - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags - VkExternalMemoryHandleTypeFlagsNV externalHandleType - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties - - - VkResult vkGetMemoryWin32HandleNV - VkDevice device - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagsNV handleType - HANDLE* pHandle - - - void vkCmdDrawIndirectCountAMD - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - void vkCmdDrawIndexedIndirectCountAMD - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - void vkCmdProcessCommandsNVX - VkCommandBuffer commandBuffer - const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo - - - void vkCmdReserveSpaceForCommandsNVX - VkCommandBuffer commandBuffer - const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo - - - VkResult vkCreateIndirectCommandsLayoutNVX - VkDevice device - const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout - - - void vkDestroyIndirectCommandsLayoutNVX - VkDevice device - VkIndirectCommandsLayoutNVX indirectCommandsLayout - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateObjectTableNVX - VkDevice device - const VkObjectTableCreateInfoNVX* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkObjectTableNVX* pObjectTable - - - void vkDestroyObjectTableNVX - VkDevice device - VkObjectTableNVX objectTable - const VkAllocationCallbacks* pAllocator - - - VkResult vkRegisterObjectsNVX - VkDevice device - VkObjectTableNVX objectTable - uint32_t objectCount - const VkObjectTableEntryNVX* const* ppObjectTableEntries - const uint32_t* pObjectIndices - - - VkResult vkUnregisterObjectsNVX - VkDevice device - VkObjectTableNVX objectTable - uint32_t objectCount - const VkObjectEntryTypeNVX* pObjectEntryTypes - const uint32_t* pObjectIndices - - - void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX - VkPhysicalDevice physicalDevice - VkDeviceGeneratedCommandsFeaturesNVX* pFeatures - VkDeviceGeneratedCommandsLimitsNVX* pLimits - - - void vkGetPhysicalDeviceFeatures2 - VkPhysicalDevice physicalDevice - VkPhysicalDeviceFeatures2* pFeatures - - - - void vkGetPhysicalDeviceProperties2 - VkPhysicalDevice physicalDevice - VkPhysicalDeviceProperties2* pProperties - - - - void vkGetPhysicalDeviceFormatProperties2 - VkPhysicalDevice physicalDevice - VkFormat format - VkFormatProperties2* pFormatProperties - - - - VkResult vkGetPhysicalDeviceImageFormatProperties2 - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo - VkImageFormatProperties2* pImageFormatProperties - - - - void vkGetPhysicalDeviceQueueFamilyProperties2 - VkPhysicalDevice physicalDevice - uint32_t* pQueueFamilyPropertyCount - VkQueueFamilyProperties2* pQueueFamilyProperties - - - - void vkGetPhysicalDeviceMemoryProperties2 - VkPhysicalDevice physicalDevice - VkPhysicalDeviceMemoryProperties2* pMemoryProperties - - - - void vkGetPhysicalDeviceSparseImageFormatProperties2 - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo - uint32_t* pPropertyCount - VkSparseImageFormatProperties2* pProperties - - - - void vkCmdPushDescriptorSetKHR - VkCommandBuffer commandBuffer - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayout layout - uint32_t set - uint32_t descriptorWriteCount - const VkWriteDescriptorSet* pDescriptorWrites - - - void vkTrimCommandPool - VkDevice device - VkCommandPool commandPool - VkCommandPoolTrimFlags flags - - - - void vkGetPhysicalDeviceExternalBufferProperties - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo - VkExternalBufferProperties* pExternalBufferProperties - - - - VkResult vkGetMemoryWin32HandleKHR - VkDevice device - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo - HANDLE* pHandle - - - VkResult vkGetMemoryWin32HandlePropertiesKHR - VkDevice device - VkExternalMemoryHandleTypeFlagBits handleType - HANDLE handle - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties - - - VkResult vkGetMemoryFdKHR - VkDevice device - const VkMemoryGetFdInfoKHR* pGetFdInfo - int* pFd - - - VkResult vkGetMemoryFdPropertiesKHR - VkDevice device - VkExternalMemoryHandleTypeFlagBits handleType - int fd - VkMemoryFdPropertiesKHR* pMemoryFdProperties - - - void vkGetPhysicalDeviceExternalSemaphoreProperties - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo - VkExternalSemaphoreProperties* pExternalSemaphoreProperties - - - - VkResult vkGetSemaphoreWin32HandleKHR - VkDevice device - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo - HANDLE* pHandle - - - VkResult vkImportSemaphoreWin32HandleKHR - VkDevice device - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo - - - VkResult vkGetSemaphoreFdKHR - VkDevice device - const VkSemaphoreGetFdInfoKHR* pGetFdInfo - int* pFd - - - VkResult vkImportSemaphoreFdKHR - VkDevice device - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo - - - void vkGetPhysicalDeviceExternalFenceProperties - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo - VkExternalFenceProperties* pExternalFenceProperties - - - - VkResult vkGetFenceWin32HandleKHR - VkDevice device - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo - HANDLE* pHandle - - - VkResult vkImportFenceWin32HandleKHR - VkDevice device - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo - - - VkResult vkGetFenceFdKHR - VkDevice device - const VkFenceGetFdInfoKHR* pGetFdInfo - int* pFd - - - VkResult vkImportFenceFdKHR - VkDevice device - const VkImportFenceFdInfoKHR* pImportFenceFdInfo - - - VkResult vkReleaseDisplayEXT - VkPhysicalDevice physicalDevice - VkDisplayKHR display - - - VkResult vkAcquireXlibDisplayEXT - VkPhysicalDevice physicalDevice - Display* dpy - VkDisplayKHR display - - - VkResult vkGetRandROutputDisplayEXT - VkPhysicalDevice physicalDevice - Display* dpy - RROutput rrOutput - VkDisplayKHR* pDisplay - - - VkResult vkDisplayPowerControlEXT - VkDevice device - VkDisplayKHR display - const VkDisplayPowerInfoEXT* pDisplayPowerInfo - - - VkResult vkRegisterDeviceEventEXT - VkDevice device - const VkDeviceEventInfoEXT* pDeviceEventInfo - const VkAllocationCallbacks* pAllocator - VkFence* pFence - - - VkResult vkRegisterDisplayEventEXT - VkDevice device - VkDisplayKHR display - const VkDisplayEventInfoEXT* pDisplayEventInfo - const VkAllocationCallbacks* pAllocator - VkFence* pFence - - - VkResult vkGetSwapchainCounterEXT - VkDevice device - VkSwapchainKHR swapchain - VkSurfaceCounterFlagBitsEXT counter - uint64_t* pCounterValue - - - VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - VkSurfaceCapabilities2EXT* pSurfaceCapabilities - - - VkResult vkEnumeratePhysicalDeviceGroups - VkInstance instance - uint32_t* pPhysicalDeviceGroupCount - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties - - - - void vkGetDeviceGroupPeerMemoryFeatures - VkDevice device - uint32_t heapIndex - uint32_t localDeviceIndex - uint32_t remoteDeviceIndex - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures - - - - VkResult vkBindBufferMemory2 - VkDevice device - uint32_t bindInfoCount - const VkBindBufferMemoryInfo* pBindInfos - - - - VkResult vkBindImageMemory2 - VkDevice device - uint32_t bindInfoCount - const VkBindImageMemoryInfo* pBindInfos - - - - void vkCmdSetDeviceMask - VkCommandBuffer commandBuffer - uint32_t deviceMask - - - - VkResult vkGetDeviceGroupPresentCapabilitiesKHR - VkDevice device - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities - - - VkResult vkGetDeviceGroupSurfacePresentModesKHR - VkDevice device - VkSurfaceKHR surface - VkDeviceGroupPresentModeFlagsKHR* pModes - - - VkResult vkAcquireNextImage2KHR - VkDevice device - const VkAcquireNextImageInfoKHR* pAcquireInfo - uint32_t* pImageIndex - - - void vkCmdDispatchBase - VkCommandBuffer commandBuffer - uint32_t baseGroupX - uint32_t baseGroupY - uint32_t baseGroupZ - uint32_t groupCountX - uint32_t groupCountY - uint32_t groupCountZ - - - - VkResult vkGetPhysicalDevicePresentRectanglesKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - uint32_t* pRectCount - VkRect2D* pRects - - - VkResult vkCreateDescriptorUpdateTemplate - VkDevice device - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate - - - - void vkDestroyDescriptorUpdateTemplate - VkDevice device - VkDescriptorUpdateTemplate descriptorUpdateTemplate - const VkAllocationCallbacks* pAllocator - - - - void vkUpdateDescriptorSetWithTemplate - VkDevice device - VkDescriptorSet descriptorSet - VkDescriptorUpdateTemplate descriptorUpdateTemplate - const void* pData - - - - void vkCmdPushDescriptorSetWithTemplateKHR - VkCommandBuffer commandBuffer - VkDescriptorUpdateTemplate descriptorUpdateTemplate - VkPipelineLayout layout - uint32_t set - const void* pData - - - void vkSetHdrMetadataEXT - VkDevice device - uint32_t swapchainCount - const VkSwapchainKHR* pSwapchains - const VkHdrMetadataEXT* pMetadata - - - VkResult vkGetSwapchainStatusKHR - VkDevice device - VkSwapchainKHR swapchain - - - VkResult vkGetRefreshCycleDurationGOOGLE - VkDevice device - VkSwapchainKHR swapchain - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties - - - VkResult vkGetPastPresentationTimingGOOGLE - VkDevice device - VkSwapchainKHR swapchain - uint32_t* pPresentationTimingCount - VkPastPresentationTimingGOOGLE* pPresentationTimings - - - VkResult vkCreateIOSSurfaceMVK - VkInstance instance - const VkIOSSurfaceCreateInfoMVK* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkCreateMacOSSurfaceMVK - VkInstance instance - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - void vkCmdSetViewportWScalingNV - VkCommandBuffer commandBuffer - uint32_t firstViewport - uint32_t viewportCount - const VkViewportWScalingNV* pViewportWScalings - - - void vkCmdSetDiscardRectangleEXT - VkCommandBuffer commandBuffer - uint32_t firstDiscardRectangle - uint32_t discardRectangleCount - const VkRect2D* pDiscardRectangles - - - void vkCmdSetSampleLocationsEXT - VkCommandBuffer commandBuffer - const VkSampleLocationsInfoEXT* pSampleLocationsInfo - - - void vkGetPhysicalDeviceMultisamplePropertiesEXT - VkPhysicalDevice physicalDevice - VkSampleCountFlagBits samples - VkMultisamplePropertiesEXT* pMultisampleProperties - - - VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo - VkSurfaceCapabilities2KHR* pSurfaceCapabilities - - - VkResult vkGetPhysicalDeviceSurfaceFormats2KHR - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo - uint32_t* pSurfaceFormatCount - VkSurfaceFormat2KHR* pSurfaceFormats - - - VkResult vkGetPhysicalDeviceDisplayProperties2KHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayProperties2KHR* pProperties - - - VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayPlaneProperties2KHR* pProperties - - - VkResult vkGetDisplayModeProperties2KHR - VkPhysicalDevice physicalDevice - VkDisplayKHR display - uint32_t* pPropertyCount - VkDisplayModeProperties2KHR* pProperties - - - VkResult vkGetDisplayPlaneCapabilities2KHR - VkPhysicalDevice physicalDevice - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo - VkDisplayPlaneCapabilities2KHR* pCapabilities - - - void vkGetBufferMemoryRequirements2 - VkDevice device - const VkBufferMemoryRequirementsInfo2* pInfo - VkMemoryRequirements2* pMemoryRequirements - - - - void vkGetImageMemoryRequirements2 - VkDevice device - const VkImageMemoryRequirementsInfo2* pInfo - VkMemoryRequirements2* pMemoryRequirements - - - - void vkGetImageSparseMemoryRequirements2 - VkDevice device - const VkImageSparseMemoryRequirementsInfo2* pInfo - uint32_t* pSparseMemoryRequirementCount - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements - - - - VkResult vkCreateSamplerYcbcrConversion - VkDevice device - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSamplerYcbcrConversion* pYcbcrConversion - - - - void vkDestroySamplerYcbcrConversion - VkDevice device - VkSamplerYcbcrConversion ycbcrConversion - const VkAllocationCallbacks* pAllocator - - - - void vkGetDeviceQueue2 - VkDevice device - const VkDeviceQueueInfo2* pQueueInfo - VkQueue* pQueue - - - VkResult vkCreateValidationCacheEXT - VkDevice device - const VkValidationCacheCreateInfoEXT* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkValidationCacheEXT* pValidationCache - - - void vkDestroyValidationCacheEXT - VkDevice device - VkValidationCacheEXT validationCache - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetValidationCacheDataEXT - VkDevice device - VkValidationCacheEXT validationCache - size_t* pDataSize - void* pData - - - VkResult vkMergeValidationCachesEXT - VkDevice device - VkValidationCacheEXT dstCache - uint32_t srcCacheCount - const VkValidationCacheEXT* pSrcCaches - - - void vkGetDescriptorSetLayoutSupport - VkDevice device - const VkDescriptorSetLayoutCreateInfo* pCreateInfo - VkDescriptorSetLayoutSupport* pSupport - - - - VkResult vkGetSwapchainGrallocUsageANDROID - VkDevice device - VkFormat format - VkImageUsageFlags imageUsage - int* grallocUsage - - - VkResult vkAcquireImageANDROID - VkDevice device - VkImage image - int nativeFenceFd - VkSemaphore semaphore - VkFence fence - - - VkResult vkQueueSignalReleaseImageANDROID - VkQueue queue - uint32_t waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - VkImage image - int* pNativeFenceFd - - - VkResult vkGetShaderInfoAMD - VkDevice device - VkPipeline pipeline - VkShaderStageFlagBits shaderStage - VkShaderInfoTypeAMD infoType - size_t* pInfoSize - void* pInfo - - - VkResult vkSetDebugUtilsObjectNameEXT - VkDevice device - const VkDebugUtilsObjectNameInfoEXT* pNameInfo - - - VkResult vkSetDebugUtilsObjectTagEXT - VkDevice device - const VkDebugUtilsObjectTagInfoEXT* pTagInfo - - - void vkQueueBeginDebugUtilsLabelEXT - VkQueue queue - const VkDebugUtilsLabelEXT* pLabelInfo - - - void vkQueueEndDebugUtilsLabelEXT - VkQueue queue - - - void vkQueueInsertDebugUtilsLabelEXT - VkQueue queue - const VkDebugUtilsLabelEXT* pLabelInfo - - - void vkCmdBeginDebugUtilsLabelEXT - VkCommandBuffer commandBuffer - const VkDebugUtilsLabelEXT* pLabelInfo - - - void vkCmdEndDebugUtilsLabelEXT - VkCommandBuffer commandBuffer - - - void vkCmdInsertDebugUtilsLabelEXT - VkCommandBuffer commandBuffer - const VkDebugUtilsLabelEXT* pLabelInfo - - - VkResult vkCreateDebugUtilsMessengerEXT - VkInstance instance - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDebugUtilsMessengerEXT* pMessenger - - - void vkDestroyDebugUtilsMessengerEXT - VkInstance instance - VkDebugUtilsMessengerEXT messenger - const VkAllocationCallbacks* pAllocator - - - void vkSubmitDebugUtilsMessageEXT - VkInstance instance - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity - VkDebugUtilsMessageTypeFlagsEXT messageTypes - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData - - - VkResult vkGetMemoryHostPointerPropertiesEXT - VkDevice device - VkExternalMemoryHandleTypeFlagBits handleType - const void* pHostPointer - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties - - - void vkCmdWriteBufferMarkerAMD - VkCommandBuffer commandBuffer - VkPipelineStageFlagBits pipelineStage - VkBuffer dstBuffer - VkDeviceSize dstOffset - uint32_t marker - - - VkResult vkGetAndroidHardwareBufferPropertiesANDROID - VkDevice device - const struct AHardwareBuffer* buffer - VkAndroidHardwareBufferPropertiesANDROID* pProperties - - - VkResult vkGetMemoryAndroidHardwareBufferANDROID - VkDevice device - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo - struct AHardwareBuffer** pBuffer - - - void vkCmdDrawIndirectCountKHR - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - void vkCmdDrawIndexedIndirectCountKHR - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum - offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Additional dependent types / tokens extending enumerants, not explicitly mentioned - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Additional dependent types / tokens extending enumerants, not explicitly mentioned - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - This duplicates definitions in VK_KHR_device_group below - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - This duplicates definitions in other extensions, below - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - enum offset=0 was mistakenly used for the 1.1 core enum - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES - (value=1000094000). Fortunately, no conflict resulted. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From 3cacb4a00ab9ffb3e9764a9fd26c20600ce0f96a Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 29 Jul 2018 22:39:45 +0200 Subject: [PATCH 025/122] Add support for extension constants --- ash/src/vk.rs | 12424 ++++++++++++++++++------------- generator/src/bin/generator.rs | 9 +- generator/src/lib.rs | 357 +- 3 files changed, 7575 insertions(+), 5215 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 2787c53..5c63bf4 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,3 +1,8 @@ +#[doc(hidden)] +pub use self::bitflags::*; +#[doc(hidden)] +pub use self::extensions::*; +#[doc(hidden)] pub use libc::*; #[macro_export] macro_rules! vk_make_version { @@ -53,7 +58,7 @@ macro_rules! vk_bitflags_wrapped { ($name:ident, $all:expr, $flag_type:ty) => { impl Default for $name { fn default() -> $name { - $name { flags: 0 } + $name(0) } } impl ::std::fmt::Debug for $name { @@ -61,35 +66,33 @@ macro_rules! vk_bitflags_wrapped { &self, f: &mut ::std::fmt::Formatter, ) -> ::std::result::Result<(), ::std::fmt::Error> { - write!(f, "{}({:b})", stringify!($name), self.flags) + write!(f, "{}({:b})", stringify!($name), self.0) } } impl $name { #[inline] pub fn empty() -> $name { - $name { flags: 0 } + $name(0) } #[inline] pub fn all() -> $name { - $name { flags: $all } + $name($all) } #[inline] pub fn flags(self) -> $flag_type { - self.flags + self.0 } #[inline] pub fn from_flags(flags: $flag_type) -> Option<$name> { if flags & !$all == 0 { - Some($name { flags: flags }) + Some($name(flags)) } else { None } } #[inline] pub fn from_flags_truncate(flags: $flag_type) -> $name { - $name { - flags: flags & $all, - } + $name(flags & $all) } #[inline] pub fn is_empty(self) -> bool { @@ -113,9 +116,7 @@ macro_rules! vk_bitflags_wrapped { type Output = $name; #[inline] fn bitor(self, rhs: $name) -> $name { - $name { - flags: self.flags | rhs.flags, - } + $name(self.0 | rhs.0) } } impl ::std::ops::BitOrAssign for $name { @@ -128,9 +129,7 @@ macro_rules! vk_bitflags_wrapped { type Output = $name; #[inline] fn bitand(self, rhs: $name) -> $name { - $name { - flags: self.flags & rhs.flags, - } + $name(self.0 & rhs.0) } } impl ::std::ops::BitAndAssign for $name { @@ -143,9 +142,7 @@ macro_rules! vk_bitflags_wrapped { type Output = $name; #[inline] fn bitxor(self, rhs: $name) -> $name { - $name { - flags: self.flags ^ rhs.flags, - } + $name(self.0 ^ rhs.0) } } impl ::std::ops::BitXorAssign for $name { @@ -4570,279 +4567,187 @@ pub type Flags = uint32_t; pub type DeviceSize = uint64_t; #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct FramebufferCreateFlags { - flags: Flags, -} +pub struct FramebufferCreateFlags(Flags); vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct QueryPoolCreateFlags { - flags: Flags, -} +pub struct QueryPoolCreateFlags(Flags); vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct RenderPassCreateFlags { - flags: Flags, -} +pub struct RenderPassCreateFlags(Flags); vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SamplerCreateFlags { - flags: Flags, -} +pub struct SamplerCreateFlags(Flags); vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineLayoutCreateFlags { - flags: Flags, -} +pub struct PipelineLayoutCreateFlags(Flags); vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineCacheCreateFlags { - flags: Flags, -} +pub struct PipelineCacheCreateFlags(Flags); vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineDepthStencilStateCreateFlags { - flags: Flags, -} +pub struct PipelineDepthStencilStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineDynamicStateCreateFlags { - flags: Flags, -} +pub struct PipelineDynamicStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineColorBlendStateCreateFlags { - flags: Flags, -} +pub struct PipelineColorBlendStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineMultisampleStateCreateFlags { - flags: Flags, -} +pub struct PipelineMultisampleStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineRasterizationStateCreateFlags { - flags: Flags, -} +pub struct PipelineRasterizationStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineViewportStateCreateFlags { - flags: Flags, -} +pub struct PipelineViewportStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineTessellationStateCreateFlags { - flags: Flags, -} +pub struct PipelineTessellationStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineInputAssemblyStateCreateFlags { - flags: Flags, -} +pub struct PipelineInputAssemblyStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineVertexInputStateCreateFlags { - flags: Flags, -} +pub struct PipelineVertexInputStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineShaderStageCreateFlags { - flags: Flags, -} +pub struct PipelineShaderStageCreateFlags(Flags); vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct BufferViewCreateFlags { - flags: Flags, -} +pub struct BufferViewCreateFlags(Flags); vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct InstanceCreateFlags { - flags: Flags, -} +pub struct InstanceCreateFlags(Flags); vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DeviceCreateFlags { - flags: Flags, -} +pub struct DeviceCreateFlags(Flags); vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ImageViewCreateFlags { - flags: Flags, -} +pub struct ImageViewCreateFlags(Flags); vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SemaphoreCreateFlags { - flags: Flags, -} +pub struct SemaphoreCreateFlags(Flags); vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ShaderModuleCreateFlags { - flags: Flags, -} +pub struct ShaderModuleCreateFlags(Flags); vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct EventCreateFlags { - flags: Flags, -} +pub struct EventCreateFlags(Flags); vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct MemoryMapFlags { - flags: Flags, -} +pub struct MemoryMapFlags(Flags); vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DescriptorPoolResetFlags { - flags: Flags, -} +pub struct DescriptorPoolResetFlags(Flags); vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DescriptorUpdateTemplateCreateFlags { - flags: Flags, -} +pub struct DescriptorUpdateTemplateCreateFlags(Flags); vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DisplayModeCreateFlagsKHR { - flags: Flags, -} +pub struct DisplayModeCreateFlagsKHR(Flags); vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DisplaySurfaceCreateFlagsKHR { - flags: Flags, -} +pub struct DisplaySurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct AndroidSurfaceCreateFlagsKHR { - flags: Flags, -} +pub struct AndroidSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct MirSurfaceCreateFlagsKHR { - flags: Flags, -} +pub struct MirSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(MirSurfaceCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ViSurfaceCreateFlagsNN { - flags: Flags, -} +pub struct ViSurfaceCreateFlagsNN(Flags); vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct WaylandSurfaceCreateFlagsKHR { - flags: Flags, -} +pub struct WaylandSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct Win32SurfaceCreateFlagsKHR { - flags: Flags, -} +pub struct Win32SurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct XlibSurfaceCreateFlagsKHR { - flags: Flags, -} +pub struct XlibSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct XcbSurfaceCreateFlagsKHR { - flags: Flags, -} +pub struct XcbSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct IOSSurfaceCreateFlagsMVK { - flags: Flags, -} +pub struct IOSSurfaceCreateFlagsMVK(Flags); vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct MacOSSurfaceCreateFlagsMVK { - flags: Flags, -} +pub struct MacOSSurfaceCreateFlagsMVK(Flags); vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct CommandPoolTrimFlags { - flags: Flags, -} +pub struct CommandPoolTrimFlags(Flags); vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineViewportSwizzleStateCreateFlagsNV { - flags: Flags, -} +pub struct PipelineViewportSwizzleStateCreateFlagsNV(Flags); vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineDiscardRectangleStateCreateFlagsEXT { - flags: Flags, -} +pub struct PipelineDiscardRectangleStateCreateFlagsEXT(Flags); vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineCoverageToColorStateCreateFlagsNV { - flags: Flags, -} +pub struct PipelineCoverageToColorStateCreateFlagsNV(Flags); vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineCoverageModulationStateCreateFlagsNV { - flags: Flags, -} +pub struct PipelineCoverageModulationStateCreateFlagsNV(Flags); vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ValidationCacheCreateFlagsEXT { - flags: Flags, -} +pub struct ValidationCacheCreateFlagsEXT(Flags); vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DebugUtilsMessengerCreateFlagsEXT { - flags: Flags, -} +pub struct DebugUtilsMessengerCreateFlagsEXT(Flags); vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DebugUtilsMessengerCallbackDataFlagsEXT { - flags: Flags, -} +pub struct DebugUtilsMessengerCallbackDataFlagsEXT(Flags); vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags); #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineRasterizationConservativeStateCreateFlagsEXT { - flags: Flags, -} +pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(Flags); vk_bitflags_wrapped!( PipelineRasterizationConservativeStateCreateFlagsEXT, 0b0, @@ -4885,21 +4790,63 @@ handle_nondispatchable!(SwapchainKHR); handle_nondispatchable!(DebugReportCallbackEXT); handle_nondispatchable!(DebugUtilsMessengerEXT); #[allow(non_camel_case_types)] -pub type PFN_vkInternalAllocationNotification = unsafe extern "system" fn() -> c_void; +pub type PFN_vkInternalAllocationNotification = + unsafe extern "system" fn( + p_user_data: *const c_void, + size: size_t, + allocation_type: InternalAllocationType, + allocation_scope: SystemAllocationScope, + ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn() -> c_void; +pub type PFN_vkInternalFreeNotification = + unsafe extern "system" fn( + p_user_data: *const c_void, + size: size_t, + allocation_type: InternalAllocationType, + allocation_scope: SystemAllocationScope, + ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkReallocationFunction = unsafe extern "system" fn() -> *const c_void; +pub type PFN_vkReallocationFunction = + unsafe extern "system" fn( + p_user_data: *const c_void, + p_original: *const c_void, + size: size_t, + alignment: size_t, + allocation_scope: SystemAllocationScope, + ) -> *const c_void; #[allow(non_camel_case_types)] -pub type PFN_vkAllocationFunction = unsafe extern "system" fn() -> *const c_void; +pub type PFN_vkAllocationFunction = + unsafe extern "system" fn( + p_user_data: *const c_void, + size: size_t, + alignment: size_t, + allocation_scope: SystemAllocationScope, + ) -> *const c_void; #[allow(non_camel_case_types)] -pub type PFN_vkFreeFunction = unsafe extern "system" fn() -> c_void; +pub type PFN_vkFreeFunction = + unsafe extern "system" fn(p_user_data: *const c_void, p_memory: *const c_void) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkVoidFunction = unsafe extern "system" fn() -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkDebugReportCallbackEXT = unsafe extern "system" fn() -> Bool32; +pub type PFN_vkDebugReportCallbackEXT = + unsafe extern "system" fn( + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: uint64_t, + location: size_t, + message_code: int32_t, + p_layer_prefix: *const c_char, + p_message: *const c_char, + p_user_data: *const c_void, + ) -> Bool32; #[allow(non_camel_case_types)] -pub type PFN_vkDebugUtilsMessengerCallbackEXT = unsafe extern "system" fn() -> Bool32; +pub type PFN_vkDebugUtilsMessengerCallbackEXT = + unsafe extern "system" fn( + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_type: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + p_user_data: *const c_void, + ) -> Bool32; #[repr(C)] #[derive(Copy, Clone)] pub struct BaseOutStructure { @@ -8217,21 +8164,30 @@ pub struct ExternalFormatANDROID { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ImageLayout(pub i32); +pub struct ImageLayout(pub(crate) i32); impl ImageLayout { + #[doc = "Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)"] pub const UNDEFINED: Self = ImageLayout(0); + #[doc = "General layout when image can be used for any kind of access"] pub const GENERAL: Self = ImageLayout(1); + #[doc = "Optimal layout when image is only used for color attachment read/write"] pub const COLOR_ATTACHMENT_OPTIMAL: Self = ImageLayout(2); + #[doc = "Optimal layout when image is only used for depth/stencil attachment read/write"] pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(3); + #[doc = "Optimal layout when image is used for read only depth/stencil attachment and shader access"] pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(4); + #[doc = "Optimal layout when image is used for read only shader access"] pub const SHADER_READ_ONLY_OPTIMAL: Self = ImageLayout(5); + #[doc = "Optimal layout when image is used only as source of transfer operations"] pub const TRANSFER_SRC_OPTIMAL: Self = ImageLayout(6); + #[doc = "Optimal layout when image is used only as destination of transfer operations"] pub const TRANSFER_DST_OPTIMAL: Self = ImageLayout(7); + #[doc = "Initial layout used when the data is populated by the CPU"] pub const PREINITIALIZED: Self = ImageLayout(8); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct AttachmentLoadOp(pub i32); +pub struct AttachmentLoadOp(pub(crate) i32); impl AttachmentLoadOp { pub const LOAD: Self = AttachmentLoadOp(0); pub const CLEAR: Self = AttachmentLoadOp(1); @@ -8239,14 +8195,14 @@ impl AttachmentLoadOp { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct AttachmentStoreOp(pub i32); +pub struct AttachmentStoreOp(pub(crate) i32); impl AttachmentStoreOp { pub const STORE: Self = AttachmentStoreOp(0); pub const DONT_CARE: Self = AttachmentStoreOp(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ImageType(pub i32); +pub struct ImageType(pub(crate) i32); impl ImageType { pub const TYPE_1D: Self = ImageType(0); pub const TYPE_2D: Self = ImageType(1); @@ -8254,14 +8210,14 @@ impl ImageType { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ImageTiling(pub i32); +pub struct ImageTiling(pub(crate) i32); impl ImageTiling { pub const OPTIMAL: Self = ImageTiling(0); pub const LINEAR: Self = ImageTiling(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ImageViewType(pub i32); +pub struct ImageViewType(pub(crate) i32); impl ImageViewType { pub const TYPE_1D: Self = ImageViewType(0); pub const TYPE_2D: Self = ImageViewType(1); @@ -8273,14 +8229,14 @@ impl ImageViewType { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct CommandBufferLevel(pub i32); +pub struct CommandBufferLevel(pub(crate) i32); impl CommandBufferLevel { pub const PRIMARY: Self = CommandBufferLevel(0); pub const SECONDARY: Self = CommandBufferLevel(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ComponentSwizzle(pub i32); +pub struct ComponentSwizzle(pub(crate) i32); impl ComponentSwizzle { pub const IDENTITY: Self = ComponentSwizzle(0); pub const ZERO: Self = ComponentSwizzle(1); @@ -8292,7 +8248,7 @@ impl ComponentSwizzle { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DescriptorType(pub i32); +pub struct DescriptorType(pub(crate) i32); impl DescriptorType { pub const SAMPLER: Self = DescriptorType(0); pub const COMBINED_IMAGE_SAMPLER: Self = DescriptorType(1); @@ -8308,15 +8264,16 @@ impl DescriptorType { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct QueryType(pub i32); +pub struct QueryType(pub(crate) i32); impl QueryType { pub const OCCLUSION: Self = QueryType(0); + #[doc = "Optional"] pub const PIPELINE_STATISTICS: Self = QueryType(1); pub const TIMESTAMP: Self = QueryType(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct BorderColor(pub i32); +pub struct BorderColor(pub(crate) i32); impl BorderColor { pub const FLOAT_TRANSPARENT_BLACK: Self = BorderColor(0); pub const INT_TRANSPARENT_BLACK: Self = BorderColor(1); @@ -8327,20 +8284,20 @@ impl BorderColor { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct PipelineBindPoint(pub i32); +pub struct PipelineBindPoint(pub(crate) i32); impl PipelineBindPoint { pub const GRAPHICS: Self = PipelineBindPoint(0); pub const COMPUTE: Self = PipelineBindPoint(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct PipelineCacheHeaderVersion(pub i32); +pub struct PipelineCacheHeaderVersion(pub(crate) i32); impl PipelineCacheHeaderVersion { pub const ONE: Self = PipelineCacheHeaderVersion(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct PrimitiveTopology(pub i32); +pub struct PrimitiveTopology(pub(crate) i32); impl PrimitiveTopology { pub const POINT_LIST: Self = PrimitiveTopology(0); pub const LINE_LIST: Self = PrimitiveTopology(1); @@ -8356,35 +8313,37 @@ impl PrimitiveTopology { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SharingMode(pub i32); +pub struct SharingMode(pub(crate) i32); impl SharingMode { pub const EXCLUSIVE: Self = SharingMode(0); pub const CONCURRENT: Self = SharingMode(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct IndexType(pub i32); +pub struct IndexType(pub(crate) i32); impl IndexType { pub const UINT16: Self = IndexType(0); pub const UINT32: Self = IndexType(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct Filter(pub i32); +pub struct Filter(pub(crate) i32); impl Filter { pub const NEAREST: Self = Filter(0); pub const LINEAR: Self = Filter(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SamplerMipmapMode(pub i32); +pub struct SamplerMipmapMode(pub(crate) i32); impl SamplerMipmapMode { + #[doc = "Choose nearest mip level"] pub const NEAREST: Self = SamplerMipmapMode(0); + #[doc = "Linear filter between mip levels"] pub const LINEAR: Self = SamplerMipmapMode(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SamplerAddressMode(pub i32); +pub struct SamplerAddressMode(pub(crate) i32); impl SamplerAddressMode { pub const REPEAT: Self = SamplerAddressMode(0); pub const MIRRORED_REPEAT: Self = SamplerAddressMode(1); @@ -8393,7 +8352,7 @@ impl SamplerAddressMode { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct CompareOp(pub i32); +pub struct CompareOp(pub(crate) i32); impl CompareOp { pub const NEVER: Self = CompareOp(0); pub const LESS: Self = CompareOp(1); @@ -8406,7 +8365,7 @@ impl CompareOp { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct PolygonMode(pub i32); +pub struct PolygonMode(pub(crate) i32); impl PolygonMode { pub const FILL: Self = PolygonMode(0); pub const LINE: Self = PolygonMode(1); @@ -8414,14 +8373,14 @@ impl PolygonMode { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct FrontFace(pub i32); +pub struct FrontFace(pub(crate) i32); impl FrontFace { pub const COUNTER_CLOCKWISE: Self = FrontFace(0); pub const CLOCKWISE: Self = FrontFace(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct BlendFactor(pub i32); +pub struct BlendFactor(pub(crate) i32); impl BlendFactor { pub const ZERO: Self = BlendFactor(0); pub const ONE: Self = BlendFactor(1); @@ -8445,7 +8404,7 @@ impl BlendFactor { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct BlendOp(pub i32); +pub struct BlendOp(pub(crate) i32); impl BlendOp { pub const ADD: Self = BlendOp(0); pub const SUBTRACT: Self = BlendOp(1); @@ -8455,7 +8414,7 @@ impl BlendOp { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct StencilOp(pub i32); +pub struct StencilOp(pub(crate) i32); impl StencilOp { pub const KEEP: Self = StencilOp(0); pub const ZERO: Self = StencilOp(1); @@ -8468,7 +8427,7 @@ impl StencilOp { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct LogicOp(pub i32); +pub struct LogicOp(pub(crate) i32); impl LogicOp { pub const CLEAR: Self = LogicOp(0); pub const AND: Self = LogicOp(1); @@ -8489,13 +8448,13 @@ impl LogicOp { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct InternalAllocationType(pub i32); +pub struct InternalAllocationType(pub(crate) i32); impl InternalAllocationType { pub const EXECUTABLE: Self = InternalAllocationType(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SystemAllocationScope(pub i32); +pub struct SystemAllocationScope(pub(crate) i32); impl SystemAllocationScope { pub const COMMAND: Self = SystemAllocationScope(0); pub const OBJECT: Self = SystemAllocationScope(1); @@ -8505,7 +8464,7 @@ impl SystemAllocationScope { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct PhysicalDeviceType(pub i32); +pub struct PhysicalDeviceType(pub(crate) i32); impl PhysicalDeviceType { pub const OTHER: Self = PhysicalDeviceType(0); pub const INTEGRATED_GPU: Self = PhysicalDeviceType(1); @@ -8515,14 +8474,14 @@ impl PhysicalDeviceType { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct VertexInputRate(pub i32); +pub struct VertexInputRate(pub(crate) i32); impl VertexInputRate { pub const VERTEX: Self = VertexInputRate(0); pub const INSTANCE: Self = VertexInputRate(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct Format(pub i32); +pub struct Format(pub(crate) i32); impl Format { pub const UNDEFINED: Self = Format(0); pub const R4G4_UNORM_PACK8: Self = Format(1); @@ -8712,7 +8671,7 @@ impl Format { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct StructureType(pub i32); +pub struct StructureType(pub(crate) i32); impl StructureType { pub const APPLICATION_INFO: Self = StructureType(0); pub const INSTANCE_CREATE_INFO: Self = StructureType(1); @@ -8761,37 +8720,57 @@ impl StructureType { pub const BUFFER_MEMORY_BARRIER: Self = StructureType(44); pub const IMAGE_MEMORY_BARRIER: Self = StructureType(45); pub const MEMORY_BARRIER: Self = StructureType(46); + #[doc = "Reserved for internal use by the loader, layers, and ICDs"] pub const LOADER_INSTANCE_CREATE_INFO: Self = StructureType(47); + #[doc = "Reserved for internal use by the loader, layers, and ICDs"] pub const LOADER_DEVICE_CREATE_INFO: Self = StructureType(48); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SubpassContents(pub i32); +pub struct SubpassContents(pub(crate) i32); impl SubpassContents { pub const INLINE: Self = SubpassContents(0); pub const SECONDARY_COMMAND_BUFFERS: Self = SubpassContents(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct Result(pub i32); +pub struct Result(pub(crate) i32); impl Result { + #[doc = "Command completed successfully"] pub const SUCCESS: Self = Result(0); + #[doc = "A fence or query has not yet completed"] pub const NOT_READY: Self = Result(1); + #[doc = "A wait operation has not completed in the specified time"] pub const TIMEOUT: Self = Result(2); + #[doc = "An event is signaled"] pub const EVENT_SET: Self = Result(3); + #[doc = "An event is unsignaled"] pub const EVENT_RESET: Self = Result(4); + #[doc = "A return array was too small for the result"] pub const INCOMPLETE: Self = Result(5); + #[doc = "A host memory allocation has failed"] pub const ERROR_OUT_OF_HOST_MEMORY: Self = Result(-1); + #[doc = "A device memory allocation has failed"] pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Result(-2); + #[doc = "Initialization of a object has failed"] pub const ERROR_INITIALIZATION_FAILED: Self = Result(-3); + #[doc = "The logical device has been lost. See <>"] pub const ERROR_DEVICE_LOST: Self = Result(-4); + #[doc = "Mapping of a memory object has failed"] pub const ERROR_MEMORY_MAP_FAILED: Self = Result(-5); + #[doc = "Layer specified does not exist"] pub const ERROR_LAYER_NOT_PRESENT: Self = Result(-6); + #[doc = "Extension specified does not exist"] pub const ERROR_EXTENSION_NOT_PRESENT: Self = Result(-7); + #[doc = "Requested feature is not available on this device"] pub const ERROR_FEATURE_NOT_PRESENT: Self = Result(-8); + #[doc = "Unable to find a Vulkan driver"] pub const ERROR_INCOMPATIBLE_DRIVER: Self = Result(-9); + #[doc = "Too many objects of the type have already been created"] pub const ERROR_TOO_MANY_OBJECTS: Self = Result(-10); + #[doc = "Requested format is not supported on this device"] pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Result(-11); + #[doc = "A requested pool allocation has failed due to fragmentation of the pool\'s memory"] pub const ERROR_FRAGMENTED_POOL: Self = Result(-12); } impl ::std::error::Error for Result { @@ -8849,7 +8828,7 @@ impl ::std::fmt::Display for Result { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DynamicState(pub i32); +pub struct DynamicState(pub(crate) i32); impl DynamicState { pub const VIEWPORT: Self = DynamicState(0); pub const SCISSOR: Self = DynamicState(1); @@ -8863,44 +8842,70 @@ impl DynamicState { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DescriptorUpdateTemplateType(pub i32); +pub struct DescriptorUpdateTemplateType(pub(crate) i32); impl DescriptorUpdateTemplateType { + #[doc = "Create descriptor update template for descriptor set updates"] pub const DESCRIPTOR_SET: Self = DescriptorUpdateTemplateType(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ObjectType(pub i32); +pub struct ObjectType(pub(crate) i32); impl ObjectType { pub const UNKNOWN: Self = ObjectType(0); + #[doc = "VkInstance"] pub const INSTANCE: Self = ObjectType(1); + #[doc = "VkPhysicalDevice"] pub const PHYSICAL_DEVICE: Self = ObjectType(2); + #[doc = "VkDevice"] pub const DEVICE: Self = ObjectType(3); + #[doc = "VkQueue"] pub const QUEUE: Self = ObjectType(4); + #[doc = "VkSemaphore"] pub const SEMAPHORE: Self = ObjectType(5); + #[doc = "VkCommandBuffer"] pub const COMMAND_BUFFER: Self = ObjectType(6); + #[doc = "VkFence"] pub const FENCE: Self = ObjectType(7); + #[doc = "VkDeviceMemory"] pub const DEVICE_MEMORY: Self = ObjectType(8); + #[doc = "VkBuffer"] pub const BUFFER: Self = ObjectType(9); + #[doc = "VkImage"] pub const IMAGE: Self = ObjectType(10); + #[doc = "VkEvent"] pub const EVENT: Self = ObjectType(11); + #[doc = "VkQueryPool"] pub const QUERY_POOL: Self = ObjectType(12); + #[doc = "VkBufferView"] pub const BUFFER_VIEW: Self = ObjectType(13); + #[doc = "VkImageView"] pub const IMAGE_VIEW: Self = ObjectType(14); + #[doc = "VkShaderModule"] pub const SHADER_MODULE: Self = ObjectType(15); + #[doc = "VkPipelineCache"] pub const PIPELINE_CACHE: Self = ObjectType(16); + #[doc = "VkPipelineLayout"] pub const PIPELINE_LAYOUT: Self = ObjectType(17); + #[doc = "VkRenderPass"] pub const RENDER_PASS: Self = ObjectType(18); + #[doc = "VkPipeline"] pub const PIPELINE: Self = ObjectType(19); + #[doc = "VkDescriptorSetLayout"] pub const DESCRIPTOR_SET_LAYOUT: Self = ObjectType(20); + #[doc = "VkSampler"] pub const SAMPLER: Self = ObjectType(21); + #[doc = "VkDescriptorPool"] pub const DESCRIPTOR_POOL: Self = ObjectType(22); + #[doc = "VkDescriptorSet"] pub const DESCRIPTOR_SET: Self = ObjectType(23); + #[doc = "VkFramebuffer"] pub const FRAMEBUFFER: Self = ObjectType(24); + #[doc = "VkCommandPool"] pub const COMMAND_POOL: Self = ObjectType(25); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct PresentModeKHR(pub i32); +pub struct PresentModeKHR(pub(crate) i32); impl PresentModeKHR { pub const PRESENT_MODE_IMMEDIATE_KHR: Self = PresentModeKHR(0); pub const PRESENT_MODE_MAILBOX_KHR: Self = PresentModeKHR(1); @@ -8909,13 +8914,13 @@ impl PresentModeKHR { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ColorSpaceKHR(pub i32); +pub struct ColorSpaceKHR(pub(crate) i32); impl ColorSpaceKHR { pub const COLOR_SPACE_SRGB_NONLINEAR_KHR: Self = ColorSpaceKHR(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DebugReportObjectTypeEXT(pub i32); +pub struct DebugReportObjectTypeEXT(pub(crate) i32); impl DebugReportObjectTypeEXT { pub const DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: Self = DebugReportObjectTypeEXT(0); pub const DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: Self = DebugReportObjectTypeEXT(1); @@ -8958,21 +8963,21 @@ impl DebugReportObjectTypeEXT { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct RasterizationOrderAMD(pub i32); +pub struct RasterizationOrderAMD(pub(crate) i32); impl RasterizationOrderAMD { pub const RASTERIZATION_ORDER_STRICT_AMD: Self = RasterizationOrderAMD(0); pub const RASTERIZATION_ORDER_RELAXED_AMD: Self = RasterizationOrderAMD(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ValidationCheckEXT(pub i32); +pub struct ValidationCheckEXT(pub(crate) i32); impl ValidationCheckEXT { pub const VALIDATION_CHECK_ALL_EXT: Self = ValidationCheckEXT(0); pub const VALIDATION_CHECK_SHADERS_EXT: Self = ValidationCheckEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct IndirectCommandsTokenTypeNVX(pub i32); +pub struct IndirectCommandsTokenTypeNVX(pub(crate) i32); impl IndirectCommandsTokenTypeNVX { pub const INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX: Self = IndirectCommandsTokenTypeNVX(0); pub const INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX: Self = @@ -8988,7 +8993,7 @@ impl IndirectCommandsTokenTypeNVX { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ObjectEntryTypeNVX(pub i32); +pub struct ObjectEntryTypeNVX(pub(crate) i32); impl ObjectEntryTypeNVX { pub const OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX: Self = ObjectEntryTypeNVX(0); pub const OBJECT_ENTRY_TYPE_PIPELINE_NVX: Self = ObjectEntryTypeNVX(1); @@ -8998,7 +9003,7 @@ impl ObjectEntryTypeNVX { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DisplayPowerStateEXT(pub i32); +pub struct DisplayPowerStateEXT(pub(crate) i32); impl DisplayPowerStateEXT { pub const DISPLAY_POWER_STATE_OFF_EXT: Self = DisplayPowerStateEXT(0); pub const DISPLAY_POWER_STATE_SUSPEND_EXT: Self = DisplayPowerStateEXT(1); @@ -9006,19 +9011,19 @@ impl DisplayPowerStateEXT { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DeviceEventTypeEXT(pub i32); +pub struct DeviceEventTypeEXT(pub(crate) i32); impl DeviceEventTypeEXT { pub const DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: Self = DeviceEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DisplayEventTypeEXT(pub i32); +pub struct DisplayEventTypeEXT(pub(crate) i32); impl DisplayEventTypeEXT { pub const DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: Self = DisplayEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ViewportCoordinateSwizzleNV(pub i32); +pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); impl ViewportCoordinateSwizzleNV { pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: Self = ViewportCoordinateSwizzleNV(0); pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: Self = ViewportCoordinateSwizzleNV(1); @@ -9031,21 +9036,21 @@ impl ViewportCoordinateSwizzleNV { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct DiscardRectangleModeEXT(pub i32); +pub struct DiscardRectangleModeEXT(pub(crate) i32); impl DiscardRectangleModeEXT { pub const DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: Self = DiscardRectangleModeEXT(0); pub const DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: Self = DiscardRectangleModeEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct PointClippingBehavior(pub i32); +pub struct PointClippingBehavior(pub(crate) i32); impl PointClippingBehavior { pub const ALL_CLIP_PLANES: Self = PointClippingBehavior(0); pub const USER_CLIP_PLANES_ONLY: Self = PointClippingBehavior(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SamplerReductionModeEXT(pub i32); +pub struct SamplerReductionModeEXT(pub(crate) i32); impl SamplerReductionModeEXT { pub const SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT: Self = SamplerReductionModeEXT(0); pub const SAMPLER_REDUCTION_MODE_MIN_EXT: Self = SamplerReductionModeEXT(1); @@ -9053,38 +9058,44 @@ impl SamplerReductionModeEXT { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct TessellationDomainOrigin(pub i32); +pub struct TessellationDomainOrigin(pub(crate) i32); impl TessellationDomainOrigin { pub const UPPER_LEFT: Self = TessellationDomainOrigin(0); pub const LOWER_LEFT: Self = TessellationDomainOrigin(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SamplerYcbcrModelConversion(pub i32); +pub struct SamplerYcbcrModelConversion(pub(crate) i32); impl SamplerYcbcrModelConversion { pub const RGB_IDENTITY: Self = SamplerYcbcrModelConversion(0); + #[doc = "just range expansion"] pub const YCBCR_IDENTITY: Self = SamplerYcbcrModelConversion(1); + #[doc = "aka HD YUV"] pub const YCBCR_709: Self = SamplerYcbcrModelConversion(2); + #[doc = "aka SD YUV"] pub const YCBCR_601: Self = SamplerYcbcrModelConversion(3); + #[doc = "aka UHD YUV"] pub const YCBCR_2020: Self = SamplerYcbcrModelConversion(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct SamplerYcbcrRange(pub i32); +pub struct SamplerYcbcrRange(pub(crate) i32); impl SamplerYcbcrRange { + #[doc = "Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)"] pub const ITU_FULL: Self = SamplerYcbcrRange(0); + #[doc = "Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240"] pub const ITU_NARROW: Self = SamplerYcbcrRange(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ChromaLocation(pub i32); +pub struct ChromaLocation(pub(crate) i32); impl ChromaLocation { pub const COSITED_EVEN: Self = ChromaLocation(0); pub const MIDPOINT: Self = ChromaLocation(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct BlendOverlapEXT(pub i32); +pub struct BlendOverlapEXT(pub(crate) i32); impl BlendOverlapEXT { pub const BLEND_OVERLAP_UNCORRELATED_EXT: Self = BlendOverlapEXT(0); pub const BLEND_OVERLAP_DISJOINT_EXT: Self = BlendOverlapEXT(1); @@ -9092,7 +9103,7 @@ impl BlendOverlapEXT { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct CoverageModulationModeNV(pub i32); +pub struct CoverageModulationModeNV(pub(crate) i32); impl CoverageModulationModeNV { pub const COVERAGE_MODULATION_MODE_NONE_NV: Self = CoverageModulationModeNV(0); pub const COVERAGE_MODULATION_MODE_RGB_NV: Self = CoverageModulationModeNV(1); @@ -9101,13 +9112,13 @@ impl CoverageModulationModeNV { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ValidationCacheHeaderVersionEXT(pub i32); +pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); impl ValidationCacheHeaderVersionEXT { pub const VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: Self = ValidationCacheHeaderVersionEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ShaderInfoTypeAMD(pub i32); +pub struct ShaderInfoTypeAMD(pub(crate) i32); impl ShaderInfoTypeAMD { pub const SHADER_INFO_TYPE_STATISTICS_AMD: Self = ShaderInfoTypeAMD(0); pub const SHADER_INFO_TYPE_BINARY_AMD: Self = ShaderInfoTypeAMD(1); @@ -9115,7 +9126,7 @@ impl ShaderInfoTypeAMD { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct QueueGlobalPriorityEXT(pub i32); +pub struct QueueGlobalPriorityEXT(pub(crate) i32); impl QueueGlobalPriorityEXT { pub const QUEUE_GLOBAL_PRIORITY_LOW_EXT: Self = QueueGlobalPriorityEXT(128); pub const QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT: Self = QueueGlobalPriorityEXT(256); @@ -9124,7 +9135,7 @@ impl QueueGlobalPriorityEXT { } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -pub struct ConservativeRasterizationModeEXT(pub i32); +pub struct ConservativeRasterizationModeEXT(pub(crate) i32); impl ConservativeRasterizationModeEXT { pub const CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: Self = ConservativeRasterizationModeEXT(0); @@ -9133,753 +9144,737 @@ impl ConservativeRasterizationModeEXT { pub const CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: Self = ConservativeRasterizationModeEXT(2); } +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct CullModeFlags { - flags: Flags, -} -vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); -impl CullModeFlags { - pub const NONE: Self = CullModeFlags { flags: 0 }; - pub const FRONT_BIT: Self = CullModeFlags { flags: 0b1 }; - pub const BACK_BIT: Self = CullModeFlags { flags: 0b10 }; - pub const FRONT_AND_BACK: Self = CullModeFlags { flags: 0x00000003 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct QueueFlags { - flags: Flags, -} -vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); -impl QueueFlags { - pub const GRAPHICS_BIT: Self = QueueFlags { flags: 0b1 }; - pub const COMPUTE_BIT: Self = QueueFlags { flags: 0b10 }; - pub const TRANSFER_BIT: Self = QueueFlags { flags: 0b100 }; - pub const SPARSE_BINDING_BIT: Self = QueueFlags { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DeviceQueueCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); -impl DeviceQueueCreateFlags {} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct MemoryPropertyFlags { - flags: Flags, -} -vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); -impl MemoryPropertyFlags { - pub const DEVICE_LOCAL_BIT: Self = MemoryPropertyFlags { flags: 0b1 }; - pub const HOST_VISIBLE_BIT: Self = MemoryPropertyFlags { flags: 0b10 }; - pub const HOST_COHERENT_BIT: Self = MemoryPropertyFlags { flags: 0b100 }; - pub const HOST_CACHED_BIT: Self = MemoryPropertyFlags { flags: 0b1000 }; - pub const LAZILY_ALLOCATED_BIT: Self = MemoryPropertyFlags { flags: 0b10000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct MemoryHeapFlags { - flags: Flags, -} -vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); -impl MemoryHeapFlags { - pub const DEVICE_LOCAL_BIT: Self = MemoryHeapFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct AccessFlags { - flags: Flags, -} -vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); -impl AccessFlags { - pub const INDIRECT_COMMAND_READ_BIT: Self = AccessFlags { flags: 0b1 }; - pub const INDEX_READ_BIT: Self = AccessFlags { flags: 0b10 }; - pub const VERTEX_ATTRIBUTE_READ_BIT: Self = AccessFlags { flags: 0b100 }; - pub const UNIFORM_READ_BIT: Self = AccessFlags { flags: 0b1000 }; - pub const INPUT_ATTACHMENT_READ_BIT: Self = AccessFlags { flags: 0b10000 }; - pub const SHADER_READ_BIT: Self = AccessFlags { flags: 0b100000 }; - pub const SHADER_WRITE_BIT: Self = AccessFlags { flags: 0b1000000 }; - pub const COLOR_ATTACHMENT_READ_BIT: Self = AccessFlags { flags: 0b10000000 }; - pub const COLOR_ATTACHMENT_WRITE_BIT: Self = AccessFlags { flags: 0b100000000 }; - pub const DEPTH_STENCIL_ATTACHMENT_READ_BIT: Self = AccessFlags { - flags: 0b1000000000, - }; - pub const DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: Self = AccessFlags { - flags: 0b10000000000, - }; - pub const TRANSFER_READ_BIT: Self = AccessFlags { - flags: 0b100000000000, - }; - pub const TRANSFER_WRITE_BIT: Self = AccessFlags { - flags: 0b1000000000000, - }; - pub const HOST_READ_BIT: Self = AccessFlags { - flags: 0b10000000000000, - }; - pub const HOST_WRITE_BIT: Self = AccessFlags { - flags: 0b100000000000000, - }; - pub const MEMORY_READ_BIT: Self = AccessFlags { - flags: 0b1000000000000000, - }; - pub const MEMORY_WRITE_BIT: Self = AccessFlags { - flags: 0b10000000000000000, - }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct BufferUsageFlags { - flags: Flags, -} -vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); -impl BufferUsageFlags { - pub const TRANSFER_SRC_BIT: Self = BufferUsageFlags { flags: 0b1 }; - pub const TRANSFER_DST_BIT: Self = BufferUsageFlags { flags: 0b10 }; - pub const UNIFORM_TEXEL_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b100 }; - pub const STORAGE_TEXEL_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b1000 }; - pub const UNIFORM_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b10000 }; - pub const STORAGE_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b100000 }; - pub const INDEX_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b1000000 }; - pub const VERTEX_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b10000000 }; - pub const INDIRECT_BUFFER_BIT: Self = BufferUsageFlags { flags: 0b100000000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct BufferCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); -impl BufferCreateFlags { - pub const SPARSE_BINDING_BIT: Self = BufferCreateFlags { flags: 0b1 }; - pub const SPARSE_RESIDENCY_BIT: Self = BufferCreateFlags { flags: 0b10 }; - pub const SPARSE_ALIASED_BIT: Self = BufferCreateFlags { flags: 0b100 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ShaderStageFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); -impl ShaderStageFlags { - pub const VERTEX_BIT: Self = ShaderStageFlags { flags: 0b1 }; - pub const TESSELLATION_CONTROL_BIT: Self = ShaderStageFlags { flags: 0b10 }; - pub const TESSELLATION_EVALUATION_BIT: Self = ShaderStageFlags { flags: 0b100 }; - pub const GEOMETRY_BIT: Self = ShaderStageFlags { flags: 0b1000 }; - pub const FRAGMENT_BIT: Self = ShaderStageFlags { flags: 0b10000 }; - pub const COMPUTE_BIT: Self = ShaderStageFlags { flags: 0b100000 }; - pub const ALL_GRAPHICS: Self = ShaderStageFlags { flags: 0x0000001F }; - pub const ALL: Self = ShaderStageFlags { flags: 0x7FFFFFFF }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ImageUsageFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); -impl ImageUsageFlags { - pub const TRANSFER_SRC_BIT: Self = ImageUsageFlags { flags: 0b1 }; - pub const TRANSFER_DST_BIT: Self = ImageUsageFlags { flags: 0b10 }; - pub const SAMPLED_BIT: Self = ImageUsageFlags { flags: 0b100 }; - pub const STORAGE_BIT: Self = ImageUsageFlags { flags: 0b1000 }; - pub const COLOR_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b10000 }; - pub const DEPTH_STENCIL_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b100000 }; - pub const TRANSIENT_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b1000000 }; - pub const INPUT_ATTACHMENT_BIT: Self = ImageUsageFlags { flags: 0b10000000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ImageCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); -impl ImageCreateFlags { - pub const SPARSE_BINDING_BIT: Self = ImageCreateFlags { flags: 0b1 }; - pub const SPARSE_RESIDENCY_BIT: Self = ImageCreateFlags { flags: 0b10 }; - pub const SPARSE_ALIASED_BIT: Self = ImageCreateFlags { flags: 0b100 }; - pub const MUTABLE_FORMAT_BIT: Self = ImageCreateFlags { flags: 0b1000 }; - pub const CUBE_COMPATIBLE_BIT: Self = ImageCreateFlags { flags: 0b10000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); -impl PipelineCreateFlags { - pub const DISABLE_OPTIMIZATION_BIT: Self = PipelineCreateFlags { flags: 0b1 }; - pub const ALLOW_DERIVATIVES_BIT: Self = PipelineCreateFlags { flags: 0b10 }; - pub const DERIVATIVE_BIT: Self = PipelineCreateFlags { flags: 0b100 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ColorComponentFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); -impl ColorComponentFlags { - pub const R_BIT: Self = ColorComponentFlags { flags: 0b1 }; - pub const G_BIT: Self = ColorComponentFlags { flags: 0b10 }; - pub const B_BIT: Self = ColorComponentFlags { flags: 0b100 }; - pub const A_BIT: Self = ColorComponentFlags { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct FenceCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); -impl FenceCreateFlags { - pub const SIGNALED_BIT: Self = FenceCreateFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct FormatFeatureFlags { - flags: Flags, -} -vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); -impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_BIT: Self = FormatFeatureFlags { flags: 0b1 }; - pub const STORAGE_IMAGE_BIT: Self = FormatFeatureFlags { flags: 0b10 }; - pub const STORAGE_IMAGE_ATOMIC_BIT: Self = FormatFeatureFlags { flags: 0b100 }; - pub const UNIFORM_TEXEL_BUFFER_BIT: Self = FormatFeatureFlags { flags: 0b1000 }; - pub const STORAGE_TEXEL_BUFFER_BIT: Self = FormatFeatureFlags { flags: 0b10000 }; - pub const STORAGE_TEXEL_BUFFER_ATOMIC_BIT: Self = FormatFeatureFlags { flags: 0b100000 }; - pub const VERTEX_BUFFER_BIT: Self = FormatFeatureFlags { flags: 0b1000000 }; - pub const COLOR_ATTACHMENT_BIT: Self = FormatFeatureFlags { flags: 0b10000000 }; - pub const COLOR_ATTACHMENT_BLEND_BIT: Self = FormatFeatureFlags { flags: 0b100000000 }; - pub const DEPTH_STENCIL_ATTACHMENT_BIT: Self = FormatFeatureFlags { - flags: 0b1000000000, - }; - pub const BLIT_SRC_BIT: Self = FormatFeatureFlags { - flags: 0b10000000000, - }; - pub const BLIT_DST_BIT: Self = FormatFeatureFlags { - flags: 0b100000000000, - }; - pub const SAMPLED_IMAGE_FILTER_LINEAR_BIT: Self = FormatFeatureFlags { - flags: 0b1000000000000, - }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct QueryControlFlags { - flags: Flags, -} -vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); -impl QueryControlFlags { - pub const PRECISE_BIT: Self = QueryControlFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct QueryResultFlags { - flags: Flags, -} -vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); -impl QueryResultFlags { - pub const TYPE_64_BIT: Self = QueryResultFlags { flags: 0b1 }; - pub const WAIT_BIT: Self = QueryResultFlags { flags: 0b10 }; - pub const WITH_AVAILABILITY_BIT: Self = QueryResultFlags { flags: 0b100 }; - pub const PARTIAL_BIT: Self = QueryResultFlags { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct CommandBufferUsageFlags { - flags: Flags, -} -vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); -impl CommandBufferUsageFlags { - pub const ONE_TIME_SUBMIT_BIT: Self = CommandBufferUsageFlags { flags: 0b1 }; - pub const RENDER_PASS_CONTINUE_BIT: Self = CommandBufferUsageFlags { flags: 0b10 }; - pub const SIMULTANEOUS_USE_BIT: Self = CommandBufferUsageFlags { flags: 0b100 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct QueryPipelineStatisticFlags { - flags: Flags, -} -vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); -impl QueryPipelineStatisticFlags { - pub const INPUT_ASSEMBLY_VERTICES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b1 }; - pub const INPUT_ASSEMBLY_PRIMITIVES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b10 }; - pub const VERTEX_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { flags: 0b100 }; - pub const GEOMETRY_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { flags: 0b1000 }; - pub const GEOMETRY_SHADER_PRIMITIVES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b10000 }; - pub const CLIPPING_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { flags: 0b100000 }; - pub const CLIPPING_PRIMITIVES_BIT: Self = QueryPipelineStatisticFlags { flags: 0b1000000 }; - pub const FRAGMENT_SHADER_INVOCATIONS_BIT: Self = - QueryPipelineStatisticFlags { flags: 0b10000000 }; - pub const TESSELLATION_CONTROL_SHADER_PATCHES_BIT: Self = - QueryPipelineStatisticFlags { flags: 0b100000000 }; - pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { - flags: 0b1000000000, - }; - pub const COMPUTE_SHADER_INVOCATIONS_BIT: Self = QueryPipelineStatisticFlags { - flags: 0b10000000000, - }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ImageAspectFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); -impl ImageAspectFlags { - pub const COLOR_BIT: Self = ImageAspectFlags { flags: 0b1 }; - pub const DEPTH_BIT: Self = ImageAspectFlags { flags: 0b10 }; - pub const STENCIL_BIT: Self = ImageAspectFlags { flags: 0b100 }; - pub const METADATA_BIT: Self = ImageAspectFlags { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SparseImageFormatFlags { - flags: Flags, -} -vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); -impl SparseImageFormatFlags { - pub const SINGLE_MIPTAIL_BIT: Self = SparseImageFormatFlags { flags: 0b1 }; - pub const ALIGNED_MIP_SIZE_BIT: Self = SparseImageFormatFlags { flags: 0b10 }; - pub const NONSTANDARD_BLOCK_SIZE_BIT: Self = SparseImageFormatFlags { flags: 0b100 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SparseMemoryBindFlags { - flags: Flags, -} -vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); -impl SparseMemoryBindFlags { - pub const METADATA_BIT: Self = SparseMemoryBindFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PipelineStageFlags { - flags: Flags, -} -vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); -impl PipelineStageFlags { - pub const TOP_OF_PIPE_BIT: Self = PipelineStageFlags { flags: 0b1 }; - pub const DRAW_INDIRECT_BIT: Self = PipelineStageFlags { flags: 0b10 }; - pub const VERTEX_INPUT_BIT: Self = PipelineStageFlags { flags: 0b100 }; - pub const VERTEX_SHADER_BIT: Self = PipelineStageFlags { flags: 0b1000 }; - pub const TESSELLATION_CONTROL_SHADER_BIT: Self = PipelineStageFlags { flags: 0b10000 }; - pub const TESSELLATION_EVALUATION_SHADER_BIT: Self = PipelineStageFlags { flags: 0b100000 }; - pub const GEOMETRY_SHADER_BIT: Self = PipelineStageFlags { flags: 0b1000000 }; - pub const FRAGMENT_SHADER_BIT: Self = PipelineStageFlags { flags: 0b10000000 }; - pub const EARLY_FRAGMENT_TESTS_BIT: Self = PipelineStageFlags { flags: 0b100000000 }; - pub const LATE_FRAGMENT_TESTS_BIT: Self = PipelineStageFlags { - flags: 0b1000000000, - }; - pub const COLOR_ATTACHMENT_OUTPUT_BIT: Self = PipelineStageFlags { - flags: 0b10000000000, - }; - pub const COMPUTE_SHADER_BIT: Self = PipelineStageFlags { - flags: 0b100000000000, - }; - pub const TRANSFER_BIT: Self = PipelineStageFlags { - flags: 0b1000000000000, - }; - pub const BOTTOM_OF_PIPE_BIT: Self = PipelineStageFlags { - flags: 0b10000000000000, - }; - pub const HOST_BIT: Self = PipelineStageFlags { - flags: 0b100000000000000, - }; - pub const ALL_GRAPHICS_BIT: Self = PipelineStageFlags { - flags: 0b1000000000000000, - }; - pub const ALL_COMMANDS_BIT: Self = PipelineStageFlags { - flags: 0b10000000000000000, - }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct CommandPoolCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); -impl CommandPoolCreateFlags { - pub const TRANSIENT_BIT: Self = CommandPoolCreateFlags { flags: 0b1 }; - pub const RESET_COMMAND_BUFFER_BIT: Self = CommandPoolCreateFlags { flags: 0b10 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct CommandPoolResetFlags { - flags: Flags, -} -vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); -impl CommandPoolResetFlags { - pub const RELEASE_RESOURCES_BIT: Self = CommandPoolResetFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct CommandBufferResetFlags { - flags: Flags, -} -vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); -impl CommandBufferResetFlags { - pub const RELEASE_RESOURCES_BIT: Self = CommandBufferResetFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SampleCountFlags { - flags: Flags, -} -vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); -impl SampleCountFlags { - pub const TYPE_1_BIT: Self = SampleCountFlags { flags: 0b1 }; - pub const TYPE_2_BIT: Self = SampleCountFlags { flags: 0b10 }; - pub const TYPE_4_BIT: Self = SampleCountFlags { flags: 0b100 }; - pub const TYPE_8_BIT: Self = SampleCountFlags { flags: 0b1000 }; - pub const TYPE_16_BIT: Self = SampleCountFlags { flags: 0b10000 }; - pub const TYPE_32_BIT: Self = SampleCountFlags { flags: 0b100000 }; - pub const TYPE_64_BIT: Self = SampleCountFlags { flags: 0b1000000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct AttachmentDescriptionFlags { - flags: Flags, -} -vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); -impl AttachmentDescriptionFlags { - pub const MAY_ALIAS_BIT: Self = AttachmentDescriptionFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct StencilFaceFlags { - flags: Flags, -} -vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); -impl StencilFaceFlags { - pub const FRONT_BIT: Self = StencilFaceFlags { flags: 0b1 }; - pub const BACK_BIT: Self = StencilFaceFlags { flags: 0b10 }; - pub const STENCIL_FRONT_AND_BACK: Self = StencilFaceFlags { flags: 0x00000003 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DescriptorPoolCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); -impl DescriptorPoolCreateFlags { - pub const FREE_DESCRIPTOR_SET_BIT: Self = DescriptorPoolCreateFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DependencyFlags { - flags: Flags, -} -vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); -impl DependencyFlags { - pub const BY_REGION_BIT: Self = DependencyFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DisplayPlaneAlphaFlagsKHR { - flags: Flags, -} -vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); -impl DisplayPlaneAlphaFlagsKHR { - pub const OPAQUE_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b1 }; - pub const GLOBAL_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b10 }; - pub const PER_PIXEL_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b100 }; - pub const PER_PIXEL_PREMULTIPLIED_BIT_KHR: Self = DisplayPlaneAlphaFlagsKHR { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct CompositeAlphaFlagsKHR { - flags: Flags, -} -vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); -impl CompositeAlphaFlagsKHR { - pub const OPAQUE_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b1 }; - pub const PRE_MULTIPLIED_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b10 }; - pub const POST_MULTIPLIED_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b100 }; - pub const INHERIT_BIT_KHR: Self = CompositeAlphaFlagsKHR { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SurfaceTransformFlagsKHR { - flags: Flags, -} -vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); -impl SurfaceTransformFlagsKHR { - pub const IDENTITY_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b1 }; - pub const ROTATE_90_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b10 }; - pub const ROTATE_180_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b100 }; - pub const ROTATE_270_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b1000 }; - pub const HORIZONTAL_MIRROR_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b10000 }; - pub const HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: Self = - SurfaceTransformFlagsKHR { flags: 0b100000 }; - pub const HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: Self = - SurfaceTransformFlagsKHR { flags: 0b1000000 }; - pub const HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: Self = - SurfaceTransformFlagsKHR { flags: 0b10000000 }; - pub const INHERIT_BIT_KHR: Self = SurfaceTransformFlagsKHR { flags: 0b100000000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DebugReportFlagsEXT { - flags: Flags, -} -vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); -impl DebugReportFlagsEXT { - pub const INFORMATION_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b1 }; - pub const WARNING_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b10 }; - pub const PERFORMANCE_WARNING_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b100 }; - pub const ERROR_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b1000 }; - pub const DEBUG_BIT_EXT: Self = DebugReportFlagsEXT { flags: 0b10000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalMemoryHandleTypeFlagsNV { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); -impl ExternalMemoryHandleTypeFlagsNV { - pub const OPAQUE_WIN32_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b1 }; - pub const OPAQUE_WIN32_KMT_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b10 }; - pub const D3D11_IMAGE_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b100 }; - pub const D3D11_IMAGE_KMT_BIT_NV: Self = ExternalMemoryHandleTypeFlagsNV { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalMemoryFeatureFlagsNV { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); -impl ExternalMemoryFeatureFlagsNV { - pub const DEDICATED_ONLY_BIT_NV: Self = ExternalMemoryFeatureFlagsNV { flags: 0b1 }; - pub const EXPORTABLE_BIT_NV: Self = ExternalMemoryFeatureFlagsNV { flags: 0b10 }; - pub const IMPORTABLE_BIT_NV: Self = ExternalMemoryFeatureFlagsNV { flags: 0b100 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SubgroupFeatureFlags { - flags: Flags, -} -vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); -impl SubgroupFeatureFlags { - pub const BASIC_BIT: Self = SubgroupFeatureFlags { flags: 0b1 }; - pub const VOTE_BIT: Self = SubgroupFeatureFlags { flags: 0b10 }; - pub const ARITHMETIC_BIT: Self = SubgroupFeatureFlags { flags: 0b100 }; - pub const BALLOT_BIT: Self = SubgroupFeatureFlags { flags: 0b1000 }; - pub const SHUFFLE_BIT: Self = SubgroupFeatureFlags { flags: 0b10000 }; - pub const SHUFFLE_RELATIVE_BIT: Self = SubgroupFeatureFlags { flags: 0b100000 }; - pub const CLUSTERED_BIT: Self = SubgroupFeatureFlags { flags: 0b1000000 }; - pub const QUAD_BIT: Self = SubgroupFeatureFlags { flags: 0b10000000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct IndirectCommandsLayoutUsageFlagsNVX { - flags: Flags, -} -vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); -impl IndirectCommandsLayoutUsageFlagsNVX { - pub const UNORDERED_SEQUENCES_BIT_NVX: Self = - IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1 }; - pub const SPARSE_SEQUENCES_BIT_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b10 }; - pub const EMPTY_EXECUTIONS_BIT_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX { flags: 0b100 }; - pub const INDEXED_SEQUENCES_BIT_NVX: Self = - IndirectCommandsLayoutUsageFlagsNVX { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ObjectEntryUsageFlagsNVX { - flags: Flags, -} -vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); -impl ObjectEntryUsageFlagsNVX { - pub const GRAPHICS_BIT_NVX: Self = ObjectEntryUsageFlagsNVX { flags: 0b1 }; - pub const COMPUTE_BIT_NVX: Self = ObjectEntryUsageFlagsNVX { flags: 0b10 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DescriptorSetLayoutCreateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); -impl DescriptorSetLayoutCreateFlags {} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalMemoryHandleTypeFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); -impl ExternalMemoryHandleTypeFlags { - pub const OPAQUE_FD_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b1 }; - pub const OPAQUE_WIN32_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b10 }; - pub const OPAQUE_WIN32_KMT_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b100 }; - pub const D3D11_TEXTURE_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b1000 }; - pub const D3D11_TEXTURE_KMT_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b10000 }; - pub const D3D12_HEAP_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b100000 }; - pub const D3D12_RESOURCE_BIT: Self = ExternalMemoryHandleTypeFlags { flags: 0b1000000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalMemoryFeatureFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); -impl ExternalMemoryFeatureFlags { - pub const DEDICATED_ONLY_BIT: Self = ExternalMemoryFeatureFlags { flags: 0b1 }; - pub const EXPORTABLE_BIT: Self = ExternalMemoryFeatureFlags { flags: 0b10 }; - pub const IMPORTABLE_BIT: Self = ExternalMemoryFeatureFlags { flags: 0b100 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalSemaphoreHandleTypeFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); -impl ExternalSemaphoreHandleTypeFlags { - pub const OPAQUE_FD_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b1 }; - pub const OPAQUE_WIN32_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b10 }; - pub const OPAQUE_WIN32_KMT_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b100 }; - pub const D3D12_FENCE_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b1000 }; - pub const SYNC_FD_BIT: Self = ExternalSemaphoreHandleTypeFlags { flags: 0b10000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalSemaphoreFeatureFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); -impl ExternalSemaphoreFeatureFlags { - pub const EXPORTABLE_BIT: Self = ExternalSemaphoreFeatureFlags { flags: 0b1 }; - pub const IMPORTABLE_BIT: Self = ExternalSemaphoreFeatureFlags { flags: 0b10 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SemaphoreImportFlags { - flags: Flags, -} -vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); -impl SemaphoreImportFlags { - pub const TEMPORARY_BIT: Self = SemaphoreImportFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalFenceHandleTypeFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); -impl ExternalFenceHandleTypeFlags { - pub const OPAQUE_FD_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b1 }; - pub const OPAQUE_WIN32_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b10 }; - pub const OPAQUE_WIN32_KMT_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b100 }; - pub const SYNC_FD_BIT: Self = ExternalFenceHandleTypeFlags { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExternalFenceFeatureFlags { - flags: Flags, -} -vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); -impl ExternalFenceFeatureFlags { - pub const EXPORTABLE_BIT: Self = ExternalFenceFeatureFlags { flags: 0b1 }; - pub const IMPORTABLE_BIT: Self = ExternalFenceFeatureFlags { flags: 0b10 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct FenceImportFlags { - flags: Flags, -} -vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); -impl FenceImportFlags { - pub const TEMPORARY_BIT: Self = FenceImportFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SurfaceCounterFlagsEXT { - flags: Flags, -} -vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); -impl SurfaceCounterFlagsEXT { - pub const VBLANK_EXT: Self = SurfaceCounterFlagsEXT { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PeerMemoryFeatureFlags { - flags: Flags, -} -vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); -impl PeerMemoryFeatureFlags { - pub const COPY_SRC_BIT: Self = PeerMemoryFeatureFlags { flags: 0b1 }; - pub const COPY_DST_BIT: Self = PeerMemoryFeatureFlags { flags: 0b10 }; - pub const GENERIC_SRC_BIT: Self = PeerMemoryFeatureFlags { flags: 0b100 }; - pub const GENERIC_DST_BIT: Self = PeerMemoryFeatureFlags { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct MemoryAllocateFlags { - flags: Flags, -} -vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); -impl MemoryAllocateFlags { - pub const DEVICE_MASK_BIT: Self = MemoryAllocateFlags { flags: 0b1 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DeviceGroupPresentModeFlagsKHR { - flags: Flags, -} -vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); -impl DeviceGroupPresentModeFlagsKHR { - pub const LOCAL_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b1 }; - pub const REMOTE_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b10 }; - pub const SUM_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b100 }; - pub const LOCAL_MULTI_DEVICE_BIT_KHR: Self = DeviceGroupPresentModeFlagsKHR { flags: 0b1000 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SwapchainCreateFlagsKHR { - flags: Flags, -} -vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); -impl SwapchainCreateFlagsKHR {} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SubpassDescriptionFlags { - flags: Flags, -} -vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); -impl SubpassDescriptionFlags {} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DebugUtilsMessageSeverityFlagsEXT { - flags: Flags, -} -vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); -impl DebugUtilsMessageSeverityFlagsEXT { - pub const VERBOSE_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { flags: 0b1 }; - pub const INFO_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { flags: 0b10000 }; - pub const WARNING_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { flags: 0b100000000 }; - pub const ERROR_BIT_EXT: Self = DebugUtilsMessageSeverityFlagsEXT { - flags: 0b1000000000000, - }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DebugUtilsMessageTypeFlagsEXT { - flags: Flags, -} -vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); -impl DebugUtilsMessageTypeFlagsEXT { - pub const GENERAL_BIT_EXT: Self = DebugUtilsMessageTypeFlagsEXT { flags: 0b1 }; - pub const VALIDATION_BIT_EXT: Self = DebugUtilsMessageTypeFlagsEXT { flags: 0b10 }; - pub const PERFORMANCE_BIT_EXT: Self = DebugUtilsMessageTypeFlagsEXT { flags: 0b100 }; -} -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DescriptorBindingFlagsEXT { - flags: Flags, -} -vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); -impl DescriptorBindingFlagsEXT { - pub const UPDATE_AFTER_BIND_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b1 }; - pub const UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b10 }; - pub const PARTIALLY_BOUND_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b100 }; - pub const VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: Self = DescriptorBindingFlagsEXT { flags: 0b1000 }; +pub struct VendorId(pub(crate) i32); +impl VendorId { + #[doc = "Vivante vendor ID"] + pub const VIV: Self = VendorId(0x10001); + #[doc = "VeriSilicon vendor ID"] + pub const VSI: Self = VendorId(0x10002); + #[doc = "Kazan Software Renderer"] + pub const KAZAN: Self = VendorId(0x10003); +} +pub mod bitflags { + use super::*; + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct CullModeFlags(pub(crate) Flags); + vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); + impl CullModeFlags { + pub const NONE: Self = CullModeFlags(0); + pub const FRONT: Self = CullModeFlags(0b1); + pub const BACK: Self = CullModeFlags(0b10); + pub const FRONT_AND_BACK: Self = CullModeFlags(0x00000003); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct QueueFlags(pub(crate) Flags); + vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); + impl QueueFlags { + #[doc = "Queue supports graphics operations"] + pub const GRAPHICS: Self = QueueFlags(0b1); + #[doc = "Queue supports compute operations"] + pub const COMPUTE: Self = QueueFlags(0b10); + #[doc = "Queue supports transfer operations"] + pub const TRANSFER: Self = QueueFlags(0b100); + #[doc = "Queue supports sparse resource memory management operations"] + pub const SPARSE_BINDING: Self = QueueFlags(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DeviceQueueCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); + impl DeviceQueueCreateFlags {} + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct MemoryPropertyFlags(pub(crate) Flags); + vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); + impl MemoryPropertyFlags { + #[doc = "If otherwise stated, then allocate memory on device"] + pub const DEVICE_LOCAL: Self = MemoryPropertyFlags(0b1); + #[doc = "Memory is mappable by host"] + pub const HOST_VISIBLE: Self = MemoryPropertyFlags(0b10); + #[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"] + pub const HOST_COHERENT: Self = MemoryPropertyFlags(0b100); + #[doc = "Memory will be cached by the host"] + pub const HOST_CACHED: Self = MemoryPropertyFlags(0b1000); + #[doc = "Memory may be allocated by the driver when it is required"] + pub const LAZILY_ALLOCATED: Self = MemoryPropertyFlags(0b10000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct MemoryHeapFlags(pub(crate) Flags); + vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); + impl MemoryHeapFlags { + #[doc = "If set, heap represents device memory"] + pub const DEVICE_LOCAL: Self = MemoryHeapFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct AccessFlags(pub(crate) Flags); + vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); + impl AccessFlags { + #[doc = "Controls coherency of indirect command reads"] + pub const INDIRECT_COMMAND_READ: Self = AccessFlags(0b1); + #[doc = "Controls coherency of index reads"] + pub const INDEX_READ: Self = AccessFlags(0b10); + #[doc = "Controls coherency of vertex attribute reads"] + pub const VERTEX_ATTRIBUTE_READ: Self = AccessFlags(0b100); + #[doc = "Controls coherency of uniform buffer reads"] + pub const UNIFORM_READ: Self = AccessFlags(0b1000); + #[doc = "Controls coherency of input attachment reads"] + pub const INPUT_ATTACHMENT_READ: Self = AccessFlags(0b10000); + #[doc = "Controls coherency of shader reads"] + pub const SHADER_READ: Self = AccessFlags(0b100000); + #[doc = "Controls coherency of shader writes"] + pub const SHADER_WRITE: Self = AccessFlags(0b1000000); + #[doc = "Controls coherency of color attachment reads"] + pub const COLOR_ATTACHMENT_READ: Self = AccessFlags(0b10000000); + #[doc = "Controls coherency of color attachment writes"] + pub const COLOR_ATTACHMENT_WRITE: Self = AccessFlags(0b100000000); + #[doc = "Controls coherency of depth/stencil attachment reads"] + pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = AccessFlags(0b1000000000); + #[doc = "Controls coherency of depth/stencil attachment writes"] + pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = AccessFlags(0b10000000000); + #[doc = "Controls coherency of transfer reads"] + pub const TRANSFER_READ: Self = AccessFlags(0b100000000000); + #[doc = "Controls coherency of transfer writes"] + pub const TRANSFER_WRITE: Self = AccessFlags(0b1000000000000); + #[doc = "Controls coherency of host reads"] + pub const HOST_READ: Self = AccessFlags(0b10000000000000); + #[doc = "Controls coherency of host writes"] + pub const HOST_WRITE: Self = AccessFlags(0b100000000000000); + #[doc = "Controls coherency of memory reads"] + pub const MEMORY_READ: Self = AccessFlags(0b1000000000000000); + #[doc = "Controls coherency of memory writes"] + pub const MEMORY_WRITE: Self = AccessFlags(0b10000000000000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct BufferUsageFlags(pub(crate) Flags); + vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); + impl BufferUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = BufferUsageFlags(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = BufferUsageFlags(0b10); + #[doc = "Can be used as TBO"] + pub const UNIFORM_TEXEL_BUFFER: Self = BufferUsageFlags(0b100); + #[doc = "Can be used as IBO"] + pub const STORAGE_TEXEL_BUFFER: Self = BufferUsageFlags(0b1000); + #[doc = "Can be used as UBO"] + pub const UNIFORM_BUFFER: Self = BufferUsageFlags(0b10000); + #[doc = "Can be used as SSBO"] + pub const STORAGE_BUFFER: Self = BufferUsageFlags(0b100000); + #[doc = "Can be used as source of fixed-function index fetch (index buffer)"] + pub const INDEX_BUFFER: Self = BufferUsageFlags(0b1000000); + #[doc = "Can be used as source of fixed-function vertex fetch (VBO)"] + pub const VERTEX_BUFFER: Self = BufferUsageFlags(0b10000000); + #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"] + pub const INDIRECT_BUFFER: Self = BufferUsageFlags(0b100000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct BufferCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); + impl BufferCreateFlags { + #[doc = "Buffer should support sparse backing"] + pub const SPARSE_BINDING: Self = BufferCreateFlags(0b1); + #[doc = "Buffer should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = BufferCreateFlags(0b10); + #[doc = "Buffer should support constent data access to physical memory ranges mapped into multiple locations of sparse buffers"] + pub const SPARSE_ALIASED: Self = BufferCreateFlags(0b100); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ShaderStageFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); + impl ShaderStageFlags { + pub const VERTEX: Self = ShaderStageFlags(0b1); + pub const TESSELLATION_CONTROL: Self = ShaderStageFlags(0b10); + pub const TESSELLATION_EVALUATION: Self = ShaderStageFlags(0b100); + pub const GEOMETRY: Self = ShaderStageFlags(0b1000); + pub const FRAGMENT: Self = ShaderStageFlags(0b10000); + pub const COMPUTE: Self = ShaderStageFlags(0b100000); + pub const ALL_GRAPHICS: Self = ShaderStageFlags(0x0000001F); + pub const ALL: Self = ShaderStageFlags(0x7FFFFFFF); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ImageUsageFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); + impl ImageUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = ImageUsageFlags(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = ImageUsageFlags(0b10); + #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED: Self = ImageUsageFlags(0b100); + #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"] + pub const STORAGE: Self = ImageUsageFlags(0b1000); + #[doc = "Can be used as framebuffer color attachment"] + pub const COLOR_ATTACHMENT: Self = ImageUsageFlags(0b10000); + #[doc = "Can be used as framebuffer depth/stencil attachment"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = ImageUsageFlags(0b100000); + #[doc = "Image data not needed outside of rendering"] + pub const TRANSIENT_ATTACHMENT: Self = ImageUsageFlags(0b1000000); + #[doc = "Can be used as framebuffer input attachment"] + pub const INPUT_ATTACHMENT: Self = ImageUsageFlags(0b10000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ImageCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); + impl ImageCreateFlags { + #[doc = "Image should support sparse backing"] + pub const SPARSE_BINDING: Self = ImageCreateFlags(0b1); + #[doc = "Image should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = ImageCreateFlags(0b10); + #[doc = "Image should support constent data access to physical memory ranges mapped into multiple locations of sparse images"] + pub const SPARSE_ALIASED: Self = ImageCreateFlags(0b100); + #[doc = "Allows image views to have different format than the base image"] + pub const MUTABLE_FORMAT: Self = ImageCreateFlags(0b1000); + #[doc = "Allows creating image views with cube type from the created image"] + pub const CUBE_COMPATIBLE: Self = ImageCreateFlags(0b10000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct PipelineCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); + impl PipelineCreateFlags { + pub const DISABLE_OPTIMIZATION: Self = PipelineCreateFlags(0b1); + pub const ALLOW_DERIVATIVES: Self = PipelineCreateFlags(0b10); + pub const DERIVATIVE: Self = PipelineCreateFlags(0b100); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ColorComponentFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); + impl ColorComponentFlags { + pub const R: Self = ColorComponentFlags(0b1); + pub const G: Self = ColorComponentFlags(0b10); + pub const B: Self = ColorComponentFlags(0b100); + pub const A: Self = ColorComponentFlags(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct FenceCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); + impl FenceCreateFlags { + pub const SIGNALED: Self = FenceCreateFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct FormatFeatureFlags(pub(crate) Flags); + vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); + impl FormatFeatureFlags { + #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED_IMAGE: Self = FormatFeatureFlags(0b1); + #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] + pub const STORAGE_IMAGE: Self = FormatFeatureFlags(0b10); + #[doc = "Format supports atomic operations in case it is used for storage images"] + pub const STORAGE_IMAGE_ATOMIC: Self = FormatFeatureFlags(0b100); + #[doc = "Format can be used for uniform texel buffers (TBOs)"] + pub const UNIFORM_TEXEL_BUFFER: Self = FormatFeatureFlags(0b1000); + #[doc = "Format can be used for storage texel buffers (IBOs)"] + pub const STORAGE_TEXEL_BUFFER: Self = FormatFeatureFlags(0b10000); + #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] + pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = FormatFeatureFlags(0b100000); + #[doc = "Format can be used for vertex buffers (VBOs)"] + pub const VERTEX_BUFFER: Self = FormatFeatureFlags(0b1000000); + #[doc = "Format can be used for color attachment images"] + pub const COLOR_ATTACHMENT: Self = FormatFeatureFlags(0b10000000); + #[doc = "Format supports blending in case it is used for color attachment images"] + pub const COLOR_ATTACHMENT_BLEND: Self = FormatFeatureFlags(0b100000000); + #[doc = "Format can be used for depth/stencil attachment images"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = FormatFeatureFlags(0b1000000000); + #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] + pub const BLIT_SRC: Self = FormatFeatureFlags(0b10000000000); + #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] + pub const BLIT_DST: Self = FormatFeatureFlags(0b100000000000); + #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] + pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = FormatFeatureFlags(0b1000000000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct QueryControlFlags(pub(crate) Flags); + vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); + impl QueryControlFlags { + #[doc = "Require precise results to be collected by the query"] + pub const PRECISE: Self = QueryControlFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct QueryResultFlags(pub(crate) Flags); + vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); + impl QueryResultFlags { + #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] + pub const TYPE_64: Self = QueryResultFlags(0b1); + #[doc = "Results of the queries are waited on before proceeding with the result copy"] + pub const WAIT: Self = QueryResultFlags(0b10); + #[doc = "Besides the results of the query, the availability of the results is also written"] + pub const WITH_AVAILABILITY: Self = QueryResultFlags(0b100); + #[doc = "Copy the partial results of the query even if the final results are not available"] + pub const PARTIAL: Self = QueryResultFlags(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct CommandBufferUsageFlags(pub(crate) Flags); + vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); + impl CommandBufferUsageFlags { + pub const ONE_TIME_SUBMIT: Self = CommandBufferUsageFlags(0b1); + pub const RENDER_PASS_CONTINUE: Self = CommandBufferUsageFlags(0b10); + #[doc = "Command buffer may be submitted/executed more than once simultaneously"] + pub const SIMULTANEOUS_USE: Self = CommandBufferUsageFlags(0b100); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct QueryPipelineStatisticFlags(pub(crate) Flags); + vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); + impl QueryPipelineStatisticFlags { + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_VERTICES: Self = QueryPipelineStatisticFlags(0b1); + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10); + #[doc = "Optional"] + pub const VERTEX_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b1000); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10000); + #[doc = "Optional"] + pub const CLIPPING_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100000); + #[doc = "Optional"] + pub const CLIPPING_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b1000000); + #[doc = "Optional"] + pub const FRAGMENT_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10000000); + #[doc = "Optional"] + pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = + QueryPipelineStatisticFlags(0b100000000); + #[doc = "Optional"] + pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = + QueryPipelineStatisticFlags(0b1000000000); + #[doc = "Optional"] + pub const COMPUTE_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10000000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ImageAspectFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); + impl ImageAspectFlags { + pub const COLOR: Self = ImageAspectFlags(0b1); + pub const DEPTH: Self = ImageAspectFlags(0b10); + pub const STENCIL: Self = ImageAspectFlags(0b100); + pub const METADATA: Self = ImageAspectFlags(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SparseImageFormatFlags(pub(crate) Flags); + vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); + impl SparseImageFormatFlags { + #[doc = "Image uses a single mip tail region for all array layers"] + pub const SINGLE_MIPTAIL: Self = SparseImageFormatFlags(0b1); + #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] + pub const ALIGNED_MIP_SIZE: Self = SparseImageFormatFlags(0b10); + #[doc = "Image uses a non-standard sparse image block dimensions"] + pub const NONSTANDARD_BLOCK_SIZE: Self = SparseImageFormatFlags(0b100); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SparseMemoryBindFlags(pub(crate) Flags); + vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); + impl SparseMemoryBindFlags { + #[doc = "Operation binds resource metadata to memory"] + pub const METADATA: Self = SparseMemoryBindFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct PipelineStageFlags(pub(crate) Flags); + vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); + impl PipelineStageFlags { + #[doc = "Before subsequent commands are processed"] + pub const TOP_OF_PIPE: Self = PipelineStageFlags(0b1); + #[doc = "Draw/DispatchIndirect command fetch"] + pub const DRAW_INDIRECT: Self = PipelineStageFlags(0b10); + #[doc = "Vertex/index fetch"] + pub const VERTEX_INPUT: Self = PipelineStageFlags(0b100); + #[doc = "Vertex shading"] + pub const VERTEX_SHADER: Self = PipelineStageFlags(0b1000); + #[doc = "Tessellation control shading"] + pub const TESSELLATION_CONTROL_SHADER: Self = PipelineStageFlags(0b10000); + #[doc = "Tessellation evaluation shading"] + pub const TESSELLATION_EVALUATION_SHADER: Self = PipelineStageFlags(0b100000); + #[doc = "Geometry shading"] + pub const GEOMETRY_SHADER: Self = PipelineStageFlags(0b1000000); + #[doc = "Fragment shading"] + pub const FRAGMENT_SHADER: Self = PipelineStageFlags(0b10000000); + #[doc = "Early fragment (depth and stencil) tests"] + pub const EARLY_FRAGMENT_TESTS: Self = PipelineStageFlags(0b100000000); + #[doc = "Late fragment (depth and stencil) tests"] + pub const LATE_FRAGMENT_TESTS: Self = PipelineStageFlags(0b1000000000); + #[doc = "Color attachment writes"] + pub const COLOR_ATTACHMENT_OUTPUT: Self = PipelineStageFlags(0b10000000000); + #[doc = "Compute shading"] + pub const COMPUTE_SHADER: Self = PipelineStageFlags(0b100000000000); + #[doc = "Transfer/copy operations"] + pub const TRANSFER: Self = PipelineStageFlags(0b1000000000000); + #[doc = "After previous commands have completed"] + pub const BOTTOM_OF_PIPE: Self = PipelineStageFlags(0b10000000000000); + #[doc = "Indicates host (CPU) is a source/sink of the dependency"] + pub const HOST: Self = PipelineStageFlags(0b100000000000000); + #[doc = "All stages of the graphics pipeline"] + pub const ALL_GRAPHICS: Self = PipelineStageFlags(0b1000000000000000); + #[doc = "All stages supported on the queue"] + pub const ALL_COMMANDS: Self = PipelineStageFlags(0b10000000000000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct CommandPoolCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); + impl CommandPoolCreateFlags { + #[doc = "Command buffers have a short lifetime"] + pub const TRANSIENT: Self = CommandPoolCreateFlags(0b1); + #[doc = "Command buffers may release their memory individually"] + pub const RESET_COMMAND_BUFFER: Self = CommandPoolCreateFlags(0b10); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct CommandPoolResetFlags(pub(crate) Flags); + vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); + impl CommandPoolResetFlags { + #[doc = "Release resources owned by the pool"] + pub const RELEASE_RESOURCES: Self = CommandPoolResetFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct CommandBufferResetFlags(pub(crate) Flags); + vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); + impl CommandBufferResetFlags { + #[doc = "Release resources owned by the buffer"] + pub const RELEASE_RESOURCES: Self = CommandBufferResetFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SampleCountFlags(pub(crate) Flags); + vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); + impl SampleCountFlags { + #[doc = "Sample count 1 supported"] + pub const TYPE_1: Self = SampleCountFlags(0b1); + #[doc = "Sample count 2 supported"] + pub const TYPE_2: Self = SampleCountFlags(0b10); + #[doc = "Sample count 4 supported"] + pub const TYPE_4: Self = SampleCountFlags(0b100); + #[doc = "Sample count 8 supported"] + pub const TYPE_8: Self = SampleCountFlags(0b1000); + #[doc = "Sample count 16 supported"] + pub const TYPE_16: Self = SampleCountFlags(0b10000); + #[doc = "Sample count 32 supported"] + pub const TYPE_32: Self = SampleCountFlags(0b100000); + #[doc = "Sample count 64 supported"] + pub const TYPE_64: Self = SampleCountFlags(0b1000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct AttachmentDescriptionFlags(pub(crate) Flags); + vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); + impl AttachmentDescriptionFlags { + #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] + pub const MAY_ALIAS: Self = AttachmentDescriptionFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct StencilFaceFlags(pub(crate) Flags); + vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); + impl StencilFaceFlags { + #[doc = "Front face"] + pub const FRONT: Self = StencilFaceFlags(0b1); + #[doc = "Back face"] + pub const BACK: Self = StencilFaceFlags(0b10); + #[doc = "Front and back faces"] + pub const STENCIL_FRONT_AND_BACK: Self = StencilFaceFlags(0x00000003); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DescriptorPoolCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); + impl DescriptorPoolCreateFlags { + #[doc = "Descriptor sets may be freed individually"] + pub const FREE_DESCRIPTOR_SET: Self = DescriptorPoolCreateFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DependencyFlags(pub(crate) Flags); + vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); + impl DependencyFlags { + #[doc = "Dependency is per pixel region "] + pub const BY_REGION: Self = DependencyFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); + vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); + impl DisplayPlaneAlphaFlagsKHR { + pub const OPAQUE_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b1); + pub const GLOBAL_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b10); + pub const PER_PIXEL_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b100); + pub const PER_PIXEL_PREMULTIPLIED_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); + vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); + impl CompositeAlphaFlagsKHR { + pub const OPAQUE_KHR: Self = CompositeAlphaFlagsKHR(0b1); + pub const PRE_MULTIPLIED_KHR: Self = CompositeAlphaFlagsKHR(0b10); + pub const POST_MULTIPLIED_KHR: Self = CompositeAlphaFlagsKHR(0b100); + pub const INHERIT_KHR: Self = CompositeAlphaFlagsKHR(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); + vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); + impl SurfaceTransformFlagsKHR { + pub const IDENTITY_KHR: Self = SurfaceTransformFlagsKHR(0b1); + pub const ROTATE_90_KHR: Self = SurfaceTransformFlagsKHR(0b10); + pub const ROTATE_180_KHR: Self = SurfaceTransformFlagsKHR(0b100); + pub const ROTATE_270_KHR: Self = SurfaceTransformFlagsKHR(0b1000); + pub const HORIZONTAL_MIRROR_KHR: Self = SurfaceTransformFlagsKHR(0b10000); + pub const HORIZONTAL_MIRROR_ROTATE_90_KHR: Self = SurfaceTransformFlagsKHR(0b100000); + pub const HORIZONTAL_MIRROR_ROTATE_180_KHR: Self = SurfaceTransformFlagsKHR(0b1000000); + pub const HORIZONTAL_MIRROR_ROTATE_270_KHR: Self = SurfaceTransformFlagsKHR(0b10000000); + pub const INHERIT_KHR: Self = SurfaceTransformFlagsKHR(0b100000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DebugReportFlagsEXT(pub(crate) Flags); + vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); + impl DebugReportFlagsEXT { + pub const INFORMATION_EXT: Self = DebugReportFlagsEXT(0b1); + pub const WARNING_EXT: Self = DebugReportFlagsEXT(0b10); + pub const PERFORMANCE_WARNING_EXT: Self = DebugReportFlagsEXT(0b100); + pub const ERROR_EXT: Self = DebugReportFlagsEXT(0b1000); + pub const DEBUG_EXT: Self = DebugReportFlagsEXT(0b10000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); + impl ExternalMemoryHandleTypeFlagsNV { + pub const OPAQUE_WIN32_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b1); + pub const OPAQUE_WIN32_KMT_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b10); + pub const D3D11_IMAGE_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b100); + pub const D3D11_IMAGE_KMT_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); + impl ExternalMemoryFeatureFlagsNV { + pub const DEDICATED_ONLY_NV: Self = ExternalMemoryFeatureFlagsNV(0b1); + pub const EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10); + pub const IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SubgroupFeatureFlags(pub(crate) Flags); + vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); + impl SubgroupFeatureFlags { + #[doc = "Basic subgroup operations"] + pub const BASIC: Self = SubgroupFeatureFlags(0b1); + #[doc = "Vote subgroup operations"] + pub const VOTE: Self = SubgroupFeatureFlags(0b10); + #[doc = "Arithmetic subgroup operations"] + pub const ARITHMETIC: Self = SubgroupFeatureFlags(0b100); + #[doc = "Ballot subgroup operations"] + pub const BALLOT: Self = SubgroupFeatureFlags(0b1000); + #[doc = "Shuffle subgroup operations"] + pub const SHUFFLE: Self = SubgroupFeatureFlags(0b10000); + #[doc = "Shuffle relative subgroup operations"] + pub const SHUFFLE_RELATIVE: Self = SubgroupFeatureFlags(0b100000); + #[doc = "Clustered subgroup operations"] + pub const CLUSTERED: Self = SubgroupFeatureFlags(0b1000000); + #[doc = "Quad subgroup operations"] + pub const QUAD: Self = SubgroupFeatureFlags(0b10000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct IndirectCommandsLayoutUsageFlagsNVX(pub(crate) Flags); + vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); + impl IndirectCommandsLayoutUsageFlagsNVX { + pub const UNORDERED_SEQUENCES_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1); + pub const SPARSE_SEQUENCES_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b10); + pub const EMPTY_EXECUTIONS_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b100); + pub const INDEXED_SEQUENCES_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ObjectEntryUsageFlagsNVX(pub(crate) Flags); + vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); + impl ObjectEntryUsageFlagsNVX { + pub const GRAPHICS_NVX: Self = ObjectEntryUsageFlagsNVX(0b1); + pub const COMPUTE_NVX: Self = ObjectEntryUsageFlagsNVX(0b10); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); + impl DescriptorSetLayoutCreateFlags {} + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); + impl ExternalMemoryHandleTypeFlags { + pub const OPAQUE_FD: Self = ExternalMemoryHandleTypeFlags(0b1); + pub const OPAQUE_WIN32: Self = ExternalMemoryHandleTypeFlags(0b10); + pub const OPAQUE_WIN32_KMT: Self = ExternalMemoryHandleTypeFlags(0b100); + pub const D3D11_TEXTURE: Self = ExternalMemoryHandleTypeFlags(0b1000); + pub const D3D11_TEXTURE_KMT: Self = ExternalMemoryHandleTypeFlags(0b10000); + pub const D3D12_HEAP: Self = ExternalMemoryHandleTypeFlags(0b100000); + pub const D3D12_RESOURCE: Self = ExternalMemoryHandleTypeFlags(0b1000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); + impl ExternalMemoryFeatureFlags { + pub const DEDICATED_ONLY: Self = ExternalMemoryFeatureFlags(0b1); + pub const EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10); + pub const IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); + impl ExternalSemaphoreHandleTypeFlags { + pub const OPAQUE_FD: Self = ExternalSemaphoreHandleTypeFlags(0b1); + pub const OPAQUE_WIN32: Self = ExternalSemaphoreHandleTypeFlags(0b10); + pub const OPAQUE_WIN32_KMT: Self = ExternalSemaphoreHandleTypeFlags(0b100); + pub const D3D12_FENCE: Self = ExternalSemaphoreHandleTypeFlags(0b1000); + pub const SYNC_FD: Self = ExternalSemaphoreHandleTypeFlags(0b10000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); + impl ExternalSemaphoreFeatureFlags { + pub const EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1); + pub const IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SemaphoreImportFlags(pub(crate) Flags); + vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); + impl SemaphoreImportFlags { + pub const TEMPORARY: Self = SemaphoreImportFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); + impl ExternalFenceHandleTypeFlags { + pub const OPAQUE_FD: Self = ExternalFenceHandleTypeFlags(0b1); + pub const OPAQUE_WIN32: Self = ExternalFenceHandleTypeFlags(0b10); + pub const OPAQUE_WIN32_KMT: Self = ExternalFenceHandleTypeFlags(0b100); + pub const SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct ExternalFenceFeatureFlags(pub(crate) Flags); + vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); + impl ExternalFenceFeatureFlags { + pub const EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1); + pub const IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct FenceImportFlags(pub(crate) Flags); + vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); + impl FenceImportFlags { + pub const TEMPORARY: Self = FenceImportFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); + vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); + impl SurfaceCounterFlagsEXT { + pub const VBLANK_EXT: Self = SurfaceCounterFlagsEXT(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct PeerMemoryFeatureFlags(pub(crate) Flags); + vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); + impl PeerMemoryFeatureFlags { + #[doc = "Can read with vkCmdCopy commands"] + pub const COPY_SRC: Self = PeerMemoryFeatureFlags(0b1); + #[doc = "Can write with vkCmdCopy commands"] + pub const COPY_DST: Self = PeerMemoryFeatureFlags(0b10); + #[doc = "Can read with any access type/command"] + pub const GENERIC_SRC: Self = PeerMemoryFeatureFlags(0b100); + #[doc = "Can write with and access type/command"] + pub const GENERIC_DST: Self = PeerMemoryFeatureFlags(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct MemoryAllocateFlags(pub(crate) Flags); + vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); + impl MemoryAllocateFlags { + #[doc = "Force allocation on specific devices"] + pub const DEVICE_MASK: Self = MemoryAllocateFlags(0b1); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); + vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); + impl DeviceGroupPresentModeFlagsKHR { + #[doc = "Present from local memory"] + pub const LOCAL_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b1); + #[doc = "Present from remote memory"] + pub const REMOTE_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b10); + #[doc = "Present sum of local and/or remote memory"] + pub const SUM_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b100); + #[doc = "Each physical device presents from local memory"] + pub const LOCAL_MULTI_DEVICE_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b1000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); + vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); + impl SwapchainCreateFlagsKHR {} + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SubpassDescriptionFlags(pub(crate) Flags); + vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); + impl SubpassDescriptionFlags {} + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); + vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); + impl DebugUtilsMessageSeverityFlagsEXT { + pub const VERBOSE_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b1); + pub const INFO_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b10000); + pub const WARNING_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b100000000); + pub const ERROR_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b1000000000000); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); + vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); + impl DebugUtilsMessageTypeFlagsEXT { + pub const GENERAL_EXT: Self = DebugUtilsMessageTypeFlagsEXT(0b1); + pub const VALIDATION_EXT: Self = DebugUtilsMessageTypeFlagsEXT(0b10); + pub const PERFORMANCE_EXT: Self = DebugUtilsMessageTypeFlagsEXT(0b100); + } + #[repr(C)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct DescriptorBindingFlagsEXT(pub(crate) Flags); + vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); + impl DescriptorBindingFlagsEXT { + pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorBindingFlagsEXT(0b1); + pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = DescriptorBindingFlagsEXT(0b10); + pub const PARTIALLY_BOUND_EXT: Self = DescriptorBindingFlagsEXT(0b100); + pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = DescriptorBindingFlagsEXT(0b1000); + } } pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; pub const VK_UUID_SIZE: usize = 16; @@ -9900,4388 +9895,6805 @@ pub const VK_QUEUE_FAMILY_EXTERNAL: u32 = !0 - 1; pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = !0 - 2; pub const VK_SUBPASS_EXTERNAL: u32 = !0; pub const VK_MAX_DEVICE_GROUP_SIZE: usize = 32; -pub struct KhrSurfaceFn { - destroy_surface_khr: extern "system" fn( - instance: Instance, - surface: SurfaceKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - get_physical_device_surface_support_khr: extern "system" fn( - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - surface: SurfaceKHR, - p_supported: *const Bool32, - ) -> Result, - get_physical_device_surface_capabilities_khr: - extern "system" fn( +pub mod extensions { + use super::*; + pub struct KhrSurfaceFn { + destroy_surface_khr: extern "system" fn( + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + get_physical_device_surface_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + surface: SurfaceKHR, + p_supported: *const Bool32, + ) -> Result, + get_physical_device_surface_capabilities_khr: + extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *const SurfaceCapabilitiesKHR, + ) -> Result, + get_physical_device_surface_formats_khr: + extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_format_count: *const uint32_t, + p_surface_formats: *const SurfaceFormatKHR, + ) -> Result, + get_physical_device_surface_present_modes_khr: + extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_present_mode_count: *const uint32_t, + p_present_modes: *const PresentModeKHR, + ) -> Result, + } + unsafe impl Send for KhrSurfaceFn {} + unsafe impl Sync for KhrSurfaceFn {} + impl ::std::clone::Clone for KhrSurfaceFn { + fn clone(&self) -> Self { + KhrSurfaceFn { + destroy_surface_khr: self.destroy_surface_khr, + get_physical_device_surface_support_khr: self + .get_physical_device_surface_support_khr, + get_physical_device_surface_capabilities_khr: self + .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_formats_khr: self + .get_physical_device_surface_formats_khr, + get_physical_device_surface_present_modes_khr: self + .get_physical_device_surface_present_modes_khr, + } + } + } + impl KhrSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSurfaceFn { + destroy_surface_khr: unsafe { + let raw_name = stringify!(vkDestroySurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_formats_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn destroy_surface_khr( + &self, + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_surface_khr)(instance, surface, p_allocator) + } + pub unsafe fn get_physical_device_surface_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + surface: SurfaceKHR, + p_supported: *const Bool32, + ) -> Result { + (self.get_physical_device_surface_support_khr)( + physical_device, + queue_family_index, + surface, + p_supported, + ) + } + pub unsafe fn get_physical_device_surface_capabilities_khr( + &self, physical_device: PhysicalDevice, surface: SurfaceKHR, p_surface_capabilities: *const SurfaceCapabilitiesKHR, - ) -> Result, - get_physical_device_surface_formats_khr: - extern "system" fn( + ) -> Result { + (self.get_physical_device_surface_capabilities_khr)( + physical_device, + surface, + p_surface_capabilities, + ) + } + pub unsafe fn get_physical_device_surface_formats_khr( + &self, physical_device: PhysicalDevice, surface: SurfaceKHR, p_surface_format_count: *const uint32_t, p_surface_formats: *const SurfaceFormatKHR, - ) -> Result, - get_physical_device_surface_present_modes_khr: - extern "system" fn( + ) -> Result { + (self.get_physical_device_surface_formats_khr)( + physical_device, + surface, + p_surface_format_count, + p_surface_formats, + ) + } + pub unsafe fn get_physical_device_surface_present_modes_khr( + &self, physical_device: PhysicalDevice, surface: SurfaceKHR, p_present_mode_count: *const uint32_t, p_present_modes: *const PresentModeKHR, + ) -> Result { + (self.get_physical_device_surface_present_modes_khr)( + physical_device, + surface, + p_present_mode_count, + p_present_modes, + ) + } + } + #[doc = "Generated from \'VK_KHR_surface\'"] + impl Result { + pub const ERROR_SURFACE_LOST_KHR: Self = Result(1000000000); + } + #[doc = "Generated from \'VK_KHR_surface\'"] + impl Result { + pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Result(1000000001); + } + #[doc = "Generated from \'VK_KHR_surface\'"] + impl ObjectType { + pub const SURFACE_KHR: Self = ObjectType(1000000000); + } + pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *const SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *const uint32_t , p_swapchain_images : *const Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : uint64_t , semaphore : Semaphore , fence : Fence , p_image_index : *const uint32_t , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } + unsafe impl Send for KhrSwapchainFn {} + unsafe impl Sync for KhrSwapchainFn {} + impl ::std::clone::Clone for KhrSwapchainFn { + fn clone(&self) -> Self { + KhrSwapchainFn { + create_swapchain_khr: self.create_swapchain_khr, + destroy_swapchain_khr: self.destroy_swapchain_khr, + get_swapchain_images_khr: self.get_swapchain_images_khr, + acquire_next_image_khr: self.acquire_next_image_khr, + queue_present_khr: self.queue_present_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, + acquire_next_image2_khr: self.acquire_next_image2_khr, + } + } + } + impl KhrSwapchainFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSwapchainFn { + create_swapchain_khr: unsafe { + let raw_name = stringify!(vkCreateSwapchainKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_swapchain_khr: unsafe { + let raw_name = stringify!(vkDestroySwapchainKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_swapchain_images_khr: unsafe { + let raw_name = stringify!(vkGetSwapchainImagesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImageKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_present_khr: unsafe { + let raw_name = stringify!(vkQueuePresentKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_present_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_present_rectangles_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image2_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_swapchain_khr( + &self, + device: Device, + p_create_info: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchain: *const SwapchainKHR, + ) -> Result { + (self.create_swapchain_khr)(device, p_create_info, p_allocator, p_swapchain) + } + pub unsafe fn destroy_swapchain_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_swapchain_khr)(device, swapchain, p_allocator) + } + pub unsafe fn get_swapchain_images_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + p_swapchain_image_count: *const uint32_t, + p_swapchain_images: *const Image, + ) -> Result { + (self.get_swapchain_images_khr)( + device, + swapchain, + p_swapchain_image_count, + p_swapchain_images, + ) + } + pub unsafe fn acquire_next_image_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + timeout: uint64_t, + semaphore: Semaphore, + fence: Fence, + p_image_index: *const uint32_t, + ) -> Result { + (self.acquire_next_image_khr)( + device, + swapchain, + timeout, + semaphore, + fence, + p_image_index, + ) + } + pub unsafe fn queue_present_khr( + &self, + queue: Queue, + p_present_info: *const PresentInfoKHR, + ) -> Result { + (self.queue_present_khr)(queue, p_present_info) + } + pub unsafe fn get_device_group_present_capabilities_khr( + &self, + device: Device, + p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + (self.get_device_group_present_capabilities_khr)( + device, + p_device_group_present_capabilities, + ) + } + pub unsafe fn get_device_group_surface_present_modes_khr( + &self, + device: Device, + surface: SurfaceKHR, + p_modes: *const DeviceGroupPresentModeFlagsKHR, + ) -> Result { + (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) + } + pub unsafe fn get_physical_device_present_rectangles_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *const uint32_t, + p_rects: *const Rect2D, + ) -> Result { + (self.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + p_rect_count, + p_rects, + ) + } + pub unsafe fn acquire_next_image2_khr( + &self, + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *const uint32_t, + ) -> Result { + (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) + } + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000001000); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const PRESENT_INFO_KHR: Self = StructureType(1000001001); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl ImageLayout { + pub const PRESENT_SRC_KHR: Self = ImageLayout(1000001002); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl Result { + pub const SUBOPTIMAL_KHR: Self = Result(1000001003); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl Result { + pub const ERROR_OUT_OF_DATE_KHR: Self = Result(1000001004); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl ObjectType { + pub const SWAPCHAIN_KHR: Self = ObjectType(1000001000); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = StructureType(1000060007); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000060008); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = StructureType(1000060009); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = StructureType(1000060010); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = StructureType(1000060011); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl StructureType { + pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000060012); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl SwapchainCreateFlagsKHR { + pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = SwapchainCreateFlagsKHR(0b1); + } + #[doc = "Generated from \'VK_KHR_swapchain\'"] + impl SwapchainCreateFlagsKHR { + pub const PROTECTED_KHR: Self = SwapchainCreateFlagsKHR(0b10); + } + pub struct KhrDisplayFn { + get_physical_device_display_properties_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayPropertiesKHR, + ) -> Result, + get_physical_device_display_plane_properties_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayPlanePropertiesKHR, + ) -> Result, + get_display_plane_supported_displays_khr: + extern "system" fn( + physical_device: PhysicalDevice, + plane_index: uint32_t, + p_display_count: *const uint32_t, + p_displays: *const DisplayKHR, + ) -> Result, + get_display_mode_properties_khr: + extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *const uint32_t, + p_properties: *const DisplayModePropertiesKHR, + ) -> Result, + create_display_mode_khr: extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *const DisplayModeKHR, ) -> Result, -} -unsafe impl Send for KhrSurfaceFn {} -unsafe impl Sync for KhrSurfaceFn {} -impl ::std::clone::Clone for KhrSurfaceFn { - fn clone(&self) -> Self { - KhrSurfaceFn { - destroy_surface_khr: self.destroy_surface_khr, - get_physical_device_surface_support_khr: self.get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: self - .get_physical_device_surface_capabilities_khr, - get_physical_device_surface_formats_khr: self.get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: self - .get_physical_device_surface_present_modes_khr, + get_display_plane_capabilities_khr: + extern "system" fn( + physical_device: PhysicalDevice, + mode: DisplayModeKHR, + plane_index: uint32_t, + p_capabilities: *const DisplayPlaneCapabilitiesKHR, + ) -> Result, + create_display_plane_surface_khr: + extern "system" fn( + instance: Instance, + p_create_info: *const DisplaySurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + } + unsafe impl Send for KhrDisplayFn {} + unsafe impl Sync for KhrDisplayFn {} + impl ::std::clone::Clone for KhrDisplayFn { + fn clone(&self) -> Self { + KhrDisplayFn { + get_physical_device_display_properties_khr: self + .get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: self + .get_physical_device_display_plane_properties_khr, + get_display_plane_supported_displays_khr: self + .get_display_plane_supported_displays_khr, + get_display_mode_properties_khr: self.get_display_mode_properties_khr, + create_display_mode_khr: self.create_display_mode_khr, + get_display_plane_capabilities_khr: self.get_display_plane_capabilities_khr, + create_display_plane_surface_khr: self.create_display_plane_surface_khr, + } } } -} -impl KhrSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSurfaceFn { - destroy_surface_khr: unsafe { - let raw_name = stringify!(vkDestroySurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_formats_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_present_modes_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl KhrDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDisplayFn { + get_physical_device_display_properties_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_display_plane_properties_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_supported_displays_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_mode_properties_khr: unsafe { + let raw_name = stringify!(vkGetDisplayModePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_display_mode_khr: unsafe { + let raw_name = stringify!(vkCreateDisplayModeKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_display_plane_surface_khr: unsafe { + let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } - pub unsafe fn destroy_surface_khr( - &self, - instance: Instance, - surface: SurfaceKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_surface_khr)(instance, surface, p_allocator) - } - pub unsafe fn get_physical_device_surface_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - surface: SurfaceKHR, - p_supported: *const Bool32, - ) -> Result { - (self.get_physical_device_surface_support_khr)( - physical_device, - queue_family_index, - surface, - p_supported, - ) - } - pub unsafe fn get_physical_device_surface_capabilities_khr( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_capabilities: *const SurfaceCapabilitiesKHR, - ) -> Result { - (self.get_physical_device_surface_capabilities_khr)( - physical_device, - surface, - p_surface_capabilities, - ) - } - pub unsafe fn get_physical_device_surface_formats_khr( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_format_count: *const uint32_t, - p_surface_formats: *const SurfaceFormatKHR, - ) -> Result { - (self.get_physical_device_surface_formats_khr)( - physical_device, - surface, - p_surface_format_count, - p_surface_formats, - ) - } - pub unsafe fn get_physical_device_surface_present_modes_khr( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_present_mode_count: *const uint32_t, - p_present_modes: *const PresentModeKHR, - ) -> Result { - (self.get_physical_device_surface_present_modes_khr)( - physical_device, - surface, - p_present_mode_count, - p_present_modes, - ) - } -} -pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *const SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *const uint32_t , p_swapchain_images : *const Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : uint64_t , semaphore : Semaphore , fence : Fence , p_image_index : *const uint32_t , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } -unsafe impl Send for KhrSwapchainFn {} -unsafe impl Sync for KhrSwapchainFn {} -impl ::std::clone::Clone for KhrSwapchainFn { - fn clone(&self) -> Self { - KhrSwapchainFn { - create_swapchain_khr: self.create_swapchain_khr, - destroy_swapchain_khr: self.destroy_swapchain_khr, - get_swapchain_images_khr: self.get_swapchain_images_khr, - acquire_next_image_khr: self.acquire_next_image_khr, - queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, - acquire_next_image2_khr: self.acquire_next_image2_khr, - } - } -} -impl KhrSwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSwapchainFn { - create_swapchain_khr: unsafe { - let raw_name = stringify!(vkCreateSwapchainKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_swapchain_khr: unsafe { - let raw_name = stringify!(vkDestroySwapchainKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_swapchain_images_khr: unsafe { - let raw_name = stringify!(vkGetSwapchainImagesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_next_image_khr: unsafe { - let raw_name = stringify!(vkAcquireNextImageKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_present_khr: unsafe { - let raw_name = stringify!(vkQueuePresentKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_device_group_present_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_device_group_surface_present_modes_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_present_rectangles_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_next_image2_khr: unsafe { - let raw_name = stringify!(vkAcquireNextImage2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_swapchain_khr( - &self, - device: Device, - p_create_info: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchain: *const SwapchainKHR, - ) -> Result { - (self.create_swapchain_khr)(device, p_create_info, p_allocator, p_swapchain) - } - pub unsafe fn destroy_swapchain_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_swapchain_khr)(device, swapchain, p_allocator) - } - pub unsafe fn get_swapchain_images_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - p_swapchain_image_count: *const uint32_t, - p_swapchain_images: *const Image, - ) -> Result { - (self.get_swapchain_images_khr)( - device, - swapchain, - p_swapchain_image_count, - p_swapchain_images, - ) - } - pub unsafe fn acquire_next_image_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - timeout: uint64_t, - semaphore: Semaphore, - fence: Fence, - p_image_index: *const uint32_t, - ) -> Result { - (self.acquire_next_image_khr)(device, swapchain, timeout, semaphore, fence, p_image_index) - } - pub unsafe fn queue_present_khr( - &self, - queue: Queue, - p_present_info: *const PresentInfoKHR, - ) -> Result { - (self.queue_present_khr)(queue, p_present_info) - } - pub unsafe fn get_device_group_present_capabilities_khr( - &self, - device: Device, - p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, - ) -> Result { - (self.get_device_group_present_capabilities_khr)( - device, - p_device_group_present_capabilities, - ) - } - pub unsafe fn get_device_group_surface_present_modes_khr( - &self, - device: Device, - surface: SurfaceKHR, - p_modes: *const DeviceGroupPresentModeFlagsKHR, - ) -> Result { - (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) - } - pub unsafe fn get_physical_device_present_rectangles_khr( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_rect_count: *const uint32_t, - p_rects: *const Rect2D, - ) -> Result { - (self.get_physical_device_present_rectangles_khr)( - physical_device, - surface, - p_rect_count, - p_rects, - ) - } - pub unsafe fn acquire_next_image2_khr( - &self, - device: Device, - p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *const uint32_t, - ) -> Result { - (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) - } -} -pub struct KhrDisplayFn { - get_physical_device_display_properties_khr: - extern "system" fn( + pub unsafe fn get_physical_device_display_properties_khr( + &self, physical_device: PhysicalDevice, p_property_count: *const uint32_t, p_properties: *const DisplayPropertiesKHR, - ) -> Result, - get_physical_device_display_plane_properties_khr: - extern "system" fn( + ) -> Result { + (self.get_physical_device_display_properties_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_physical_device_display_plane_properties_khr( + &self, physical_device: PhysicalDevice, p_property_count: *const uint32_t, p_properties: *const DisplayPlanePropertiesKHR, - ) -> Result, - get_display_plane_supported_displays_khr: extern "system" fn( - physical_device: PhysicalDevice, - plane_index: uint32_t, - p_display_count: *const uint32_t, - p_displays: *const DisplayKHR, - ) -> Result, - get_display_mode_properties_khr: - extern "system" fn( + ) -> Result { + (self.get_physical_device_display_plane_properties_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_plane_supported_displays_khr( + &self, + physical_device: PhysicalDevice, + plane_index: uint32_t, + p_display_count: *const uint32_t, + p_displays: *const DisplayKHR, + ) -> Result { + (self.get_display_plane_supported_displays_khr)( + physical_device, + plane_index, + p_display_count, + p_displays, + ) + } + pub unsafe fn get_display_mode_properties_khr( + &self, physical_device: PhysicalDevice, display: DisplayKHR, p_property_count: *const uint32_t, p_properties: *const DisplayModePropertiesKHR, - ) -> Result, - create_display_mode_khr: extern "system" fn( - physical_device: PhysicalDevice, - display: DisplayKHR, - p_create_info: *const DisplayModeCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_mode: *const DisplayModeKHR, - ) -> Result, - get_display_plane_capabilities_khr: - extern "system" fn( + ) -> Result { + (self.get_display_mode_properties_khr)( + physical_device, + display, + p_property_count, + p_properties, + ) + } + pub unsafe fn create_display_mode_khr( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *const DisplayModeKHR, + ) -> Result { + (self.create_display_mode_khr)( + physical_device, + display, + p_create_info, + p_allocator, + p_mode, + ) + } + pub unsafe fn get_display_plane_capabilities_khr( + &self, physical_device: PhysicalDevice, mode: DisplayModeKHR, plane_index: uint32_t, p_capabilities: *const DisplayPlaneCapabilitiesKHR, - ) -> Result, - create_display_plane_surface_khr: - extern "system" fn( + ) -> Result { + (self.get_display_plane_capabilities_khr)( + physical_device, + mode, + plane_index, + p_capabilities, + ) + } + pub unsafe fn create_display_plane_surface_khr( + &self, instance: Instance, p_create_info: *const DisplaySurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_display_plane_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + } + #[doc = "Generated from \'VK_KHR_display\'"] + impl StructureType { + pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = StructureType(1000002000); + } + #[doc = "Generated from \'VK_KHR_display\'"] + impl StructureType { + pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000002001); + } + #[doc = "Generated from \'VK_KHR_display\'"] + impl ObjectType { + pub const DISPLAY_KHR: Self = ObjectType(1000002000); + } + #[doc = "Generated from \'VK_KHR_display\'"] + impl ObjectType { + pub const DISPLAY_MODE_KHR: Self = ObjectType(1000002001); + } + pub struct KhrDisplaySwapchainFn { + create_shared_swapchains_khr: + extern "system" fn( + device: Device, + swapchain_count: uint32_t, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *const SwapchainKHR, + ) -> Result, + } + unsafe impl Send for KhrDisplaySwapchainFn {} + unsafe impl Sync for KhrDisplaySwapchainFn {} + impl ::std::clone::Clone for KhrDisplaySwapchainFn { + fn clone(&self) -> Self { + KhrDisplaySwapchainFn { + create_shared_swapchains_khr: self.create_shared_swapchains_khr, + } + } + } + impl KhrDisplaySwapchainFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDisplaySwapchainFn { + create_shared_swapchains_khr: unsafe { + let raw_name = stringify!(vkCreateSharedSwapchainsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_shared_swapchains_khr( + &self, + device: Device, + swapchain_count: uint32_t, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *const SwapchainKHR, + ) -> Result { + (self.create_shared_swapchains_khr)( + device, + swapchain_count, + p_create_infos, + p_allocator, + p_swapchains, + ) + } + } + #[doc = "Generated from \'VK_KHR_display_swapchain\'"] + impl StructureType { + pub const DISPLAY_PRESENT_INFO_KHR: Self = StructureType(1000003000); + } + #[doc = "Generated from \'VK_KHR_display_swapchain\'"] + impl Result { + pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Result(1000003001); + } + pub struct KhrXlibSurfaceFn { + create_xlib_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, ) -> Result, -} -unsafe impl Send for KhrDisplayFn {} -unsafe impl Sync for KhrDisplayFn {} -impl ::std::clone::Clone for KhrDisplayFn { - fn clone(&self) -> Self { - KhrDisplayFn { - get_physical_device_display_properties_khr: self - .get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: self - .get_physical_device_display_plane_properties_khr, - get_display_plane_supported_displays_khr: self.get_display_plane_supported_displays_khr, - get_display_mode_properties_khr: self.get_display_mode_properties_khr, - create_display_mode_khr: self.create_display_mode_khr, - get_display_plane_capabilities_khr: self.get_display_plane_capabilities_khr, - create_display_plane_surface_khr: self.create_display_plane_surface_khr, + get_physical_device_xlib_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + dpy: *const Display, + visual_id: VisualID, + ) -> Bool32, + } + unsafe impl Send for KhrXlibSurfaceFn {} + unsafe impl Sync for KhrXlibSurfaceFn {} + impl ::std::clone::Clone for KhrXlibSurfaceFn { + fn clone(&self) -> Self { + KhrXlibSurfaceFn { + create_xlib_surface_khr: self.create_xlib_surface_khr, + get_physical_device_xlib_presentation_support_khr: self + .get_physical_device_xlib_presentation_support_khr, + } } } -} -impl KhrDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDisplayFn { - get_physical_device_display_properties_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_display_plane_properties_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_plane_supported_displays_khr: unsafe { - let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_mode_properties_khr: unsafe { - let raw_name = stringify!(vkGetDisplayModePropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_display_mode_khr: unsafe { - let raw_name = stringify!(vkCreateDisplayModeKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_plane_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_display_plane_surface_khr: unsafe { - let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl KhrXlibSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrXlibSurfaceFn { + create_xlib_surface_khr: unsafe { + let raw_name = stringify!(vkCreateXlibSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_xlib_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } - pub unsafe fn get_physical_device_display_properties_khr( - &self, - physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPropertiesKHR, - ) -> Result { - (self.get_physical_device_display_properties_khr)( - physical_device, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_physical_device_display_plane_properties_khr( - &self, - physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPlanePropertiesKHR, - ) -> Result { - (self.get_physical_device_display_plane_properties_khr)( - physical_device, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_display_plane_supported_displays_khr( - &self, - physical_device: PhysicalDevice, - plane_index: uint32_t, - p_display_count: *const uint32_t, - p_displays: *const DisplayKHR, - ) -> Result { - (self.get_display_plane_supported_displays_khr)( - physical_device, - plane_index, - p_display_count, - p_displays, - ) - } - pub unsafe fn get_display_mode_properties_khr( - &self, - physical_device: PhysicalDevice, - display: DisplayKHR, - p_property_count: *const uint32_t, - p_properties: *const DisplayModePropertiesKHR, - ) -> Result { - (self.get_display_mode_properties_khr)( - physical_device, - display, - p_property_count, - p_properties, - ) - } - pub unsafe fn create_display_mode_khr( - &self, - physical_device: PhysicalDevice, - display: DisplayKHR, - p_create_info: *const DisplayModeCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_mode: *const DisplayModeKHR, - ) -> Result { - (self.create_display_mode_khr)(physical_device, display, p_create_info, p_allocator, p_mode) - } - pub unsafe fn get_display_plane_capabilities_khr( - &self, - physical_device: PhysicalDevice, - mode: DisplayModeKHR, - plane_index: uint32_t, - p_capabilities: *const DisplayPlaneCapabilitiesKHR, - ) -> Result { - (self.get_display_plane_capabilities_khr)( - physical_device, - mode, - plane_index, - p_capabilities, - ) - } - pub unsafe fn create_display_plane_surface_khr( - &self, - instance: Instance, - p_create_info: *const DisplaySurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_display_plane_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } -} -pub struct KhrDisplaySwapchainFn { - create_shared_swapchains_khr: extern "system" fn( - device: Device, - swapchain_count: uint32_t, - p_create_infos: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchains: *const SwapchainKHR, - ) -> Result, -} -unsafe impl Send for KhrDisplaySwapchainFn {} -unsafe impl Sync for KhrDisplaySwapchainFn {} -impl ::std::clone::Clone for KhrDisplaySwapchainFn { - fn clone(&self) -> Self { - KhrDisplaySwapchainFn { - create_shared_swapchains_khr: self.create_shared_swapchains_khr, + pub unsafe fn create_xlib_surface_khr( + &self, + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_xlib_surface_khr)(instance, p_create_info, p_allocator, p_surface) } - } -} -impl KhrDisplaySwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDisplaySwapchainFn { - create_shared_swapchains_khr: unsafe { - let raw_name = stringify!(vkCreateSharedSwapchainsKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_shared_swapchains_khr( - &self, - device: Device, - swapchain_count: uint32_t, - p_create_infos: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchains: *const SwapchainKHR, - ) -> Result { - (self.create_shared_swapchains_khr)( - device, - swapchain_count, - p_create_infos, - p_allocator, - p_swapchains, - ) - } -} -pub struct KhrXlibSurfaceFn { - create_xlib_surface_khr: extern "system" fn( - instance: Instance, - p_create_info: *const XlibSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result, - get_physical_device_xlib_presentation_support_khr: - extern "system" fn( + pub unsafe fn get_physical_device_xlib_presentation_support_khr( + &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, dpy: *const Display, visual_id: VisualID, - ) -> Bool32, -} -unsafe impl Send for KhrXlibSurfaceFn {} -unsafe impl Sync for KhrXlibSurfaceFn {} -impl ::std::clone::Clone for KhrXlibSurfaceFn { - fn clone(&self) -> Self { - KhrXlibSurfaceFn { - create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: self - .get_physical_device_xlib_presentation_support_khr, + ) -> Bool32 { + (self.get_physical_device_xlib_presentation_support_khr)( + physical_device, + queue_family_index, + dpy, + visual_id, + ) } } -} -impl KhrXlibSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrXlibSurfaceFn { - create_xlib_surface_khr: unsafe { - let raw_name = stringify!(vkCreateXlibSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_xlib_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_KHR_xlib_surface\'"] + impl StructureType { + pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000004000); + } + pub struct KhrXcbSurfaceFn { + create_xcb_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_xcb_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *const xcb_connection_t, + visual_id: xcb_visualid_t, + ) -> Bool32, + } + unsafe impl Send for KhrXcbSurfaceFn {} + unsafe impl Sync for KhrXcbSurfaceFn {} + impl ::std::clone::Clone for KhrXcbSurfaceFn { + fn clone(&self) -> Self { + KhrXcbSurfaceFn { + create_xcb_surface_khr: self.create_xcb_surface_khr, + get_physical_device_xcb_presentation_support_khr: self + .get_physical_device_xcb_presentation_support_khr, + } } } - pub unsafe fn create_xlib_surface_khr( - &self, - instance: Instance, - p_create_info: *const XlibSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_xlib_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_xlib_presentation_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - dpy: *const Display, - visual_id: VisualID, - ) -> Bool32 { - (self.get_physical_device_xlib_presentation_support_khr)( - physical_device, - queue_family_index, - dpy, - visual_id, - ) - } -} -pub struct KhrXcbSurfaceFn { - create_xcb_surface_khr: extern "system" fn( - instance: Instance, - p_create_info: *const XcbSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result, - get_physical_device_xcb_presentation_support_khr: - extern "system" fn( + impl KhrXcbSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrXcbSurfaceFn { + create_xcb_surface_khr: unsafe { + let raw_name = stringify!(vkCreateXcbSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_xcb_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_xcb_surface_khr( + &self, + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_xcb_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_xcb_presentation_support_khr( + &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, connection: *const xcb_connection_t, visual_id: xcb_visualid_t, - ) -> Bool32, -} -unsafe impl Send for KhrXcbSurfaceFn {} -unsafe impl Sync for KhrXcbSurfaceFn {} -impl ::std::clone::Clone for KhrXcbSurfaceFn { - fn clone(&self) -> Self { - KhrXcbSurfaceFn { - create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: self - .get_physical_device_xcb_presentation_support_khr, + ) -> Bool32 { + (self.get_physical_device_xcb_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + visual_id, + ) } } -} -impl KhrXcbSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrXcbSurfaceFn { - create_xcb_surface_khr: unsafe { - let raw_name = stringify!(vkCreateXcbSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_xcb_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_KHR_xcb_surface\'"] + impl StructureType { + pub const XCB_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000005000); + } + pub struct KhrWaylandSurfaceFn { + create_wayland_surface_khr: + extern "system" fn( + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_wayland_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + display: *const wl_display, + ) -> Bool32, + } + unsafe impl Send for KhrWaylandSurfaceFn {} + unsafe impl Sync for KhrWaylandSurfaceFn {} + impl ::std::clone::Clone for KhrWaylandSurfaceFn { + fn clone(&self) -> Self { + KhrWaylandSurfaceFn { + create_wayland_surface_khr: self.create_wayland_surface_khr, + get_physical_device_wayland_presentation_support_khr: self + .get_physical_device_wayland_presentation_support_khr, + } } } - pub unsafe fn create_xcb_surface_khr( - &self, - instance: Instance, - p_create_info: *const XcbSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_xcb_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_xcb_presentation_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - connection: *const xcb_connection_t, - visual_id: xcb_visualid_t, - ) -> Bool32 { - (self.get_physical_device_xcb_presentation_support_khr)( - physical_device, - queue_family_index, - connection, - visual_id, - ) - } -} -pub struct KhrWaylandSurfaceFn { - create_wayland_surface_khr: - extern "system" fn( + impl KhrWaylandSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWaylandSurfaceFn { + create_wayland_surface_khr: unsafe { + let raw_name = stringify!(vkCreateWaylandSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_wayland_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_wayland_surface_khr( + &self, instance: Instance, p_create_info: *const WaylandSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_surface: *const SurfaceKHR, - ) -> Result, - get_physical_device_wayland_presentation_support_khr: - extern "system" fn( + ) -> Result { + (self.create_wayland_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_wayland_presentation_support_khr( + &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, display: *const wl_display, - ) -> Bool32, -} -unsafe impl Send for KhrWaylandSurfaceFn {} -unsafe impl Sync for KhrWaylandSurfaceFn {} -impl ::std::clone::Clone for KhrWaylandSurfaceFn { - fn clone(&self) -> Self { - KhrWaylandSurfaceFn { - create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: self - .get_physical_device_wayland_presentation_support_khr, + ) -> Bool32 { + (self.get_physical_device_wayland_presentation_support_khr)( + physical_device, + queue_family_index, + display, + ) } } -} -impl KhrWaylandSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrWaylandSurfaceFn { - create_wayland_surface_khr: unsafe { - let raw_name = stringify!(vkCreateWaylandSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_wayland_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_KHR_wayland_surface\'"] + impl StructureType { + pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000006000); + } + pub struct KhrMirSurfaceFn { + create_mir_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_mir_presentation_support_khr: + extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *const MirConnection, + ) -> Bool32, + } + unsafe impl Send for KhrMirSurfaceFn {} + unsafe impl Sync for KhrMirSurfaceFn {} + impl ::std::clone::Clone for KhrMirSurfaceFn { + fn clone(&self) -> Self { + KhrMirSurfaceFn { + create_mir_surface_khr: self.create_mir_surface_khr, + get_physical_device_mir_presentation_support_khr: self + .get_physical_device_mir_presentation_support_khr, + } } } - pub unsafe fn create_wayland_surface_khr( - &self, - instance: Instance, - p_create_info: *const WaylandSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_wayland_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_wayland_presentation_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - display: *const wl_display, - ) -> Bool32 { - (self.get_physical_device_wayland_presentation_support_khr)( - physical_device, - queue_family_index, - display, - ) - } -} -pub struct KhrMirSurfaceFn { - create_mir_surface_khr: extern "system" fn( - instance: Instance, - p_create_info: *const MirSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result, - get_physical_device_mir_presentation_support_khr: - extern "system" fn( + impl KhrMirSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMirSurfaceFn { + create_mir_surface_khr: unsafe { + let raw_name = stringify!(vkCreateMirSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_mir_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_mir_surface_khr( + &self, + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_mir_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_mir_presentation_support_khr( + &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, connection: *const MirConnection, - ) -> Bool32, -} -unsafe impl Send for KhrMirSurfaceFn {} -unsafe impl Sync for KhrMirSurfaceFn {} -impl ::std::clone::Clone for KhrMirSurfaceFn { - fn clone(&self) -> Self { - KhrMirSurfaceFn { - create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: self - .get_physical_device_mir_presentation_support_khr, + ) -> Bool32 { + (self.get_physical_device_mir_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + ) } } -} -impl KhrMirSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrMirSurfaceFn { - create_mir_surface_khr: unsafe { - let raw_name = stringify!(vkCreateMirSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_mir_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_KHR_mir_surface\'"] + impl StructureType { + pub const MIR_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000007000); + } + pub struct KhrAndroidSurfaceFn { + create_android_surface_khr: + extern "system" fn( + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + } + unsafe impl Send for KhrAndroidSurfaceFn {} + unsafe impl Sync for KhrAndroidSurfaceFn {} + impl ::std::clone::Clone for KhrAndroidSurfaceFn { + fn clone(&self) -> Self { + KhrAndroidSurfaceFn { + create_android_surface_khr: self.create_android_surface_khr, + } } } - pub unsafe fn create_mir_surface_khr( - &self, - instance: Instance, - p_create_info: *const MirSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_mir_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_mir_presentation_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - connection: *const MirConnection, - ) -> Bool32 { - (self.get_physical_device_mir_presentation_support_khr)( - physical_device, - queue_family_index, - connection, - ) - } -} -pub struct KhrAndroidSurfaceFn { - create_android_surface_khr: - extern "system" fn( + impl KhrAndroidSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrAndroidSurfaceFn { + create_android_surface_khr: unsafe { + let raw_name = stringify!(vkCreateAndroidSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_android_surface_khr( + &self, instance: Instance, p_create_info: *const AndroidSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_surface: *const SurfaceKHR, - ) -> Result, -} -unsafe impl Send for KhrAndroidSurfaceFn {} -unsafe impl Sync for KhrAndroidSurfaceFn {} -impl ::std::clone::Clone for KhrAndroidSurfaceFn { - fn clone(&self) -> Self { - KhrAndroidSurfaceFn { - create_android_surface_khr: self.create_android_surface_khr, + ) -> Result { + (self.create_android_surface_khr)(instance, p_create_info, p_allocator, p_surface) } } -} -impl KhrAndroidSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrAndroidSurfaceFn { - create_android_surface_khr: unsafe { - let raw_name = stringify!(vkCreateAndroidSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_KHR_android_surface\'"] + impl StructureType { + pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000008000); + } + pub struct KhrWin32SurfaceFn { + create_win32_surface_khr: + extern "system" fn( + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + get_physical_device_win32_presentation_support_khr: + extern "system" fn(physical_device: PhysicalDevice, queue_family_index: uint32_t) + -> Bool32, + } + unsafe impl Send for KhrWin32SurfaceFn {} + unsafe impl Sync for KhrWin32SurfaceFn {} + impl ::std::clone::Clone for KhrWin32SurfaceFn { + fn clone(&self) -> Self { + KhrWin32SurfaceFn { + create_win32_surface_khr: self.create_win32_surface_khr, + get_physical_device_win32_presentation_support_khr: self + .get_physical_device_win32_presentation_support_khr, + } } } - pub unsafe fn create_android_surface_khr( - &self, - instance: Instance, - p_create_info: *const AndroidSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_android_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } -} -pub struct KhrWin32SurfaceFn { - create_win32_surface_khr: extern "system" fn( - instance: Instance, - p_create_info: *const Win32SurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result, - get_physical_device_win32_presentation_support_khr: - extern "system" fn(physical_device: PhysicalDevice, queue_family_index: uint32_t) -> Bool32, -} -unsafe impl Send for KhrWin32SurfaceFn {} -unsafe impl Sync for KhrWin32SurfaceFn {} -impl ::std::clone::Clone for KhrWin32SurfaceFn { - fn clone(&self) -> Self { - KhrWin32SurfaceFn { - create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: self - .get_physical_device_win32_presentation_support_khr, + impl KhrWin32SurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWin32SurfaceFn { + create_win32_surface_khr: unsafe { + let raw_name = stringify!(vkCreateWin32SurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_win32_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_win32_surface_khr( + &self, + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_win32_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_win32_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + ) -> Bool32 { + (self.get_physical_device_win32_presentation_support_khr)( + physical_device, + queue_family_index, + ) } } -} -impl KhrWin32SurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrWin32SurfaceFn { - create_win32_surface_khr: unsafe { - let raw_name = stringify!(vkCreateWin32SurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_win32_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_KHR_win32_surface\'"] + impl StructureType { + pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000009000); + } + pub struct ExtDebugReportFn { + create_debug_report_callback_ext: + extern "system" fn( + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *const DebugReportCallbackEXT, + ) -> Result, + destroy_debug_report_callback_ext: + extern "system" fn( + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + debug_report_message_ext: extern "system" fn( + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: uint64_t, + location: size_t, + message_code: int32_t, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> c_void, + } + unsafe impl Send for ExtDebugReportFn {} + unsafe impl Sync for ExtDebugReportFn {} + impl ::std::clone::Clone for ExtDebugReportFn { + fn clone(&self) -> Self { + ExtDebugReportFn { + create_debug_report_callback_ext: self.create_debug_report_callback_ext, + destroy_debug_report_callback_ext: self.destroy_debug_report_callback_ext, + debug_report_message_ext: self.debug_report_message_ext, + } } } - pub unsafe fn create_win32_surface_khr( - &self, - instance: Instance, - p_create_info: *const Win32SurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_win32_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_win32_presentation_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: uint32_t, - ) -> Bool32 { - (self.get_physical_device_win32_presentation_support_khr)( - physical_device, - queue_family_index, - ) - } -} -pub struct AndroidNativeBufferFn { - get_swapchain_gralloc_usage_android: extern "system" fn( - device: Device, - format: Format, - image_usage: ImageUsageFlags, - gralloc_usage: *const c_int, - ) -> Result, - acquire_image_android: extern "system" fn( - device: Device, - image: Image, - native_fence_fd: c_int, - semaphore: Semaphore, - fence: Fence, - ) -> Result, - queue_signal_release_image_android: extern "system" fn( - queue: Queue, - wait_semaphore_count: uint32_t, - p_wait_semaphores: *const Semaphore, - image: Image, - p_native_fence_fd: *const c_int, - ) -> Result, -} -unsafe impl Send for AndroidNativeBufferFn {} -unsafe impl Sync for AndroidNativeBufferFn {} -impl ::std::clone::Clone for AndroidNativeBufferFn { - fn clone(&self) -> Self { - AndroidNativeBufferFn { - get_swapchain_gralloc_usage_android: self.get_swapchain_gralloc_usage_android, - acquire_image_android: self.acquire_image_android, - queue_signal_release_image_android: self.queue_signal_release_image_android, + impl ExtDebugReportFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugReportFn { + create_debug_report_callback_ext: unsafe { + let raw_name = stringify!(vkCreateDebugReportCallbackEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_debug_report_callback_ext: unsafe { + let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + debug_report_message_ext: unsafe { + let raw_name = stringify!(vkDebugReportMessageEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } -} -impl AndroidNativeBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AndroidNativeBufferFn { - get_swapchain_gralloc_usage_android: unsafe { - let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_image_android: unsafe { - let raw_name = stringify!(vkAcquireImageANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_signal_release_image_android: unsafe { - let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_swapchain_gralloc_usage_android( - &self, - device: Device, - format: Format, - image_usage: ImageUsageFlags, - gralloc_usage: *const c_int, - ) -> Result { - (self.get_swapchain_gralloc_usage_android)(device, format, image_usage, gralloc_usage) - } - pub unsafe fn acquire_image_android( - &self, - device: Device, - image: Image, - native_fence_fd: c_int, - semaphore: Semaphore, - fence: Fence, - ) -> Result { - (self.acquire_image_android)(device, image, native_fence_fd, semaphore, fence) - } - pub unsafe fn queue_signal_release_image_android( - &self, - queue: Queue, - wait_semaphore_count: uint32_t, - p_wait_semaphores: *const Semaphore, - image: Image, - p_native_fence_fd: *const c_int, - ) -> Result { - (self.queue_signal_release_image_android)( - queue, - wait_semaphore_count, - p_wait_semaphores, - image, - p_native_fence_fd, - ) - } -} -pub struct ExtDebugReportFn { - create_debug_report_callback_ext: - extern "system" fn( + pub unsafe fn create_debug_report_callback_ext( + &self, instance: Instance, p_create_info: *const DebugReportCallbackCreateInfoEXT, p_allocator: *const AllocationCallbacks, p_callback: *const DebugReportCallbackEXT, + ) -> Result { + (self.create_debug_report_callback_ext)( + instance, + p_create_info, + p_allocator, + p_callback, + ) + } + pub unsafe fn destroy_debug_report_callback_ext( + &self, + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_debug_report_callback_ext)(instance, callback, p_allocator) + } + pub unsafe fn debug_report_message_ext( + &self, + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: uint64_t, + location: size_t, + message_code: int32_t, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> c_void { + (self.debug_report_message_ext)( + instance, + flags, + object_type, + object, + location, + message_code, + p_layer_prefix, + p_message, + ) + } + } + #[doc = "Generated from \'VK_EXT_debug_report\'"] + impl StructureType { + pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = StructureType(1000011000); + } + #[doc = "Generated from \'VK_EXT_debug_report\'"] + impl Result { + pub const ERROR_VALIDATION_FAILED_EXT: Self = Result(1000011001); + } + #[doc = "Generated from \'VK_EXT_debug_report\'"] + impl ObjectType { + pub const DEBUG_REPORT_CALLBACK_EXT: Self = ObjectType(1000011000); + } + #[doc = "Generated from \'VK_EXT_debug_report\'"] + impl DebugReportObjectTypeEXT { + pub const DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: Self = + DebugReportObjectTypeEXT(1000156000); + } + #[doc = "Generated from \'VK_EXT_debug_report\'"] + impl DebugReportObjectTypeEXT { + pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: Self = + DebugReportObjectTypeEXT(1000085000); + } + pub struct NvGlslShaderFn {} + unsafe impl Send for NvGlslShaderFn {} + unsafe impl Sync for NvGlslShaderFn {} + impl ::std::clone::Clone for NvGlslShaderFn { + fn clone(&self) -> Self { + NvGlslShaderFn {} + } + } + impl NvGlslShaderFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvGlslShaderFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_NV_glsl_shader\'"] + impl Result { + pub const ERROR_INVALID_SHADER_NV: Self = Result(1000012000); + } + pub struct ExtDepthRangeUnrestrictedFn {} + unsafe impl Send for ExtDepthRangeUnrestrictedFn {} + unsafe impl Sync for ExtDepthRangeUnrestrictedFn {} + impl ::std::clone::Clone for ExtDepthRangeUnrestrictedFn { + fn clone(&self) -> Self { + ExtDepthRangeUnrestrictedFn {} + } + } + impl ExtDepthRangeUnrestrictedFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDepthRangeUnrestrictedFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrSamplerMirrorClampToEdgeFn {} + unsafe impl Send for KhrSamplerMirrorClampToEdgeFn {} + unsafe impl Sync for KhrSamplerMirrorClampToEdgeFn {} + impl ::std::clone::Clone for KhrSamplerMirrorClampToEdgeFn { + fn clone(&self) -> Self { + KhrSamplerMirrorClampToEdgeFn {} + } + } + impl KhrSamplerMirrorClampToEdgeFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSamplerMirrorClampToEdgeFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ImgFilterCubicFn {} + unsafe impl Send for ImgFilterCubicFn {} + unsafe impl Sync for ImgFilterCubicFn {} + impl ::std::clone::Clone for ImgFilterCubicFn { + fn clone(&self) -> Self { + ImgFilterCubicFn {} + } + } + impl ImgFilterCubicFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgFilterCubicFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_IMG_filter_cubic\'"] + impl Filter { + pub const CUBIC_IMG: Self = Filter(1000015000); + } + #[doc = "Generated from \'VK_IMG_filter_cubic\'"] + impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = FormatFeatureFlags(0b10000000000000); + } + pub struct AmdRasterizationOrderFn {} + unsafe impl Send for AmdRasterizationOrderFn {} + unsafe impl Sync for AmdRasterizationOrderFn {} + impl ::std::clone::Clone for AmdRasterizationOrderFn { + fn clone(&self) -> Self { + AmdRasterizationOrderFn {} + } + } + impl AmdRasterizationOrderFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdRasterizationOrderFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_AMD_rasterization_order\'"] + impl StructureType { + pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = + StructureType(1000018000); + } + pub struct AmdShaderTrinaryMinmaxFn {} + unsafe impl Send for AmdShaderTrinaryMinmaxFn {} + unsafe impl Sync for AmdShaderTrinaryMinmaxFn {} + impl ::std::clone::Clone for AmdShaderTrinaryMinmaxFn { + fn clone(&self) -> Self { + AmdShaderTrinaryMinmaxFn {} + } + } + impl AmdShaderTrinaryMinmaxFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderTrinaryMinmaxFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdShaderExplicitVertexParameterFn {} + unsafe impl Send for AmdShaderExplicitVertexParameterFn {} + unsafe impl Sync for AmdShaderExplicitVertexParameterFn {} + impl ::std::clone::Clone for AmdShaderExplicitVertexParameterFn { + fn clone(&self) -> Self { + AmdShaderExplicitVertexParameterFn {} + } + } + impl AmdShaderExplicitVertexParameterFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderExplicitVertexParameterFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: + extern "system" fn(device: Device, p_tag_info: *const DebugMarkerObjectTagInfoEXT) + -> Result, + debug_marker_set_object_name_ext: + extern "system" fn(device: Device, p_name_info: *const DebugMarkerObjectNameInfoEXT) + -> Result, + cmd_debug_marker_begin_ext: + extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void, + cmd_debug_marker_end_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, + cmd_debug_marker_insert_ext: + extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void, + } + unsafe impl Send for ExtDebugMarkerFn {} + unsafe impl Sync for ExtDebugMarkerFn {} + impl ::std::clone::Clone for ExtDebugMarkerFn { + fn clone(&self) -> Self { + ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: self.debug_marker_set_object_tag_ext, + debug_marker_set_object_name_ext: self.debug_marker_set_object_name_ext, + cmd_debug_marker_begin_ext: self.cmd_debug_marker_begin_ext, + cmd_debug_marker_end_ext: self.cmd_debug_marker_end_ext, + cmd_debug_marker_insert_ext: self.cmd_debug_marker_insert_ext, + } + } + } + impl ExtDebugMarkerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: unsafe { + let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + debug_marker_set_object_name_ext: unsafe { + let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_begin_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_end_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerEndEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_insert_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn debug_marker_set_object_tag_ext( + &self, + device: Device, + p_tag_info: *const DebugMarkerObjectTagInfoEXT, + ) -> Result { + (self.debug_marker_set_object_tag_ext)(device, p_tag_info) + } + pub unsafe fn debug_marker_set_object_name_ext( + &self, + device: Device, + p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result { + (self.debug_marker_set_object_name_ext)(device, p_name_info) + } + pub unsafe fn cmd_debug_marker_begin_ext( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + (self.cmd_debug_marker_begin_ext)(command_buffer, p_marker_info) + } + pub unsafe fn cmd_debug_marker_end_ext(&self, command_buffer: CommandBuffer) -> c_void { + (self.cmd_debug_marker_end_ext)(command_buffer) + } + pub unsafe fn cmd_debug_marker_insert_ext( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + (self.cmd_debug_marker_insert_ext)(command_buffer, p_marker_info) + } + } + #[doc = "Generated from \'VK_EXT_debug_marker\'"] + impl StructureType { + pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = StructureType(1000022000); + } + #[doc = "Generated from \'VK_EXT_debug_marker\'"] + impl StructureType { + pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = StructureType(1000022001); + } + #[doc = "Generated from \'VK_EXT_debug_marker\'"] + impl StructureType { + pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = StructureType(1000022002); + } + pub struct AmdGcnShaderFn {} + unsafe impl Send for AmdGcnShaderFn {} + unsafe impl Sync for AmdGcnShaderFn {} + impl ::std::clone::Clone for AmdGcnShaderFn { + fn clone(&self) -> Self { + AmdGcnShaderFn {} + } + } + impl AmdGcnShaderFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdGcnShaderFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvDedicatedAllocationFn {} + unsafe impl Send for NvDedicatedAllocationFn {} + unsafe impl Sync for NvDedicatedAllocationFn {} + impl ::std::clone::Clone for NvDedicatedAllocationFn { + fn clone(&self) -> Self { + NvDedicatedAllocationFn {} + } + } + impl NvDedicatedAllocationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvDedicatedAllocationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] + impl StructureType { + pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = StructureType(1000026000); + } + #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] + impl StructureType { + pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = StructureType(1000026001); + } + #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] + impl StructureType { + pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = StructureType(1000026002); + } + pub struct AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + cmd_draw_indexed_indirect_count_amd: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + } + unsafe impl Send for AmdDrawIndirectCountFn {} + unsafe impl Sync for AmdDrawIndirectCountFn {} + impl ::std::clone::Clone for AmdDrawIndirectCountFn { + fn clone(&self) -> Self { + AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: self.cmd_draw_indirect_count_amd, + cmd_draw_indexed_indirect_count_amd: self.cmd_draw_indexed_indirect_count_amd, + } + } + } + impl AmdDrawIndirectCountFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: unsafe { + let raw_name = stringify!(vkCmdDrawIndirectCountAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed_indirect_count_amd: unsafe { + let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_draw_indirect_count_amd( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indirect_count_amd)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + pub unsafe fn cmd_draw_indexed_indirect_count_amd( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indexed_indirect_count_amd)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + } + pub struct AmdNegativeViewportHeightFn {} + unsafe impl Send for AmdNegativeViewportHeightFn {} + unsafe impl Sync for AmdNegativeViewportHeightFn {} + impl ::std::clone::Clone for AmdNegativeViewportHeightFn { + fn clone(&self) -> Self { + AmdNegativeViewportHeightFn {} + } + } + impl AmdNegativeViewportHeightFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdNegativeViewportHeightFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdGpuShaderHalfFloatFn {} + unsafe impl Send for AmdGpuShaderHalfFloatFn {} + unsafe impl Sync for AmdGpuShaderHalfFloatFn {} + impl ::std::clone::Clone for AmdGpuShaderHalfFloatFn { + fn clone(&self) -> Self { + AmdGpuShaderHalfFloatFn {} + } + } + impl AmdGpuShaderHalfFloatFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdGpuShaderHalfFloatFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdShaderBallotFn {} + unsafe impl Send for AmdShaderBallotFn {} + unsafe impl Sync for AmdShaderBallotFn {} + impl ::std::clone::Clone for AmdShaderBallotFn { + fn clone(&self) -> Self { + AmdShaderBallotFn {} + } + } + impl AmdShaderBallotFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderBallotFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdTextureGatherBiasLodFn {} + unsafe impl Send for AmdTextureGatherBiasLodFn {} + unsafe impl Sync for AmdTextureGatherBiasLodFn {} + impl ::std::clone::Clone for AmdTextureGatherBiasLodFn { + fn clone(&self) -> Self { + AmdTextureGatherBiasLodFn {} + } + } + impl AmdTextureGatherBiasLodFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdTextureGatherBiasLodFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_AMD_texture_gather_bias_lod\'"] + impl StructureType { + pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = StructureType(1000041000); + } + pub struct AmdShaderInfoFn { + get_shader_info_amd: extern "system" fn( + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *const size_t, + p_info: *const c_void, ) -> Result, - destroy_debug_report_callback_ext: extern "system" fn( - instance: Instance, - callback: DebugReportCallbackEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - debug_report_message_ext: extern "system" fn( - instance: Instance, - flags: DebugReportFlagsEXT, - object_type: DebugReportObjectTypeEXT, - object: uint64_t, - location: size_t, - message_code: int32_t, - p_layer_prefix: *const c_char, - p_message: *const c_char, - ) -> c_void, -} -unsafe impl Send for ExtDebugReportFn {} -unsafe impl Sync for ExtDebugReportFn {} -impl ::std::clone::Clone for ExtDebugReportFn { - fn clone(&self) -> Self { - ExtDebugReportFn { - create_debug_report_callback_ext: self.create_debug_report_callback_ext, - destroy_debug_report_callback_ext: self.destroy_debug_report_callback_ext, - debug_report_message_ext: self.debug_report_message_ext, + } + unsafe impl Send for AmdShaderInfoFn {} + unsafe impl Sync for AmdShaderInfoFn {} + impl ::std::clone::Clone for AmdShaderInfoFn { + fn clone(&self) -> Self { + AmdShaderInfoFn { + get_shader_info_amd: self.get_shader_info_amd, + } } } -} -impl ExtDebugReportFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDebugReportFn { - create_debug_report_callback_ext: unsafe { - let raw_name = stringify!(vkCreateDebugReportCallbackEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_debug_report_callback_ext: unsafe { - let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - debug_report_message_ext: unsafe { - let raw_name = stringify!(vkDebugReportMessageEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl AmdShaderInfoFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderInfoFn { + get_shader_info_amd: unsafe { + let raw_name = stringify!(vkGetShaderInfoAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_shader_info_amd( + &self, + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *const size_t, + p_info: *const c_void, + ) -> Result { + (self.get_shader_info_amd)( + device, + pipeline, + shader_stage, + info_type, + p_info_size, + p_info, + ) } } - pub unsafe fn create_debug_report_callback_ext( - &self, - instance: Instance, - p_create_info: *const DebugReportCallbackCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_callback: *const DebugReportCallbackEXT, - ) -> Result { - (self.create_debug_report_callback_ext)(instance, p_create_info, p_allocator, p_callback) - } - pub unsafe fn destroy_debug_report_callback_ext( - &self, - instance: Instance, - callback: DebugReportCallbackEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_debug_report_callback_ext)(instance, callback, p_allocator) - } - pub unsafe fn debug_report_message_ext( - &self, - instance: Instance, - flags: DebugReportFlagsEXT, - object_type: DebugReportObjectTypeEXT, - object: uint64_t, - location: size_t, - message_code: int32_t, - p_layer_prefix: *const c_char, - p_message: *const c_char, - ) -> c_void { - (self.debug_report_message_ext)( - instance, - flags, - object_type, - object, - location, - message_code, - p_layer_prefix, - p_message, - ) - } -} -pub struct ExtDebugMarkerFn { - debug_marker_set_object_tag_ext: - extern "system" fn(device: Device, p_tag_info: *const DebugMarkerObjectTagInfoEXT) - -> Result, - debug_marker_set_object_name_ext: - extern "system" fn(device: Device, p_name_info: *const DebugMarkerObjectNameInfoEXT) - -> Result, - cmd_debug_marker_begin_ext: extern "system" fn( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void, - cmd_debug_marker_end_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, - cmd_debug_marker_insert_ext: extern "system" fn( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void, -} -unsafe impl Send for ExtDebugMarkerFn {} -unsafe impl Sync for ExtDebugMarkerFn {} -impl ::std::clone::Clone for ExtDebugMarkerFn { - fn clone(&self) -> Self { - ExtDebugMarkerFn { - debug_marker_set_object_tag_ext: self.debug_marker_set_object_tag_ext, - debug_marker_set_object_name_ext: self.debug_marker_set_object_name_ext, - cmd_debug_marker_begin_ext: self.cmd_debug_marker_begin_ext, - cmd_debug_marker_end_ext: self.cmd_debug_marker_end_ext, - cmd_debug_marker_insert_ext: self.cmd_debug_marker_insert_ext, + pub struct AmdShaderImageLoadStoreLodFn {} + unsafe impl Send for AmdShaderImageLoadStoreLodFn {} + unsafe impl Sync for AmdShaderImageLoadStoreLodFn {} + impl ::std::clone::Clone for AmdShaderImageLoadStoreLodFn { + fn clone(&self) -> Self { + AmdShaderImageLoadStoreLodFn {} } } -} -impl ExtDebugMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDebugMarkerFn { - debug_marker_set_object_tag_ext: unsafe { - let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - debug_marker_set_object_name_ext: unsafe { - let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_debug_marker_begin_ext: unsafe { - let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_debug_marker_end_ext: unsafe { - let raw_name = stringify!(vkCmdDebugMarkerEndEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_debug_marker_insert_ext: unsafe { - let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl AmdShaderImageLoadStoreLodFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderImageLoadStoreLodFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } - pub unsafe fn debug_marker_set_object_tag_ext( - &self, - device: Device, - p_tag_info: *const DebugMarkerObjectTagInfoEXT, - ) -> Result { - (self.debug_marker_set_object_tag_ext)(device, p_tag_info) - } - pub unsafe fn debug_marker_set_object_name_ext( - &self, - device: Device, - p_name_info: *const DebugMarkerObjectNameInfoEXT, - ) -> Result { - (self.debug_marker_set_object_name_ext)(device, p_name_info) - } - pub unsafe fn cmd_debug_marker_begin_ext( - &self, - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void { - (self.cmd_debug_marker_begin_ext)(command_buffer, p_marker_info) - } - pub unsafe fn cmd_debug_marker_end_ext(&self, command_buffer: CommandBuffer) -> c_void { - (self.cmd_debug_marker_end_ext)(command_buffer) - } - pub unsafe fn cmd_debug_marker_insert_ext( - &self, - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void { - (self.cmd_debug_marker_insert_ext)(command_buffer, p_marker_info) - } -} -pub struct AmdDrawIndirectCountFn { - cmd_draw_indirect_count_amd: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void, - cmd_draw_indexed_indirect_count_amd: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void, -} -unsafe impl Send for AmdDrawIndirectCountFn {} -unsafe impl Sync for AmdDrawIndirectCountFn {} -impl ::std::clone::Clone for AmdDrawIndirectCountFn { - fn clone(&self) -> Self { - AmdDrawIndirectCountFn { - cmd_draw_indirect_count_amd: self.cmd_draw_indirect_count_amd, - cmd_draw_indexed_indirect_count_amd: self.cmd_draw_indexed_indirect_count_amd, + pub struct KhrMultiviewFn {} + unsafe impl Send for KhrMultiviewFn {} + unsafe impl Sync for KhrMultiviewFn {} + impl ::std::clone::Clone for KhrMultiviewFn { + fn clone(&self) -> Self { + KhrMultiviewFn {} } } -} -impl AmdDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdDrawIndirectCountFn { - cmd_draw_indirect_count_amd: unsafe { - let raw_name = stringify!(vkCmdDrawIndirectCountAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_draw_indexed_indirect_count_amd: unsafe { - let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl KhrMultiviewFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMultiviewFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } - pub unsafe fn cmd_draw_indirect_count_amd( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void { - (self.cmd_draw_indirect_count_amd)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) - } - pub unsafe fn cmd_draw_indexed_indirect_count_amd( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void { - (self.cmd_draw_indexed_indirect_count_amd)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) - } -} -pub struct AmdShaderInfoFn { - get_shader_info_amd: extern "system" fn( - device: Device, - pipeline: Pipeline, - shader_stage: ShaderStageFlags, - info_type: ShaderInfoTypeAMD, - p_info_size: *const size_t, - p_info: *const c_void, - ) -> Result, -} -unsafe impl Send for AmdShaderInfoFn {} -unsafe impl Sync for AmdShaderInfoFn {} -impl ::std::clone::Clone for AmdShaderInfoFn { - fn clone(&self) -> Self { - AmdShaderInfoFn { - get_shader_info_amd: self.get_shader_info_amd, + pub struct ImgFormatPvrtcFn {} + unsafe impl Send for ImgFormatPvrtcFn {} + unsafe impl Sync for ImgFormatPvrtcFn {} + impl ::std::clone::Clone for ImgFormatPvrtcFn { + fn clone(&self) -> Self { + ImgFormatPvrtcFn {} } } -} -impl AmdShaderInfoFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderInfoFn { - get_shader_info_amd: unsafe { - let raw_name = stringify!(vkGetShaderInfoAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl ImgFormatPvrtcFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgFormatPvrtcFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } - pub unsafe fn get_shader_info_amd( - &self, - device: Device, - pipeline: Pipeline, - shader_stage: ShaderStageFlags, - info_type: ShaderInfoTypeAMD, - p_info_size: *const size_t, - p_info: *const c_void, - ) -> Result { - (self.get_shader_info_amd)( - device, - pipeline, - shader_stage, - info_type, - p_info_size, - p_info, - ) + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Format(1000054000); } -} -pub struct NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv : extern "system" fn ( physical_device : PhysicalDevice , format : Format , ty : ImageType , tiling : ImageTiling , usage : ImageUsageFlags , flags : ImageCreateFlags , external_handle_type : ExternalMemoryHandleTypeFlagsNV , p_external_image_format_properties : *const ExternalImageFormatPropertiesNV , ) -> Result , } -unsafe impl Send for NvExternalMemoryCapabilitiesFn {} -unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} -impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { - fn clone(&self) -> Self { - NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: self - .get_physical_device_external_image_format_properties_nv, + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Format(1000054001); + } + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Format(1000054002); + } + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Format(1000054003); + } + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Format(1000054004); + } + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Format(1000054005); + } + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Format(1000054006); + } + #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] + impl Format { + pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Format(1000054007); + } + pub struct NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv : extern "system" fn ( physical_device : PhysicalDevice , format : Format , ty : ImageType , tiling : ImageTiling , usage : ImageUsageFlags , flags : ImageCreateFlags , external_handle_type : ExternalMemoryHandleTypeFlagsNV , p_external_image_format_properties : *const ExternalImageFormatPropertiesNV , ) -> Result , } + unsafe impl Send for NvExternalMemoryCapabilitiesFn {} + unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} + impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { + fn clone(&self) -> Self { + NvExternalMemoryCapabilitiesFn { + get_physical_device_external_image_format_properties_nv: self + .get_physical_device_external_image_format_properties_nv, + } } } -} -impl NvExternalMemoryCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl NvExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryCapabilitiesFn { + get_physical_device_external_image_format_properties_nv: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_external_image_format_properties_nv( + &self, + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + external_handle_type: ExternalMemoryHandleTypeFlagsNV, + p_external_image_format_properties: *const ExternalImageFormatPropertiesNV, + ) -> Result { + (self.get_physical_device_external_image_format_properties_nv)( + physical_device, + format, + ty, + tiling, + usage, + flags, + external_handle_type, + p_external_image_format_properties, + ) } } - pub unsafe fn get_physical_device_external_image_format_properties_nv( - &self, - physical_device: PhysicalDevice, - format: Format, - ty: ImageType, - tiling: ImageTiling, - usage: ImageUsageFlags, - flags: ImageCreateFlags, - external_handle_type: ExternalMemoryHandleTypeFlagsNV, - p_external_image_format_properties: *const ExternalImageFormatPropertiesNV, - ) -> Result { - (self.get_physical_device_external_image_format_properties_nv)( - physical_device, - format, - ty, - tiling, - usage, - flags, - external_handle_type, - p_external_image_format_properties, - ) - } -} -pub struct NvExternalMemoryWin32Fn { - get_memory_win32_handle_nv: extern "system" fn( - device: Device, - memory: DeviceMemory, - handle_type: ExternalMemoryHandleTypeFlagsNV, - p_handle: *const HANDLE, - ) -> Result, -} -unsafe impl Send for NvExternalMemoryWin32Fn {} -unsafe impl Sync for NvExternalMemoryWin32Fn {} -impl ::std::clone::Clone for NvExternalMemoryWin32Fn { - fn clone(&self) -> Self { - NvExternalMemoryWin32Fn { - get_memory_win32_handle_nv: self.get_memory_win32_handle_nv, + pub struct NvExternalMemoryFn {} + unsafe impl Send for NvExternalMemoryFn {} + unsafe impl Sync for NvExternalMemoryFn {} + impl ::std::clone::Clone for NvExternalMemoryFn { + fn clone(&self) -> Self { + NvExternalMemoryFn {} } } -} -impl NvExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryWin32Fn { - get_memory_win32_handle_nv: unsafe { - let raw_name = stringify!(vkGetMemoryWin32HandleNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl NvExternalMemoryFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } - pub unsafe fn get_memory_win32_handle_nv( - &self, - device: Device, - memory: DeviceMemory, - handle_type: ExternalMemoryHandleTypeFlagsNV, - p_handle: *const HANDLE, - ) -> Result { - (self.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle) + #[doc = "Generated from \'VK_NV_external_memory\'"] + impl StructureType { + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = StructureType(1000056000); } -} -pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } -unsafe impl Send for KhrDeviceGroupFn {} -unsafe impl Sync for KhrDeviceGroupFn {} -impl ::std::clone::Clone for KhrDeviceGroupFn { - fn clone(&self) -> Self { - KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, - acquire_next_image2_khr: self.acquire_next_image2_khr, + #[doc = "Generated from \'VK_NV_external_memory\'"] + impl StructureType { + pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = StructureType(1000056001); + } + pub struct NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: + extern "system" fn( + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *const HANDLE, + ) -> Result, + } + unsafe impl Send for NvExternalMemoryWin32Fn {} + unsafe impl Sync for NvExternalMemoryWin32Fn {} + impl ::std::clone::Clone for NvExternalMemoryWin32Fn { + fn clone(&self) -> Self { + NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: self.get_memory_win32_handle_nv, + } } } -} -impl KhrDeviceGroupFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_device_group_surface_present_modes_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_present_rectangles_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_next_image2_khr: unsafe { - let raw_name = stringify!(vkAcquireNextImage2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl NvExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandleNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_win32_handle_nv( + &self, + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *const HANDLE, + ) -> Result { + (self.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle) } } - pub unsafe fn get_device_group_present_capabilities_khr( - &self, - device: Device, - p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, - ) -> Result { - (self.get_device_group_present_capabilities_khr)( - device, - p_device_group_present_capabilities, - ) + #[doc = "Generated from \'VK_NV_external_memory_win32\'"] + impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = StructureType(1000057000); } - pub unsafe fn get_device_group_surface_present_modes_khr( - &self, - device: Device, - surface: SurfaceKHR, - p_modes: *const DeviceGroupPresentModeFlagsKHR, - ) -> Result { - (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) + #[doc = "Generated from \'VK_NV_external_memory_win32\'"] + impl StructureType { + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = StructureType(1000057001); } - pub unsafe fn get_physical_device_present_rectangles_khr( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_rect_count: *const uint32_t, - p_rects: *const Rect2D, - ) -> Result { - (self.get_physical_device_present_rectangles_khr)( - physical_device, - surface, - p_rect_count, - p_rects, - ) - } - pub unsafe fn acquire_next_image2_khr( - &self, - device: Device, - p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *const uint32_t, - ) -> Result { - (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) - } -} -pub struct NnViSurfaceFn { - create_vi_surface_nn: extern "system" fn( - instance: Instance, - p_create_info: *const ViSurfaceCreateInfoNN, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result, -} -unsafe impl Send for NnViSurfaceFn {} -unsafe impl Sync for NnViSurfaceFn {} -impl ::std::clone::Clone for NnViSurfaceFn { - fn clone(&self) -> Self { - NnViSurfaceFn { - create_vi_surface_nn: self.create_vi_surface_nn, + pub struct NvWin32KeyedMutexFn {} + unsafe impl Send for NvWin32KeyedMutexFn {} + unsafe impl Sync for NvWin32KeyedMutexFn {} + impl ::std::clone::Clone for NvWin32KeyedMutexFn { + fn clone(&self) -> Self { + NvWin32KeyedMutexFn {} } } -} -impl NnViSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NnViSurfaceFn { - create_vi_surface_nn: unsafe { - let raw_name = stringify!(vkCreateViSurfaceNN); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl NvWin32KeyedMutexFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvWin32KeyedMutexFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } - pub unsafe fn create_vi_surface_nn( - &self, - instance: Instance, - p_create_info: *const ViSurfaceCreateInfoNN, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_vi_surface_nn)(instance, p_create_info, p_allocator, p_surface) + #[doc = "Generated from \'VK_NV_win32_keyed_mutex\'"] + impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = StructureType(1000058000); } -} -pub struct KhrExternalMemoryWin32Fn { - get_memory_win32_handle_khr: - extern "system" fn( + pub struct KhrGetPhysicalDeviceProperties2Fn {} + unsafe impl Send for KhrGetPhysicalDeviceProperties2Fn {} + unsafe impl Sync for KhrGetPhysicalDeviceProperties2Fn {} + impl ::std::clone::Clone for KhrGetPhysicalDeviceProperties2Fn { + fn clone(&self) -> Self { + KhrGetPhysicalDeviceProperties2Fn {} + } + } + impl KhrGetPhysicalDeviceProperties2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetPhysicalDeviceProperties2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } + unsafe impl Send for KhrDeviceGroupFn {} + unsafe impl Sync for KhrDeviceGroupFn {} + impl ::std::clone::Clone for KhrDeviceGroupFn { + fn clone(&self) -> Self { + KhrDeviceGroupFn { + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, + acquire_next_image2_khr: self.acquire_next_image2_khr, + } + } + } + impl KhrDeviceGroupFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDeviceGroupFn { + get_device_group_present_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_present_rectangles_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image2_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_device_group_present_capabilities_khr( + &self, + device: Device, + p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + (self.get_device_group_present_capabilities_khr)( + device, + p_device_group_present_capabilities, + ) + } + pub unsafe fn get_device_group_surface_present_modes_khr( + &self, + device: Device, + surface: SurfaceKHR, + p_modes: *const DeviceGroupPresentModeFlagsKHR, + ) -> Result { + (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) + } + pub unsafe fn get_physical_device_present_rectangles_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *const uint32_t, + p_rects: *const Rect2D, + ) -> Result { + (self.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + p_rect_count, + p_rects, + ) + } + pub unsafe fn acquire_next_image2_khr( + &self, + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *const uint32_t, + ) -> Result { + (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) + } + } + pub struct ExtValidationFlagsFn {} + unsafe impl Send for ExtValidationFlagsFn {} + unsafe impl Sync for ExtValidationFlagsFn {} + impl ::std::clone::Clone for ExtValidationFlagsFn { + fn clone(&self) -> Self { + ExtValidationFlagsFn {} + } + } + impl ExtValidationFlagsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtValidationFlagsFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_EXT_validation_flags\'"] + impl StructureType { + pub const VALIDATION_FLAGS_EXT: Self = StructureType(1000061000); + } + pub struct NnViSurfaceFn { + create_vi_surface_nn: extern "system" fn( + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, + } + unsafe impl Send for NnViSurfaceFn {} + unsafe impl Sync for NnViSurfaceFn {} + impl ::std::clone::Clone for NnViSurfaceFn { + fn clone(&self) -> Self { + NnViSurfaceFn { + create_vi_surface_nn: self.create_vi_surface_nn, + } + } + } + impl NnViSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NnViSurfaceFn { + create_vi_surface_nn: unsafe { + let raw_name = stringify!(vkCreateViSurfaceNN); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_vi_surface_nn( + &self, + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_vi_surface_nn)(instance, p_create_info, p_allocator, p_surface) + } + } + #[doc = "Generated from \'VK_NN_vi_surface\'"] + impl StructureType { + pub const VI_SURFACE_CREATE_INFO_NN: Self = StructureType(1000062000); + } + pub struct KhrShaderDrawParametersFn {} + unsafe impl Send for KhrShaderDrawParametersFn {} + unsafe impl Sync for KhrShaderDrawParametersFn {} + impl ::std::clone::Clone for KhrShaderDrawParametersFn { + fn clone(&self) -> Self { + KhrShaderDrawParametersFn {} + } + } + impl KhrShaderDrawParametersFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrShaderDrawParametersFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtShaderSubgroupBallotFn {} + unsafe impl Send for ExtShaderSubgroupBallotFn {} + unsafe impl Sync for ExtShaderSubgroupBallotFn {} + impl ::std::clone::Clone for ExtShaderSubgroupBallotFn { + fn clone(&self) -> Self { + ExtShaderSubgroupBallotFn {} + } + } + impl ExtShaderSubgroupBallotFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderSubgroupBallotFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtShaderSubgroupVoteFn {} + unsafe impl Send for ExtShaderSubgroupVoteFn {} + unsafe impl Sync for ExtShaderSubgroupVoteFn {} + impl ::std::clone::Clone for ExtShaderSubgroupVoteFn { + fn clone(&self) -> Self { + ExtShaderSubgroupVoteFn {} + } + } + impl ExtShaderSubgroupVoteFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderSubgroupVoteFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrMaintenance1Fn {} + unsafe impl Send for KhrMaintenance1Fn {} + unsafe impl Sync for KhrMaintenance1Fn {} + impl ::std::clone::Clone for KhrMaintenance1Fn { + fn clone(&self) -> Self { + KhrMaintenance1Fn {} + } + } + impl KhrMaintenance1Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMaintenance1Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrDeviceGroupCreationFn {} + unsafe impl Send for KhrDeviceGroupCreationFn {} + unsafe impl Sync for KhrDeviceGroupCreationFn {} + impl ::std::clone::Clone for KhrDeviceGroupCreationFn { + fn clone(&self) -> Self { + KhrDeviceGroupCreationFn {} + } + } + impl KhrDeviceGroupCreationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDeviceGroupCreationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExternalMemoryCapabilitiesFn {} + unsafe impl Send for KhrExternalMemoryCapabilitiesFn {} + unsafe impl Sync for KhrExternalMemoryCapabilitiesFn {} + impl ::std::clone::Clone for KhrExternalMemoryCapabilitiesFn { + fn clone(&self) -> Self { + KhrExternalMemoryCapabilitiesFn {} + } + } + impl KhrExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryCapabilitiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExternalMemoryFn {} + unsafe impl Send for KhrExternalMemoryFn {} + unsafe impl Sync for KhrExternalMemoryFn {} + impl ::std::clone::Clone for KhrExternalMemoryFn { + fn clone(&self) -> Self { + KhrExternalMemoryFn {} + } + } + impl KhrExternalMemoryFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExternalMemoryWin32Fn { get_memory_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const MemoryGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , get_memory_win32_handle_properties_khr : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , handle : HANDLE , p_memory_win32_handle_properties : *const MemoryWin32HandlePropertiesKHR , ) -> Result , } + unsafe impl Send for KhrExternalMemoryWin32Fn {} + unsafe impl Sync for KhrExternalMemoryWin32Fn {} + impl ::std::clone::Clone for KhrExternalMemoryWin32Fn { + fn clone(&self) -> Self { + KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: self.get_memory_win32_handle_khr, + get_memory_win32_handle_properties_khr: self.get_memory_win32_handle_properties_khr, + } + } + } + impl KhrExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_win32_handle_properties_khr: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_win32_handle_khr( + &self, device: Device, p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, p_handle: *const HANDLE, - ) -> Result, - get_memory_win32_handle_properties_khr: - extern "system" fn( + ) -> Result { + (self.get_memory_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } + pub unsafe fn get_memory_win32_handle_properties_khr( + &self, device: Device, handle_type: ExternalMemoryHandleTypeFlags, handle: HANDLE, p_memory_win32_handle_properties: *const MemoryWin32HandlePropertiesKHR, + ) -> Result { + (self.get_memory_win32_handle_properties_khr)( + device, + handle_type, + handle, + p_memory_win32_handle_properties, + ) + } + } + #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] + impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073000); + } + #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] + impl StructureType { + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073001); + } + #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] + impl StructureType { + pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = StructureType(1000073002); + } + #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] + impl StructureType { + pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073003); + } + pub struct KhrExternalMemoryFdFn { + get_memory_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *const c_int, ) -> Result, -} -unsafe impl Send for KhrExternalMemoryWin32Fn {} -unsafe impl Sync for KhrExternalMemoryWin32Fn {} -impl ::std::clone::Clone for KhrExternalMemoryWin32Fn { - fn clone(&self) -> Self { - KhrExternalMemoryWin32Fn { - get_memory_win32_handle_khr: self.get_memory_win32_handle_khr, - get_memory_win32_handle_properties_khr: self.get_memory_win32_handle_properties_khr, + get_memory_fd_properties_khr: + extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + fd: c_int, + p_memory_fd_properties: *const MemoryFdPropertiesKHR, + ) -> Result, + } + unsafe impl Send for KhrExternalMemoryFdFn {} + unsafe impl Sync for KhrExternalMemoryFdFn {} + impl ::std::clone::Clone for KhrExternalMemoryFdFn { + fn clone(&self) -> Self { + KhrExternalMemoryFdFn { + get_memory_fd_khr: self.get_memory_fd_khr, + get_memory_fd_properties_khr: self.get_memory_fd_properties_khr, + } } } -} -impl KhrExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryWin32Fn { - get_memory_win32_handle_khr: unsafe { - let raw_name = stringify!(vkGetMemoryWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_memory_win32_handle_properties_khr: unsafe { - let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl KhrExternalMemoryFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryFdFn { + get_memory_fd_khr: unsafe { + let raw_name = stringify!(vkGetMemoryFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_fd_properties_khr: unsafe { + let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } - pub unsafe fn get_memory_win32_handle_khr( - &self, - device: Device, - p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, - p_handle: *const HANDLE, - ) -> Result { - (self.get_memory_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) - } - pub unsafe fn get_memory_win32_handle_properties_khr( - &self, - device: Device, - handle_type: ExternalMemoryHandleTypeFlags, - handle: HANDLE, - p_memory_win32_handle_properties: *const MemoryWin32HandlePropertiesKHR, - ) -> Result { - (self.get_memory_win32_handle_properties_khr)( - device, - handle_type, - handle, - p_memory_win32_handle_properties, - ) - } -} -pub struct KhrExternalMemoryFdFn { - get_memory_fd_khr: extern "system" fn( - device: Device, - p_get_fd_info: *const MemoryGetFdInfoKHR, - p_fd: *const c_int, - ) -> Result, - get_memory_fd_properties_khr: - extern "system" fn( + pub unsafe fn get_memory_fd_khr( + &self, + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result { + (self.get_memory_fd_khr)(device, p_get_fd_info, p_fd) + } + pub unsafe fn get_memory_fd_properties_khr( + &self, device: Device, handle_type: ExternalMemoryHandleTypeFlags, fd: c_int, p_memory_fd_properties: *const MemoryFdPropertiesKHR, + ) -> Result { + (self.get_memory_fd_properties_khr)(device, handle_type, fd, p_memory_fd_properties) + } + } + #[doc = "Generated from \'VK_KHR_external_memory_fd\'"] + impl StructureType { + pub const IMPORT_MEMORY_FD_INFO_KHR: Self = StructureType(1000074000); + } + #[doc = "Generated from \'VK_KHR_external_memory_fd\'"] + impl StructureType { + pub const MEMORY_FD_PROPERTIES_KHR: Self = StructureType(1000074001); + } + #[doc = "Generated from \'VK_KHR_external_memory_fd\'"] + impl StructureType { + pub const MEMORY_GET_FD_INFO_KHR: Self = StructureType(1000074002); + } + pub struct KhrWin32KeyedMutexFn {} + unsafe impl Send for KhrWin32KeyedMutexFn {} + unsafe impl Sync for KhrWin32KeyedMutexFn {} + impl ::std::clone::Clone for KhrWin32KeyedMutexFn { + fn clone(&self) -> Self { + KhrWin32KeyedMutexFn {} + } + } + impl KhrWin32KeyedMutexFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWin32KeyedMutexFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_KHR_win32_keyed_mutex\'"] + impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = StructureType(1000075000); + } + pub struct KhrExternalSemaphoreCapabilitiesFn {} + unsafe impl Send for KhrExternalSemaphoreCapabilitiesFn {} + unsafe impl Sync for KhrExternalSemaphoreCapabilitiesFn {} + impl ::std::clone::Clone for KhrExternalSemaphoreCapabilitiesFn { + fn clone(&self) -> Self { + KhrExternalSemaphoreCapabilitiesFn {} + } + } + impl KhrExternalSemaphoreCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreCapabilitiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExternalSemaphoreFn {} + unsafe impl Send for KhrExternalSemaphoreFn {} + unsafe impl Sync for KhrExternalSemaphoreFn {} + impl ::std::clone::Clone for KhrExternalSemaphoreFn { + fn clone(&self) -> Self { + KhrExternalSemaphoreFn {} + } + } + impl KhrExternalSemaphoreFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , } + unsafe impl Send for KhrExternalSemaphoreWin32Fn {} + unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} + impl ::std::clone::Clone for KhrExternalSemaphoreWin32Fn { + fn clone(&self) -> Self { + KhrExternalSemaphoreWin32Fn { + import_semaphore_win32_handle_khr: self.import_semaphore_win32_handle_khr, + get_semaphore_win32_handle_khr: self.get_semaphore_win32_handle_khr, + } + } + } + impl KhrExternalSemaphoreWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreWin32Fn { + import_semaphore_win32_handle_khr: unsafe { + let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_semaphore_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_semaphore_win32_handle_khr( + &self, + device: Device, + p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, + ) -> Result { + (self.import_semaphore_win32_handle_khr)(device, p_import_semaphore_win32_handle_info) + } + pub unsafe fn get_semaphore_win32_handle_khr( + &self, + device: Device, + p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + p_handle: *const HANDLE, + ) -> Result { + (self.get_semaphore_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } + } + #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] + impl StructureType { + pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078000); + } + #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] + impl StructureType { + pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078001); + } + #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] + impl StructureType { + pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = StructureType(1000078002); + } + #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] + impl StructureType { + pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078003); + } + pub struct KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: + extern "system" fn( + device: Device, + p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result, + get_semaphore_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *const c_int, ) -> Result, -} -unsafe impl Send for KhrExternalMemoryFdFn {} -unsafe impl Sync for KhrExternalMemoryFdFn {} -impl ::std::clone::Clone for KhrExternalMemoryFdFn { - fn clone(&self) -> Self { - KhrExternalMemoryFdFn { - get_memory_fd_khr: self.get_memory_fd_khr, - get_memory_fd_properties_khr: self.get_memory_fd_properties_khr, + } + unsafe impl Send for KhrExternalSemaphoreFdFn {} + unsafe impl Sync for KhrExternalSemaphoreFdFn {} + impl ::std::clone::Clone for KhrExternalSemaphoreFdFn { + fn clone(&self) -> Self { + KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: self.import_semaphore_fd_khr, + get_semaphore_fd_khr: self.get_semaphore_fd_khr, + } } } -} -impl KhrExternalMemoryFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryFdFn { - get_memory_fd_khr: unsafe { - let raw_name = stringify!(vkGetMemoryFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_memory_fd_properties_khr: unsafe { - let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl KhrExternalSemaphoreFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: unsafe { + let raw_name = stringify!(vkImportSemaphoreFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_semaphore_fd_khr: unsafe { + let raw_name = stringify!(vkGetSemaphoreFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } - pub unsafe fn get_memory_fd_khr( - &self, - device: Device, - p_get_fd_info: *const MemoryGetFdInfoKHR, - p_fd: *const c_int, - ) -> Result { - (self.get_memory_fd_khr)(device, p_get_fd_info, p_fd) - } - pub unsafe fn get_memory_fd_properties_khr( - &self, - device: Device, - handle_type: ExternalMemoryHandleTypeFlags, - fd: c_int, - p_memory_fd_properties: *const MemoryFdPropertiesKHR, - ) -> Result { - (self.get_memory_fd_properties_khr)(device, handle_type, fd, p_memory_fd_properties) - } -} -pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , } -unsafe impl Send for KhrExternalSemaphoreWin32Fn {} -unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} -impl ::std::clone::Clone for KhrExternalSemaphoreWin32Fn { - fn clone(&self) -> Self { - KhrExternalSemaphoreWin32Fn { - import_semaphore_win32_handle_khr: self.import_semaphore_win32_handle_khr, - get_semaphore_win32_handle_khr: self.get_semaphore_win32_handle_khr, - } - } -} -impl KhrExternalSemaphoreWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreWin32Fn { - import_semaphore_win32_handle_khr: unsafe { - let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_semaphore_win32_handle_khr: unsafe { - let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn import_semaphore_win32_handle_khr( - &self, - device: Device, - p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, - ) -> Result { - (self.import_semaphore_win32_handle_khr)(device, p_import_semaphore_win32_handle_info) - } - pub unsafe fn get_semaphore_win32_handle_khr( - &self, - device: Device, - p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, - p_handle: *const HANDLE, - ) -> Result { - (self.get_semaphore_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) - } -} -pub struct KhrExternalSemaphoreFdFn { - import_semaphore_fd_khr: - extern "system" fn( + pub unsafe fn import_semaphore_fd_khr( + &self, device: Device, p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result { + (self.import_semaphore_fd_khr)(device, p_import_semaphore_fd_info) + } + pub unsafe fn get_semaphore_fd_khr( + &self, + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result { + (self.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd) + } + } + #[doc = "Generated from \'VK_KHR_external_semaphore_fd\'"] + impl StructureType { + pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = StructureType(1000079000); + } + #[doc = "Generated from \'VK_KHR_external_semaphore_fd\'"] + impl StructureType { + pub const SEMAPHORE_GET_FD_INFO_KHR: Self = StructureType(1000079001); + } + pub struct KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: + extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: uint32_t, + descriptor_write_count: uint32_t, + p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void, + cmd_push_descriptor_set_with_template_khr: + extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void, + } + unsafe impl Send for KhrPushDescriptorFn {} + unsafe impl Sync for KhrPushDescriptorFn {} + impl ::std::clone::Clone for KhrPushDescriptorFn { + fn clone(&self) -> Self { + KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, + } + } + } + impl KhrPushDescriptorFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_push_descriptor_set_with_template_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_push_descriptor_set_khr( + &self, + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: uint32_t, + descriptor_write_count: uint32_t, + p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void { + (self.cmd_push_descriptor_set_khr)( + command_buffer, + pipeline_bind_point, + layout, + set, + descriptor_write_count, + p_descriptor_writes, + ) + } + pub unsafe fn cmd_push_descriptor_set_with_template_khr( + &self, + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void { + (self.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ) + } + } + #[doc = "Generated from \'VK_KHR_push_descriptor\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = StructureType(1000080000); + } + #[doc = "Generated from \'VK_KHR_push_descriptor\'"] + impl DescriptorSetLayoutCreateFlags { + pub const PUSH_DESCRIPTOR_KHR: Self = DescriptorSetLayoutCreateFlags(0b1); + } + pub struct Khr16bitStorageFn {} + unsafe impl Send for Khr16bitStorageFn {} + unsafe impl Sync for Khr16bitStorageFn {} + impl ::std::clone::Clone for Khr16bitStorageFn { + fn clone(&self) -> Self { + Khr16bitStorageFn {} + } + } + impl Khr16bitStorageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = Khr16bitStorageFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrIncrementalPresentFn {} + unsafe impl Send for KhrIncrementalPresentFn {} + unsafe impl Sync for KhrIncrementalPresentFn {} + impl ::std::clone::Clone for KhrIncrementalPresentFn { + fn clone(&self) -> Self { + KhrIncrementalPresentFn {} + } + } + impl KhrIncrementalPresentFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrIncrementalPresentFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_KHR_incremental_present\'"] + impl StructureType { + pub const PRESENT_REGIONS_KHR: Self = StructureType(1000084000); + } + pub struct KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: + extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void, + } + unsafe impl Send for KhrDescriptorUpdateTemplateFn {} + unsafe impl Sync for KhrDescriptorUpdateTemplateFn {} + impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { + fn clone(&self) -> Self { + KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, + } + } + } + impl KhrDescriptorUpdateTemplateFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_push_descriptor_set_with_template_khr( + &self, + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: uint32_t, + p_data: *const c_void, + ) -> c_void { + (self.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ) + } + } + pub struct NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: + extern "system" fn( + command_buffer: CommandBuffer, + p_process_commands_info: *const CmdProcessCommandsInfoNVX, + ) -> c_void, + cmd_reserve_space_for_commands_nvx: + extern "system" fn( + command_buffer: CommandBuffer, + p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, + ) -> c_void, + create_indirect_commands_layout_nvx: + extern "system" fn( + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *const IndirectCommandsLayoutNVX, + ) -> Result, + destroy_indirect_commands_layout_nvx: + extern "system" fn( + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + create_object_table_nvx: extern "system" fn( + device: Device, + p_create_info: *const ObjectTableCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_object_table: *const ObjectTableNVX, ) -> Result, - get_semaphore_fd_khr: extern "system" fn( - device: Device, - p_get_fd_info: *const SemaphoreGetFdInfoKHR, - p_fd: *const c_int, - ) -> Result, -} -unsafe impl Send for KhrExternalSemaphoreFdFn {} -unsafe impl Sync for KhrExternalSemaphoreFdFn {} -impl ::std::clone::Clone for KhrExternalSemaphoreFdFn { - fn clone(&self) -> Self { - KhrExternalSemaphoreFdFn { - import_semaphore_fd_khr: self.import_semaphore_fd_khr, - get_semaphore_fd_khr: self.get_semaphore_fd_khr, - } - } -} -impl KhrExternalSemaphoreFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreFdFn { - import_semaphore_fd_khr: unsafe { - let raw_name = stringify!(vkImportSemaphoreFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_semaphore_fd_khr: unsafe { - let raw_name = stringify!(vkGetSemaphoreFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn import_semaphore_fd_khr( - &self, - device: Device, - p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, - ) -> Result { - (self.import_semaphore_fd_khr)(device, p_import_semaphore_fd_info) - } - pub unsafe fn get_semaphore_fd_khr( - &self, - device: Device, - p_get_fd_info: *const SemaphoreGetFdInfoKHR, - p_fd: *const c_int, - ) -> Result { - (self.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd) - } -} -pub struct KhrPushDescriptorFn { - cmd_push_descriptor_set_khr: extern "system" fn( - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - layout: PipelineLayout, - set: uint32_t, - descriptor_write_count: uint32_t, - p_descriptor_writes: *const WriteDescriptorSet, - ) -> c_void, - cmd_push_descriptor_set_with_template_khr: - extern "system" fn( - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: uint32_t, - p_data: *const c_void, + destroy_object_table_nvx: extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + p_allocator: *const AllocationCallbacks, ) -> c_void, -} -unsafe impl Send for KhrPushDescriptorFn {} -unsafe impl Sync for KhrPushDescriptorFn {} -impl ::std::clone::Clone for KhrPushDescriptorFn { - fn clone(&self) -> Self { - KhrPushDescriptorFn { - cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + register_objects_nvx: + extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + pp_object_table_entries: *const ObjectTableEntryNVX, + p_object_indices: *const uint32_t, + ) -> Result, + unregister_objects_nvx: extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + p_object_entry_types: *const ObjectEntryTypeNVX, + p_object_indices: *const uint32_t, + ) -> Result, + get_physical_device_generated_commands_properties_nvx: + extern "system" fn( + physical_device: PhysicalDevice, + p_features: *const DeviceGeneratedCommandsFeaturesNVX, + p_limits: *const DeviceGeneratedCommandsLimitsNVX, + ) -> c_void, + } + unsafe impl Send for NvxDeviceGeneratedCommandsFn {} + unsafe impl Sync for NvxDeviceGeneratedCommandsFn {} + impl ::std::clone::Clone for NvxDeviceGeneratedCommandsFn { + fn clone(&self) -> Self { + NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: self.cmd_process_commands_nvx, + cmd_reserve_space_for_commands_nvx: self.cmd_reserve_space_for_commands_nvx, + create_indirect_commands_layout_nvx: self.create_indirect_commands_layout_nvx, + destroy_indirect_commands_layout_nvx: self.destroy_indirect_commands_layout_nvx, + create_object_table_nvx: self.create_object_table_nvx, + destroy_object_table_nvx: self.destroy_object_table_nvx, + register_objects_nvx: self.register_objects_nvx, + unregister_objects_nvx: self.unregister_objects_nvx, + get_physical_device_generated_commands_properties_nvx: self + .get_physical_device_generated_commands_properties_nvx, + } } } -} -impl KhrPushDescriptorFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrPushDescriptorFn { - cmd_push_descriptor_set_khr: unsafe { - let raw_name = stringify!(vkCmdPushDescriptorSetKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_push_descriptor_set_with_template_khr: unsafe { - let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl NvxDeviceGeneratedCommandsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: unsafe { + let raw_name = stringify!(vkCmdProcessCommandsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_reserve_space_for_commands_nvx: unsafe { + let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_indirect_commands_layout_nvx: unsafe { + let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_indirect_commands_layout_nvx: unsafe { + let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_object_table_nvx: unsafe { + let raw_name = stringify!(vkCreateObjectTableNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_object_table_nvx: unsafe { + let raw_name = stringify!(vkDestroyObjectTableNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_objects_nvx: unsafe { + let raw_name = stringify!(vkRegisterObjectsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + unregister_objects_nvx: unsafe { + let raw_name = stringify!(vkUnregisterObjectsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_generated_commands_properties_nvx: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } - pub unsafe fn cmd_push_descriptor_set_khr( - &self, - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - layout: PipelineLayout, - set: uint32_t, - descriptor_write_count: uint32_t, - p_descriptor_writes: *const WriteDescriptorSet, - ) -> c_void { - (self.cmd_push_descriptor_set_khr)( - command_buffer, - pipeline_bind_point, - layout, - set, - descriptor_write_count, - p_descriptor_writes, - ) - } - pub unsafe fn cmd_push_descriptor_set_with_template_khr( - &self, - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: uint32_t, - p_data: *const c_void, - ) -> c_void { - (self.cmd_push_descriptor_set_with_template_khr)( - command_buffer, - descriptor_update_template, - layout, - set, - p_data, - ) - } -} -pub struct KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: - extern "system" fn( - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: uint32_t, - p_data: *const c_void, - ) -> c_void, -} -unsafe impl Send for KhrDescriptorUpdateTemplateFn {} -unsafe impl Sync for KhrDescriptorUpdateTemplateFn {} -impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { - fn clone(&self) -> Self { - KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, - } - } -} -impl KhrDescriptorUpdateTemplateFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: unsafe { - let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_push_descriptor_set_with_template_khr( - &self, - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: uint32_t, - p_data: *const c_void, - ) -> c_void { - (self.cmd_push_descriptor_set_with_template_khr)( - command_buffer, - descriptor_update_template, - layout, - set, - p_data, - ) - } -} -pub struct NvxDeviceGeneratedCommandsFn { - cmd_process_commands_nvx: - extern "system" fn( + pub unsafe fn cmd_process_commands_nvx( + &self, command_buffer: CommandBuffer, p_process_commands_info: *const CmdProcessCommandsInfoNVX, - ) -> c_void, - cmd_reserve_space_for_commands_nvx: - extern "system" fn( + ) -> c_void { + (self.cmd_process_commands_nvx)(command_buffer, p_process_commands_info) + } + pub unsafe fn cmd_reserve_space_for_commands_nvx( + &self, command_buffer: CommandBuffer, p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, - ) -> c_void, - create_indirect_commands_layout_nvx: - extern "system" fn( + ) -> c_void { + (self.cmd_reserve_space_for_commands_nvx)(command_buffer, p_reserve_space_info) + } + pub unsafe fn create_indirect_commands_layout_nvx( + &self, device: Device, p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, p_allocator: *const AllocationCallbacks, p_indirect_commands_layout: *const IndirectCommandsLayoutNVX, - ) -> Result, - destroy_indirect_commands_layout_nvx: - extern "system" fn( + ) -> Result { + (self.create_indirect_commands_layout_nvx)( + device, + p_create_info, + p_allocator, + p_indirect_commands_layout, + ) + } + pub unsafe fn destroy_indirect_commands_layout_nvx( + &self, device: Device, indirect_commands_layout: IndirectCommandsLayoutNVX, p_allocator: *const AllocationCallbacks, - ) -> c_void, - create_object_table_nvx: extern "system" fn( - device: Device, - p_create_info: *const ObjectTableCreateInfoNVX, - p_allocator: *const AllocationCallbacks, - p_object_table: *const ObjectTableNVX, - ) -> Result, - destroy_object_table_nvx: extern "system" fn( - device: Device, - object_table: ObjectTableNVX, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - register_objects_nvx: extern "system" fn( - device: Device, - object_table: ObjectTableNVX, - object_count: uint32_t, - pp_object_table_entries: *const ObjectTableEntryNVX, - p_object_indices: *const uint32_t, - ) -> Result, - unregister_objects_nvx: extern "system" fn( - device: Device, - object_table: ObjectTableNVX, - object_count: uint32_t, - p_object_entry_types: *const ObjectEntryTypeNVX, - p_object_indices: *const uint32_t, - ) -> Result, - get_physical_device_generated_commands_properties_nvx: - extern "system" fn( + ) -> c_void { + (self.destroy_indirect_commands_layout_nvx)( + device, + indirect_commands_layout, + p_allocator, + ) + } + pub unsafe fn create_object_table_nvx( + &self, + device: Device, + p_create_info: *const ObjectTableCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_object_table: *const ObjectTableNVX, + ) -> Result { + (self.create_object_table_nvx)(device, p_create_info, p_allocator, p_object_table) + } + pub unsafe fn destroy_object_table_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_object_table_nvx)(device, object_table, p_allocator) + } + pub unsafe fn register_objects_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + pp_object_table_entries: *const ObjectTableEntryNVX, + p_object_indices: *const uint32_t, + ) -> Result { + (self.register_objects_nvx)( + device, + object_table, + object_count, + pp_object_table_entries, + p_object_indices, + ) + } + pub unsafe fn unregister_objects_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + object_count: uint32_t, + p_object_entry_types: *const ObjectEntryTypeNVX, + p_object_indices: *const uint32_t, + ) -> Result { + (self.unregister_objects_nvx)( + device, + object_table, + object_count, + p_object_entry_types, + p_object_indices, + ) + } + pub unsafe fn get_physical_device_generated_commands_properties_nvx( + &self, physical_device: PhysicalDevice, p_features: *const DeviceGeneratedCommandsFeaturesNVX, p_limits: *const DeviceGeneratedCommandsLimitsNVX, - ) -> c_void, -} -unsafe impl Send for NvxDeviceGeneratedCommandsFn {} -unsafe impl Sync for NvxDeviceGeneratedCommandsFn {} -impl ::std::clone::Clone for NvxDeviceGeneratedCommandsFn { - fn clone(&self) -> Self { - NvxDeviceGeneratedCommandsFn { - cmd_process_commands_nvx: self.cmd_process_commands_nvx, - cmd_reserve_space_for_commands_nvx: self.cmd_reserve_space_for_commands_nvx, - create_indirect_commands_layout_nvx: self.create_indirect_commands_layout_nvx, - destroy_indirect_commands_layout_nvx: self.destroy_indirect_commands_layout_nvx, - create_object_table_nvx: self.create_object_table_nvx, - destroy_object_table_nvx: self.destroy_object_table_nvx, - register_objects_nvx: self.register_objects_nvx, - unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: self - .get_physical_device_generated_commands_properties_nvx, + ) -> c_void { + (self.get_physical_device_generated_commands_properties_nvx)( + physical_device, + p_features, + p_limits, + ) } } -} -impl NvxDeviceGeneratedCommandsFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxDeviceGeneratedCommandsFn { - cmd_process_commands_nvx: unsafe { - let raw_name = stringify!(vkCmdProcessCommandsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_reserve_space_for_commands_nvx: unsafe { - let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_indirect_commands_layout_nvx: unsafe { - let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_indirect_commands_layout_nvx: unsafe { - let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_object_table_nvx: unsafe { - let raw_name = stringify!(vkCreateObjectTableNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_object_table_nvx: unsafe { - let raw_name = stringify!(vkDestroyObjectTableNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - register_objects_nvx: unsafe { - let raw_name = stringify!(vkRegisterObjectsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - unregister_objects_nvx: unsafe { - let raw_name = stringify!(vkUnregisterObjectsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_generated_commands_properties_nvx: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl StructureType { + pub const OBJECT_TABLE_CREATE_INFO_NVX: Self = StructureType(1000086000); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl StructureType { + pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: Self = StructureType(1000086001); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl StructureType { + pub const CMD_PROCESS_COMMANDS_INFO_NVX: Self = StructureType(1000086002); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl StructureType { + pub const CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX: Self = StructureType(1000086003); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl StructureType { + pub const DEVICE_GENERATED_COMMANDS_LIMITS_NVX: Self = StructureType(1000086004); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl StructureType { + pub const DEVICE_GENERATED_COMMANDS_FEATURES_NVX: Self = StructureType(1000086005); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl PipelineStageFlags { + pub const COMMAND_PROCESS_NVX: Self = PipelineStageFlags(0b100000000000000000); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl AccessFlags { + pub const COMMAND_PROCESS_READ_NVX: Self = AccessFlags(0b100000000000000000); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl AccessFlags { + pub const COMMAND_PROCESS_WRITE_NVX: Self = AccessFlags(0b1000000000000000000); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl ObjectType { + pub const OBJECT_TABLE_NVX: Self = ObjectType(1000086000); + } + #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] + impl ObjectType { + pub const INDIRECT_COMMANDS_LAYOUT_NVX: Self = ObjectType(1000086001); + } + pub struct NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: + extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: uint32_t, + viewport_count: uint32_t, + p_viewport_w_scalings: *const ViewportWScalingNV, + ) -> c_void, + } + unsafe impl Send for NvClipSpaceWScalingFn {} + unsafe impl Sync for NvClipSpaceWScalingFn {} + impl ::std::clone::Clone for NvClipSpaceWScalingFn { + fn clone(&self) -> Self { + NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: self.cmd_set_viewport_w_scaling_nv, + } } } - pub unsafe fn cmd_process_commands_nvx( - &self, - command_buffer: CommandBuffer, - p_process_commands_info: *const CmdProcessCommandsInfoNVX, - ) -> c_void { - (self.cmd_process_commands_nvx)(command_buffer, p_process_commands_info) - } - pub unsafe fn cmd_reserve_space_for_commands_nvx( - &self, - command_buffer: CommandBuffer, - p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, - ) -> c_void { - (self.cmd_reserve_space_for_commands_nvx)(command_buffer, p_reserve_space_info) - } - pub unsafe fn create_indirect_commands_layout_nvx( - &self, - device: Device, - p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, - p_allocator: *const AllocationCallbacks, - p_indirect_commands_layout: *const IndirectCommandsLayoutNVX, - ) -> Result { - (self.create_indirect_commands_layout_nvx)( - device, - p_create_info, - p_allocator, - p_indirect_commands_layout, - ) - } - pub unsafe fn destroy_indirect_commands_layout_nvx( - &self, - device: Device, - indirect_commands_layout: IndirectCommandsLayoutNVX, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_indirect_commands_layout_nvx)(device, indirect_commands_layout, p_allocator) - } - pub unsafe fn create_object_table_nvx( - &self, - device: Device, - p_create_info: *const ObjectTableCreateInfoNVX, - p_allocator: *const AllocationCallbacks, - p_object_table: *const ObjectTableNVX, - ) -> Result { - (self.create_object_table_nvx)(device, p_create_info, p_allocator, p_object_table) - } - pub unsafe fn destroy_object_table_nvx( - &self, - device: Device, - object_table: ObjectTableNVX, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_object_table_nvx)(device, object_table, p_allocator) - } - pub unsafe fn register_objects_nvx( - &self, - device: Device, - object_table: ObjectTableNVX, - object_count: uint32_t, - pp_object_table_entries: *const ObjectTableEntryNVX, - p_object_indices: *const uint32_t, - ) -> Result { - (self.register_objects_nvx)( - device, - object_table, - object_count, - pp_object_table_entries, - p_object_indices, - ) - } - pub unsafe fn unregister_objects_nvx( - &self, - device: Device, - object_table: ObjectTableNVX, - object_count: uint32_t, - p_object_entry_types: *const ObjectEntryTypeNVX, - p_object_indices: *const uint32_t, - ) -> Result { - (self.unregister_objects_nvx)( - device, - object_table, - object_count, - p_object_entry_types, - p_object_indices, - ) - } - pub unsafe fn get_physical_device_generated_commands_properties_nvx( - &self, - physical_device: PhysicalDevice, - p_features: *const DeviceGeneratedCommandsFeaturesNVX, - p_limits: *const DeviceGeneratedCommandsLimitsNVX, - ) -> c_void { - (self.get_physical_device_generated_commands_properties_nvx)( - physical_device, - p_features, - p_limits, - ) - } -} -pub struct NvClipSpaceWScalingFn { - cmd_set_viewport_w_scaling_nv: - extern "system" fn( + impl NvClipSpaceWScalingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: unsafe { + let raw_name = stringify!(vkCmdSetViewportWScalingNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_set_viewport_w_scaling_nv( + &self, command_buffer: CommandBuffer, first_viewport: uint32_t, viewport_count: uint32_t, p_viewport_w_scalings: *const ViewportWScalingNV, - ) -> c_void, -} -unsafe impl Send for NvClipSpaceWScalingFn {} -unsafe impl Sync for NvClipSpaceWScalingFn {} -impl ::std::clone::Clone for NvClipSpaceWScalingFn { - fn clone(&self) -> Self { - NvClipSpaceWScalingFn { - cmd_set_viewport_w_scaling_nv: self.cmd_set_viewport_w_scaling_nv, + ) -> c_void { + (self.cmd_set_viewport_w_scaling_nv)( + command_buffer, + first_viewport, + viewport_count, + p_viewport_w_scalings, + ) } } -} -impl NvClipSpaceWScalingFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvClipSpaceWScalingFn { - cmd_set_viewport_w_scaling_nv: unsafe { - let raw_name = stringify!(vkCmdSetViewportWScalingNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_NV_clip_space_w_scaling\'"] + impl StructureType { + pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = + StructureType(1000087000); + } + #[doc = "Generated from \'VK_NV_clip_space_w_scaling\'"] + impl DynamicState { + pub const VIEWPORT_W_SCALING_NV: Self = DynamicState(1000087000); + } + pub struct ExtDirectModeDisplayFn { + release_display_ext: + extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result, + } + unsafe impl Send for ExtDirectModeDisplayFn {} + unsafe impl Sync for ExtDirectModeDisplayFn {} + impl ::std::clone::Clone for ExtDirectModeDisplayFn { + fn clone(&self) -> Self { + ExtDirectModeDisplayFn { + release_display_ext: self.release_display_ext, + } } } - pub unsafe fn cmd_set_viewport_w_scaling_nv( - &self, - command_buffer: CommandBuffer, - first_viewport: uint32_t, - viewport_count: uint32_t, - p_viewport_w_scalings: *const ViewportWScalingNV, - ) -> c_void { - (self.cmd_set_viewport_w_scaling_nv)( - command_buffer, - first_viewport, - viewport_count, - p_viewport_w_scalings, - ) - } -} -pub struct ExtDirectModeDisplayFn { - release_display_ext: - extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result, -} -unsafe impl Send for ExtDirectModeDisplayFn {} -unsafe impl Sync for ExtDirectModeDisplayFn {} -impl ::std::clone::Clone for ExtDirectModeDisplayFn { - fn clone(&self) -> Self { - ExtDirectModeDisplayFn { - release_display_ext: self.release_display_ext, + impl ExtDirectModeDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDirectModeDisplayFn { + release_display_ext: unsafe { + let raw_name = stringify!(vkReleaseDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn release_display_ext( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + ) -> Result { + (self.release_display_ext)(physical_device, display) } } -} -impl ExtDirectModeDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDirectModeDisplayFn { - release_display_ext: unsafe { - let raw_name = stringify!(vkReleaseDisplayEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + pub struct ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: extern "system" fn( + physical_device: PhysicalDevice, + dpy: *const Display, + display: DisplayKHR, + ) -> Result, + get_rand_r_output_display_ext: extern "system" fn( + physical_device: PhysicalDevice, + dpy: *const Display, + rr_output: RROutput, + p_display: *const DisplayKHR, + ) -> Result, + } + unsafe impl Send for ExtAcquireXlibDisplayFn {} + unsafe impl Sync for ExtAcquireXlibDisplayFn {} + impl ::std::clone::Clone for ExtAcquireXlibDisplayFn { + fn clone(&self) -> Self { + ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: self.acquire_xlib_display_ext, + get_rand_r_output_display_ext: self.get_rand_r_output_display_ext, + } } } - pub unsafe fn release_display_ext( - &self, - physical_device: PhysicalDevice, - display: DisplayKHR, - ) -> Result { - (self.release_display_ext)(physical_device, display) - } -} -pub struct ExtAcquireXlibDisplayFn { - acquire_xlib_display_ext: extern "system" fn( - physical_device: PhysicalDevice, - dpy: *const Display, - display: DisplayKHR, - ) -> Result, - get_rand_r_output_display_ext: extern "system" fn( - physical_device: PhysicalDevice, - dpy: *const Display, - rr_output: RROutput, - p_display: *const DisplayKHR, - ) -> Result, -} -unsafe impl Send for ExtAcquireXlibDisplayFn {} -unsafe impl Sync for ExtAcquireXlibDisplayFn {} -impl ::std::clone::Clone for ExtAcquireXlibDisplayFn { - fn clone(&self) -> Self { - ExtAcquireXlibDisplayFn { - acquire_xlib_display_ext: self.acquire_xlib_display_ext, - get_rand_r_output_display_ext: self.get_rand_r_output_display_ext, + impl ExtAcquireXlibDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: unsafe { + let raw_name = stringify!(vkAcquireXlibDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_rand_r_output_display_ext: unsafe { + let raw_name = stringify!(vkGetRandROutputDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn acquire_xlib_display_ext( + &self, + physical_device: PhysicalDevice, + dpy: *const Display, + display: DisplayKHR, + ) -> Result { + (self.acquire_xlib_display_ext)(physical_device, dpy, display) + } + pub unsafe fn get_rand_r_output_display_ext( + &self, + physical_device: PhysicalDevice, + dpy: *const Display, + rr_output: RROutput, + p_display: *const DisplayKHR, + ) -> Result { + (self.get_rand_r_output_display_ext)(physical_device, dpy, rr_output, p_display) } } -} -impl ExtAcquireXlibDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtAcquireXlibDisplayFn { - acquire_xlib_display_ext: unsafe { - let raw_name = stringify!(vkAcquireXlibDisplayEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_rand_r_output_display_ext: unsafe { - let raw_name = stringify!(vkGetRandROutputDisplayEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + pub struct ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: + extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *const SurfaceCapabilities2EXT, + ) -> Result, + } + unsafe impl Send for ExtDisplaySurfaceCounterFn {} + unsafe impl Sync for ExtDisplaySurfaceCounterFn {} + impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { + fn clone(&self) -> Self { + ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: self + .get_physical_device_surface_capabilities2_ext, + } } } - pub unsafe fn acquire_xlib_display_ext( - &self, - physical_device: PhysicalDevice, - dpy: *const Display, - display: DisplayKHR, - ) -> Result { - (self.acquire_xlib_display_ext)(physical_device, dpy, display) - } - pub unsafe fn get_rand_r_output_display_ext( - &self, - physical_device: PhysicalDevice, - dpy: *const Display, - rr_output: RROutput, - p_display: *const DisplayKHR, - ) -> Result { - (self.get_rand_r_output_display_ext)(physical_device, dpy, rr_output, p_display) - } -} -pub struct ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: - extern "system" fn( + impl ExtDisplaySurfaceCounterFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_surface_capabilities2_ext( + &self, physical_device: PhysicalDevice, surface: SurfaceKHR, p_surface_capabilities: *const SurfaceCapabilities2EXT, + ) -> Result { + (self.get_physical_device_surface_capabilities2_ext)( + physical_device, + surface, + p_surface_capabilities, + ) + } + } + #[doc = "Generated from \'VK_EXT_display_surface_counter\'"] + impl StructureType { + pub const SURFACE_CAPABILITIES_2_EXT: Self = StructureType(1000090000); + } + pub struct ExtDisplayControlFn { + display_power_control_ext: + extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result, + register_device_event_ext: + extern "system" fn( + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result, + register_display_event_ext: + extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_event_info: *const DisplayEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result, + get_swapchain_counter_ext: extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *const uint64_t, ) -> Result, -} -unsafe impl Send for ExtDisplaySurfaceCounterFn {} -unsafe impl Sync for ExtDisplaySurfaceCounterFn {} -impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { - fn clone(&self) -> Self { - ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: self - .get_physical_device_surface_capabilities2_ext, + } + unsafe impl Send for ExtDisplayControlFn {} + unsafe impl Sync for ExtDisplayControlFn {} + impl ::std::clone::Clone for ExtDisplayControlFn { + fn clone(&self) -> Self { + ExtDisplayControlFn { + display_power_control_ext: self.display_power_control_ext, + register_device_event_ext: self.register_device_event_ext, + register_display_event_ext: self.register_display_event_ext, + get_swapchain_counter_ext: self.get_swapchain_counter_ext, + } } } -} -impl ExtDisplaySurfaceCounterFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl ExtDisplayControlFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDisplayControlFn { + display_power_control_ext: unsafe { + let raw_name = stringify!(vkDisplayPowerControlEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_device_event_ext: unsafe { + let raw_name = stringify!(vkRegisterDeviceEventEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_display_event_ext: unsafe { + let raw_name = stringify!(vkRegisterDisplayEventEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_swapchain_counter_ext: unsafe { + let raw_name = stringify!(vkGetSwapchainCounterEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } - pub unsafe fn get_physical_device_surface_capabilities2_ext( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_capabilities: *const SurfaceCapabilities2EXT, - ) -> Result { - (self.get_physical_device_surface_capabilities2_ext)( - physical_device, - surface, - p_surface_capabilities, - ) - } -} -pub struct ExtDisplayControlFn { - display_power_control_ext: extern "system" fn( - device: Device, - display: DisplayKHR, - p_display_power_info: *const DisplayPowerInfoEXT, - ) -> Result, - register_device_event_ext: extern "system" fn( - device: Device, - p_device_event_info: *const DeviceEventInfoEXT, - p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, - ) -> Result, - register_display_event_ext: - extern "system" fn( + pub unsafe fn display_power_control_ext( + &self, + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result { + (self.display_power_control_ext)(device, display, p_display_power_info) + } + pub unsafe fn register_device_event_ext( + &self, + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *const Fence, + ) -> Result { + (self.register_device_event_ext)(device, p_device_event_info, p_allocator, p_fence) + } + pub unsafe fn register_display_event_ext( + &self, device: Device, display: DisplayKHR, p_display_event_info: *const DisplayEventInfoEXT, p_allocator: *const AllocationCallbacks, p_fence: *const Fence, - ) -> Result, - get_swapchain_counter_ext: extern "system" fn( - device: Device, - swapchain: SwapchainKHR, - counter: SurfaceCounterFlagsEXT, - p_counter_value: *const uint64_t, - ) -> Result, -} -unsafe impl Send for ExtDisplayControlFn {} -unsafe impl Sync for ExtDisplayControlFn {} -impl ::std::clone::Clone for ExtDisplayControlFn { - fn clone(&self) -> Self { - ExtDisplayControlFn { - display_power_control_ext: self.display_power_control_ext, - register_device_event_ext: self.register_device_event_ext, - register_display_event_ext: self.register_display_event_ext, - get_swapchain_counter_ext: self.get_swapchain_counter_ext, + ) -> Result { + (self.register_display_event_ext)( + device, + display, + p_display_event_info, + p_allocator, + p_fence, + ) + } + pub unsafe fn get_swapchain_counter_ext( + &self, + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *const uint64_t, + ) -> Result { + (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value) } } -} -impl ExtDisplayControlFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDisplayControlFn { - display_power_control_ext: unsafe { - let raw_name = stringify!(vkDisplayPowerControlEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - register_device_event_ext: unsafe { - let raw_name = stringify!(vkRegisterDeviceEventEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - register_display_event_ext: unsafe { - let raw_name = stringify!(vkRegisterDisplayEventEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_swapchain_counter_ext: unsafe { - let raw_name = stringify!(vkGetSwapchainCounterEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_EXT_display_control\'"] + impl StructureType { + pub const DISPLAY_POWER_INFO_EXT: Self = StructureType(1000091000); + } + #[doc = "Generated from \'VK_EXT_display_control\'"] + impl StructureType { + pub const DEVICE_EVENT_INFO_EXT: Self = StructureType(1000091001); + } + #[doc = "Generated from \'VK_EXT_display_control\'"] + impl StructureType { + pub const DISPLAY_EVENT_INFO_EXT: Self = StructureType(1000091002); + } + #[doc = "Generated from \'VK_EXT_display_control\'"] + impl StructureType { + pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = StructureType(1000091003); + } + pub struct GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: + extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_display_timing_properties: *const RefreshCycleDurationGOOGLE, + ) -> Result, + get_past_presentation_timing_google: + extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_presentation_timing_count: *const uint32_t, + p_presentation_timings: *const PastPresentationTimingGOOGLE, + ) -> Result, + } + unsafe impl Send for GoogleDisplayTimingFn {} + unsafe impl Sync for GoogleDisplayTimingFn {} + impl ::std::clone::Clone for GoogleDisplayTimingFn { + fn clone(&self) -> Self { + GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: self.get_refresh_cycle_duration_google, + get_past_presentation_timing_google: self.get_past_presentation_timing_google, + } } } - pub unsafe fn display_power_control_ext( - &self, - device: Device, - display: DisplayKHR, - p_display_power_info: *const DisplayPowerInfoEXT, - ) -> Result { - (self.display_power_control_ext)(device, display, p_display_power_info) - } - pub unsafe fn register_device_event_ext( - &self, - device: Device, - p_device_event_info: *const DeviceEventInfoEXT, - p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, - ) -> Result { - (self.register_device_event_ext)(device, p_device_event_info, p_allocator, p_fence) - } - pub unsafe fn register_display_event_ext( - &self, - device: Device, - display: DisplayKHR, - p_display_event_info: *const DisplayEventInfoEXT, - p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, - ) -> Result { - (self.register_display_event_ext)( - device, - display, - p_display_event_info, - p_allocator, - p_fence, - ) - } - pub unsafe fn get_swapchain_counter_ext( - &self, - device: Device, - swapchain: SwapchainKHR, - counter: SurfaceCounterFlagsEXT, - p_counter_value: *const uint64_t, - ) -> Result { - (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value) - } -} -pub struct GoogleDisplayTimingFn { - get_refresh_cycle_duration_google: - extern "system" fn( + impl GoogleDisplayTimingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: unsafe { + let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_past_presentation_timing_google: unsafe { + let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_refresh_cycle_duration_google( + &self, device: Device, swapchain: SwapchainKHR, p_display_timing_properties: *const RefreshCycleDurationGOOGLE, - ) -> Result, - get_past_presentation_timing_google: - extern "system" fn( + ) -> Result { + (self.get_refresh_cycle_duration_google)(device, swapchain, p_display_timing_properties) + } + pub unsafe fn get_past_presentation_timing_google( + &self, device: Device, swapchain: SwapchainKHR, p_presentation_timing_count: *const uint32_t, p_presentation_timings: *const PastPresentationTimingGOOGLE, - ) -> Result, -} -unsafe impl Send for GoogleDisplayTimingFn {} -unsafe impl Sync for GoogleDisplayTimingFn {} -impl ::std::clone::Clone for GoogleDisplayTimingFn { - fn clone(&self) -> Self { - GoogleDisplayTimingFn { - get_refresh_cycle_duration_google: self.get_refresh_cycle_duration_google, - get_past_presentation_timing_google: self.get_past_presentation_timing_google, + ) -> Result { + (self.get_past_presentation_timing_google)( + device, + swapchain, + p_presentation_timing_count, + p_presentation_timings, + ) } } -} -impl GoogleDisplayTimingFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleDisplayTimingFn { - get_refresh_cycle_duration_google: unsafe { - let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_past_presentation_timing_google: unsafe { - let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_GOOGLE_display_timing\'"] + impl StructureType { + pub const PRESENT_TIMES_INFO_GOOGLE: Self = StructureType(1000092000); + } + pub struct NvSampleMaskOverrideCoverageFn {} + unsafe impl Send for NvSampleMaskOverrideCoverageFn {} + unsafe impl Sync for NvSampleMaskOverrideCoverageFn {} + impl ::std::clone::Clone for NvSampleMaskOverrideCoverageFn { + fn clone(&self) -> Self { + NvSampleMaskOverrideCoverageFn {} } } - pub unsafe fn get_refresh_cycle_duration_google( - &self, - device: Device, - swapchain: SwapchainKHR, - p_display_timing_properties: *const RefreshCycleDurationGOOGLE, - ) -> Result { - (self.get_refresh_cycle_duration_google)(device, swapchain, p_display_timing_properties) - } - pub unsafe fn get_past_presentation_timing_google( - &self, - device: Device, - swapchain: SwapchainKHR, - p_presentation_timing_count: *const uint32_t, - p_presentation_timings: *const PastPresentationTimingGOOGLE, - ) -> Result { - (self.get_past_presentation_timing_google)( - device, - swapchain, - p_presentation_timing_count, - p_presentation_timings, - ) - } -} -pub struct ExtDiscardRectanglesFn { - cmd_set_discard_rectangle_ext: extern "system" fn( - command_buffer: CommandBuffer, - first_discard_rectangle: uint32_t, - discard_rectangle_count: uint32_t, - p_discard_rectangles: *const Rect2D, - ) -> c_void, -} -unsafe impl Send for ExtDiscardRectanglesFn {} -unsafe impl Sync for ExtDiscardRectanglesFn {} -impl ::std::clone::Clone for ExtDiscardRectanglesFn { - fn clone(&self) -> Self { - ExtDiscardRectanglesFn { - cmd_set_discard_rectangle_ext: self.cmd_set_discard_rectangle_ext, + impl NvSampleMaskOverrideCoverageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvSampleMaskOverrideCoverageFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } -} -impl ExtDiscardRectanglesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDiscardRectanglesFn { - cmd_set_discard_rectangle_ext: unsafe { - let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + pub struct NvGeometryShaderPassthroughFn {} + unsafe impl Send for NvGeometryShaderPassthroughFn {} + unsafe impl Sync for NvGeometryShaderPassthroughFn {} + impl ::std::clone::Clone for NvGeometryShaderPassthroughFn { + fn clone(&self) -> Self { + NvGeometryShaderPassthroughFn {} } } - pub unsafe fn cmd_set_discard_rectangle_ext( - &self, - command_buffer: CommandBuffer, - first_discard_rectangle: uint32_t, - discard_rectangle_count: uint32_t, - p_discard_rectangles: *const Rect2D, - ) -> c_void { - (self.cmd_set_discard_rectangle_ext)( - command_buffer, - first_discard_rectangle, - discard_rectangle_count, - p_discard_rectangles, - ) - } -} -pub struct ExtHdrMetadataFn { - set_hdr_metadata_ext: extern "system" fn( - device: Device, - swapchain_count: uint32_t, - p_swapchains: *const SwapchainKHR, - p_metadata: *const HdrMetadataEXT, - ) -> c_void, -} -unsafe impl Send for ExtHdrMetadataFn {} -unsafe impl Sync for ExtHdrMetadataFn {} -impl ::std::clone::Clone for ExtHdrMetadataFn { - fn clone(&self) -> Self { - ExtHdrMetadataFn { - set_hdr_metadata_ext: self.set_hdr_metadata_ext, + impl NvGeometryShaderPassthroughFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvGeometryShaderPassthroughFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } -} -impl ExtHdrMetadataFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtHdrMetadataFn { - set_hdr_metadata_ext: unsafe { - let raw_name = stringify!(vkSetHdrMetadataEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + pub struct NvViewportArray2Fn {} + unsafe impl Send for NvViewportArray2Fn {} + unsafe impl Sync for NvViewportArray2Fn {} + impl ::std::clone::Clone for NvViewportArray2Fn { + fn clone(&self) -> Self { + NvViewportArray2Fn {} } } - pub unsafe fn set_hdr_metadata_ext( - &self, - device: Device, - swapchain_count: uint32_t, - p_swapchains: *const SwapchainKHR, - p_metadata: *const HdrMetadataEXT, - ) -> c_void { - (self.set_hdr_metadata_ext)(device, swapchain_count, p_swapchains, p_metadata) - } -} -pub struct KhrSharedPresentableImageFn { - get_swapchain_status_khr: extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, -} -unsafe impl Send for KhrSharedPresentableImageFn {} -unsafe impl Sync for KhrSharedPresentableImageFn {} -impl ::std::clone::Clone for KhrSharedPresentableImageFn { - fn clone(&self) -> Self { - KhrSharedPresentableImageFn { - get_swapchain_status_khr: self.get_swapchain_status_khr, + impl NvViewportArray2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvViewportArray2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } -} -impl KhrSharedPresentableImageFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSharedPresentableImageFn { - get_swapchain_status_khr: unsafe { - let raw_name = stringify!(vkGetSwapchainStatusKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + pub struct NvxMultiviewPerViewAttributesFn {} + unsafe impl Send for NvxMultiviewPerViewAttributesFn {} + unsafe impl Sync for NvxMultiviewPerViewAttributesFn {} + impl ::std::clone::Clone for NvxMultiviewPerViewAttributesFn { + fn clone(&self) -> Self { + NvxMultiviewPerViewAttributesFn {} } } - pub unsafe fn get_swapchain_status_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - ) -> Result { - (self.get_swapchain_status_khr)(device, swapchain) + impl NvxMultiviewPerViewAttributesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxMultiviewPerViewAttributesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } } -} -pub struct KhrExternalFenceWin32Fn { - import_fence_win32_handle_khr: - extern "system" fn( + #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self = + StructureType(1000097000); + } + #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] + impl SubpassDescriptionFlags { + pub const PER_VIEW_ATTRIBUTES_NVX: Self = SubpassDescriptionFlags(0b1); + } + #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] + impl SubpassDescriptionFlags { + pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = SubpassDescriptionFlags(0b10); + } + pub struct NvViewportSwizzleFn {} + unsafe impl Send for NvViewportSwizzleFn {} + unsafe impl Sync for NvViewportSwizzleFn {} + impl ::std::clone::Clone for NvViewportSwizzleFn { + fn clone(&self) -> Self { + NvViewportSwizzleFn {} + } + } + impl NvViewportSwizzleFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvViewportSwizzleFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_NV_viewport_swizzle\'"] + impl StructureType { + pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = StructureType(1000098000); + } + pub struct ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: extern "system" fn( + command_buffer: CommandBuffer, + first_discard_rectangle: uint32_t, + discard_rectangle_count: uint32_t, + p_discard_rectangles: *const Rect2D, + ) -> c_void, + } + unsafe impl Send for ExtDiscardRectanglesFn {} + unsafe impl Sync for ExtDiscardRectanglesFn {} + impl ::std::clone::Clone for ExtDiscardRectanglesFn { + fn clone(&self) -> Self { + ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: self.cmd_set_discard_rectangle_ext, + } + } + } + impl ExtDiscardRectanglesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: unsafe { + let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_set_discard_rectangle_ext( + &self, + command_buffer: CommandBuffer, + first_discard_rectangle: uint32_t, + discard_rectangle_count: uint32_t, + p_discard_rectangles: *const Rect2D, + ) -> c_void { + (self.cmd_set_discard_rectangle_ext)( + command_buffer, + first_discard_rectangle, + discard_rectangle_count, + p_discard_rectangles, + ) + } + } + #[doc = "Generated from \'VK_EXT_discard_rectangles\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = + StructureType(1000099000); + } + #[doc = "Generated from \'VK_EXT_discard_rectangles\'"] + impl StructureType { + pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = + StructureType(1000099001); + } + #[doc = "Generated from \'VK_EXT_discard_rectangles\'"] + impl DynamicState { + pub const DISCARD_RECTANGLE_EXT: Self = DynamicState(1000099000); + } + pub struct ExtConservativeRasterizationFn {} + unsafe impl Send for ExtConservativeRasterizationFn {} + unsafe impl Sync for ExtConservativeRasterizationFn {} + impl ::std::clone::Clone for ExtConservativeRasterizationFn { + fn clone(&self) -> Self { + ExtConservativeRasterizationFn {} + } + } + impl ExtConservativeRasterizationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtConservativeRasterizationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = + StructureType(1000101000); + } + #[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] + impl StructureType { + pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = + StructureType(1000101001); + } + pub struct ExtSwapchainColorspaceFn {} + unsafe impl Send for ExtSwapchainColorspaceFn {} + unsafe impl Sync for ExtSwapchainColorspaceFn {} + impl ::std::clone::Clone for ExtSwapchainColorspaceFn { + fn clone(&self) -> Self { + ExtSwapchainColorspaceFn {} + } + } + impl ExtSwapchainColorspaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtSwapchainColorspaceFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104001); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104002); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_DCI_P3_LINEAR_EXT: Self = ColorSpaceKHR(1000104003); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_DCI_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104004); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_BT709_LINEAR_EXT: Self = ColorSpaceKHR(1000104005); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_BT709_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104006); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_BT2020_LINEAR_EXT: Self = ColorSpaceKHR(1000104007); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_HDR10_ST2084_EXT: Self = ColorSpaceKHR(1000104008); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_DOLBYVISION_EXT: Self = ColorSpaceKHR(1000104009); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_HDR10_HLG_EXT: Self = ColorSpaceKHR(1000104010); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_ADOBERGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104011); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_ADOBERGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104012); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_PASS_THROUGH_EXT: Self = ColorSpaceKHR(1000104013); + } + #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] + impl ColorSpaceKHR { + pub const COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104014); + } + pub struct ExtHdrMetadataFn { + set_hdr_metadata_ext: extern "system" fn( + device: Device, + swapchain_count: uint32_t, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, + ) -> c_void, + } + unsafe impl Send for ExtHdrMetadataFn {} + unsafe impl Sync for ExtHdrMetadataFn {} + impl ::std::clone::Clone for ExtHdrMetadataFn { + fn clone(&self) -> Self { + ExtHdrMetadataFn { + set_hdr_metadata_ext: self.set_hdr_metadata_ext, + } + } + } + impl ExtHdrMetadataFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtHdrMetadataFn { + set_hdr_metadata_ext: unsafe { + let raw_name = stringify!(vkSetHdrMetadataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn set_hdr_metadata_ext( + &self, + device: Device, + swapchain_count: uint32_t, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, + ) -> c_void { + (self.set_hdr_metadata_ext)(device, swapchain_count, p_swapchains, p_metadata) + } + } + #[doc = "Generated from \'VK_EXT_hdr_metadata\'"] + impl StructureType { + pub const HDR_METADATA_EXT: Self = StructureType(1000105000); + } + pub struct KhrSharedPresentableImageFn { + get_swapchain_status_khr: + extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, + } + unsafe impl Send for KhrSharedPresentableImageFn {} + unsafe impl Sync for KhrSharedPresentableImageFn {} + impl ::std::clone::Clone for KhrSharedPresentableImageFn { + fn clone(&self) -> Self { + KhrSharedPresentableImageFn { + get_swapchain_status_khr: self.get_swapchain_status_khr, + } + } + } + impl KhrSharedPresentableImageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSharedPresentableImageFn { + get_swapchain_status_khr: unsafe { + let raw_name = stringify!(vkGetSwapchainStatusKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_swapchain_status_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + ) -> Result { + (self.get_swapchain_status_khr)(device, swapchain) + } + } + #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] + impl StructureType { + pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = StructureType(1000111000); + } + #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] + impl PresentModeKHR { + pub const PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR: Self = PresentModeKHR(1000111000); + } + #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] + impl PresentModeKHR { + pub const PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR: Self = PresentModeKHR(1000111001); + } + #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] + impl ImageLayout { + pub const SHARED_PRESENT_KHR: Self = ImageLayout(1000111000); + } + pub struct KhrExternalFenceCapabilitiesFn {} + unsafe impl Send for KhrExternalFenceCapabilitiesFn {} + unsafe impl Sync for KhrExternalFenceCapabilitiesFn {} + impl ::std::clone::Clone for KhrExternalFenceCapabilitiesFn { + fn clone(&self) -> Self { + KhrExternalFenceCapabilitiesFn {} + } + } + impl KhrExternalFenceCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceCapabilitiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExternalFenceFn {} + unsafe impl Send for KhrExternalFenceFn {} + unsafe impl Sync for KhrExternalFenceFn {} + impl ::std::clone::Clone for KhrExternalFenceFn { + fn clone(&self) -> Self { + KhrExternalFenceFn {} + } + } + impl KhrExternalFenceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExternalFenceWin32Fn { import_fence_win32_handle_khr : extern "system" fn ( device : Device , p_import_fence_win32_handle_info : *const ImportFenceWin32HandleInfoKHR , ) -> Result , get_fence_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const FenceGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , } + unsafe impl Send for KhrExternalFenceWin32Fn {} + unsafe impl Sync for KhrExternalFenceWin32Fn {} + impl ::std::clone::Clone for KhrExternalFenceWin32Fn { + fn clone(&self) -> Self { + KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: self.import_fence_win32_handle_khr, + get_fence_win32_handle_khr: self.get_fence_win32_handle_khr, + } + } + } + impl KhrExternalFenceWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: unsafe { + let raw_name = stringify!(vkImportFenceWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_fence_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetFenceWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_fence_win32_handle_khr( + &self, device: Device, p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, - ) -> Result, - get_fence_win32_handle_khr: - extern "system" fn( + ) -> Result { + (self.import_fence_win32_handle_khr)(device, p_import_fence_win32_handle_info) + } + pub unsafe fn get_fence_win32_handle_khr( + &self, device: Device, p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, p_handle: *const HANDLE, + ) -> Result { + (self.get_fence_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } + } + #[doc = "Generated from \'VK_KHR_external_fence_win32\'"] + impl StructureType { + pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114000); + } + #[doc = "Generated from \'VK_KHR_external_fence_win32\'"] + impl StructureType { + pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114001); + } + #[doc = "Generated from \'VK_KHR_external_fence_win32\'"] + impl StructureType { + pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114002); + } + pub struct KhrExternalFenceFdFn { + import_fence_fd_khr: + extern "system" fn(device: Device, p_import_fence_fd_info: *const ImportFenceFdInfoKHR) + -> Result, + get_fence_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *const c_int, ) -> Result, -} -unsafe impl Send for KhrExternalFenceWin32Fn {} -unsafe impl Sync for KhrExternalFenceWin32Fn {} -impl ::std::clone::Clone for KhrExternalFenceWin32Fn { - fn clone(&self) -> Self { - KhrExternalFenceWin32Fn { - import_fence_win32_handle_khr: self.import_fence_win32_handle_khr, - get_fence_win32_handle_khr: self.get_fence_win32_handle_khr, + } + unsafe impl Send for KhrExternalFenceFdFn {} + unsafe impl Sync for KhrExternalFenceFdFn {} + impl ::std::clone::Clone for KhrExternalFenceFdFn { + fn clone(&self) -> Self { + KhrExternalFenceFdFn { + import_fence_fd_khr: self.import_fence_fd_khr, + get_fence_fd_khr: self.get_fence_fd_khr, + } } } -} -impl KhrExternalFenceWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceWin32Fn { - import_fence_win32_handle_khr: unsafe { - let raw_name = stringify!(vkImportFenceWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_fence_win32_handle_khr: unsafe { - let raw_name = stringify!(vkGetFenceWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl KhrExternalFenceFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceFdFn { + import_fence_fd_khr: unsafe { + let raw_name = stringify!(vkImportFenceFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_fence_fd_khr: unsafe { + let raw_name = stringify!(vkGetFenceFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_fence_fd_khr( + &self, + device: Device, + p_import_fence_fd_info: *const ImportFenceFdInfoKHR, + ) -> Result { + (self.import_fence_fd_khr)(device, p_import_fence_fd_info) + } + pub unsafe fn get_fence_fd_khr( + &self, + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *const c_int, + ) -> Result { + (self.get_fence_fd_khr)(device, p_get_fd_info, p_fd) } } - pub unsafe fn import_fence_win32_handle_khr( - &self, - device: Device, - p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, - ) -> Result { - (self.import_fence_win32_handle_khr)(device, p_import_fence_win32_handle_info) + #[doc = "Generated from \'VK_KHR_external_fence_fd\'"] + impl StructureType { + pub const IMPORT_FENCE_FD_INFO_KHR: Self = StructureType(1000115000); } - pub unsafe fn get_fence_win32_handle_khr( - &self, - device: Device, - p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, - p_handle: *const HANDLE, - ) -> Result { - (self.get_fence_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + #[doc = "Generated from \'VK_KHR_external_fence_fd\'"] + impl StructureType { + pub const FENCE_GET_FD_INFO_KHR: Self = StructureType(1000115001); } -} -pub struct KhrExternalFenceFdFn { - import_fence_fd_khr: - extern "system" fn(device: Device, p_import_fence_fd_info: *const ImportFenceFdInfoKHR) - -> Result, - get_fence_fd_khr: extern "system" fn( - device: Device, - p_get_fd_info: *const FenceGetFdInfoKHR, - p_fd: *const c_int, - ) -> Result, -} -unsafe impl Send for KhrExternalFenceFdFn {} -unsafe impl Sync for KhrExternalFenceFdFn {} -impl ::std::clone::Clone for KhrExternalFenceFdFn { - fn clone(&self) -> Self { - KhrExternalFenceFdFn { - import_fence_fd_khr: self.import_fence_fd_khr, - get_fence_fd_khr: self.get_fence_fd_khr, + pub struct KhrMaintenance2Fn {} + unsafe impl Send for KhrMaintenance2Fn {} + unsafe impl Sync for KhrMaintenance2Fn {} + impl ::std::clone::Clone for KhrMaintenance2Fn { + fn clone(&self) -> Self { + KhrMaintenance2Fn {} } } -} -impl KhrExternalFenceFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceFdFn { - import_fence_fd_khr: unsafe { - let raw_name = stringify!(vkImportFenceFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_fence_fd_khr: unsafe { - let raw_name = stringify!(vkGetFenceFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl KhrMaintenance2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMaintenance2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } - pub unsafe fn import_fence_fd_khr( - &self, - device: Device, - p_import_fence_fd_info: *const ImportFenceFdInfoKHR, - ) -> Result { - (self.import_fence_fd_khr)(device, p_import_fence_fd_info) + pub struct KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_capabilities: *const SurfaceCapabilities2KHR, + ) -> Result, + get_physical_device_surface_formats2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_format_count: *const uint32_t, + p_surface_formats: *const SurfaceFormat2KHR, + ) -> Result, } - pub unsafe fn get_fence_fd_khr( - &self, - device: Device, - p_get_fd_info: *const FenceGetFdInfoKHR, - p_fd: *const c_int, - ) -> Result { - (self.get_fence_fd_khr)(device, p_get_fd_info, p_fd) + unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} + unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {} + impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { + fn clone(&self) -> Self { + KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: self + .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_formats2_khr: self + .get_physical_device_surface_formats2_khr, + } + } } -} -pub struct KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: - extern "system" fn( + impl KhrGetSurfaceCapabilities2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_formats2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_surface_capabilities2_khr( + &self, physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, p_surface_capabilities: *const SurfaceCapabilities2KHR, - ) -> Result, - get_physical_device_surface_formats2_khr: - extern "system" fn( + ) -> Result { + (self.get_physical_device_surface_capabilities2_khr)( + physical_device, + p_surface_info, + p_surface_capabilities, + ) + } + pub unsafe fn get_physical_device_surface_formats2_khr( + &self, physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, p_surface_format_count: *const uint32_t, p_surface_formats: *const SurfaceFormat2KHR, - ) -> Result, -} -unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} -unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {} -impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { - fn clone(&self) -> Self { - KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: self - .get_physical_device_surface_capabilities2_khr, - get_physical_device_surface_formats2_khr: self.get_physical_device_surface_formats2_khr, + ) -> Result { + (self.get_physical_device_surface_formats2_khr)( + physical_device, + p_surface_info, + p_surface_format_count, + p_surface_formats, + ) } } -} -impl KhrGetSurfaceCapabilities2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_formats2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = StructureType(1000119000); + } + #[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] + impl StructureType { + pub const SURFACE_CAPABILITIES_2_KHR: Self = StructureType(1000119001); + } + #[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] + impl StructureType { + pub const SURFACE_FORMAT_2_KHR: Self = StructureType(1000119002); + } + pub struct KhrVariablePointersFn {} + unsafe impl Send for KhrVariablePointersFn {} + unsafe impl Sync for KhrVariablePointersFn {} + impl ::std::clone::Clone for KhrVariablePointersFn { + fn clone(&self) -> Self { + KhrVariablePointersFn {} } } - pub unsafe fn get_physical_device_surface_capabilities2_khr( - &self, - physical_device: PhysicalDevice, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_capabilities: *const SurfaceCapabilities2KHR, - ) -> Result { - (self.get_physical_device_surface_capabilities2_khr)( - physical_device, - p_surface_info, - p_surface_capabilities, - ) + impl KhrVariablePointersFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrVariablePointersFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } } - pub unsafe fn get_physical_device_surface_formats2_khr( - &self, - physical_device: PhysicalDevice, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_format_count: *const uint32_t, - p_surface_formats: *const SurfaceFormat2KHR, - ) -> Result { - (self.get_physical_device_surface_formats2_khr)( - physical_device, - p_surface_info, - p_surface_format_count, - p_surface_formats, - ) + pub struct KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayProperties2KHR, + ) -> Result, + get_physical_device_display_plane_properties2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *const uint32_t, + p_properties: *const DisplayPlaneProperties2KHR, + ) -> Result, + get_display_mode_properties2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *const uint32_t, + p_properties: *const DisplayModeProperties2KHR, + ) -> Result, + get_display_plane_capabilities2_khr: + extern "system" fn( + physical_device: PhysicalDevice, + p_display_plane_info: *const DisplayPlaneInfo2KHR, + p_capabilities: *const DisplayPlaneCapabilities2KHR, + ) -> Result, } -} -pub struct KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: - extern "system" fn( + unsafe impl Send for KhrGetDisplayProperties2Fn {} + unsafe impl Sync for KhrGetDisplayProperties2Fn {} + impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { + fn clone(&self) -> Self { + KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: self + .get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: self + .get_physical_device_display_plane_properties2_khr, + get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, + get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, + } + } + } + impl KhrGetDisplayProperties2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_display_plane_properties2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_mode_properties2_khr: unsafe { + let raw_name = stringify!(vkGetDisplayModeProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_capabilities2_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_display_properties2_khr( + &self, physical_device: PhysicalDevice, p_property_count: *const uint32_t, p_properties: *const DisplayProperties2KHR, - ) -> Result, - get_physical_device_display_plane_properties2_khr: - extern "system" fn( + ) -> Result { + (self.get_physical_device_display_properties2_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_physical_device_display_plane_properties2_khr( + &self, physical_device: PhysicalDevice, p_property_count: *const uint32_t, p_properties: *const DisplayPlaneProperties2KHR, - ) -> Result, - get_display_mode_properties2_khr: - extern "system" fn( + ) -> Result { + (self.get_physical_device_display_plane_properties2_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_mode_properties2_khr( + &self, physical_device: PhysicalDevice, display: DisplayKHR, p_property_count: *const uint32_t, p_properties: *const DisplayModeProperties2KHR, - ) -> Result, - get_display_plane_capabilities2_khr: - extern "system" fn( + ) -> Result { + (self.get_display_mode_properties2_khr)( + physical_device, + display, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_plane_capabilities2_khr( + &self, physical_device: PhysicalDevice, p_display_plane_info: *const DisplayPlaneInfo2KHR, p_capabilities: *const DisplayPlaneCapabilities2KHR, + ) -> Result { + (self.get_display_plane_capabilities2_khr)( + physical_device, + p_display_plane_info, + p_capabilities, + ) + } + } + #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] + impl StructureType { + pub const DISPLAY_PROPERTIES_2_KHR: Self = StructureType(1000121000); + } + #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] + impl StructureType { + pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = StructureType(1000121001); + } + #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] + impl StructureType { + pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = StructureType(1000121002); + } + #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] + impl StructureType { + pub const DISPLAY_PLANE_INFO_2_KHR: Self = StructureType(1000121003); + } + #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] + impl StructureType { + pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = StructureType(1000121004); + } + pub struct MvkIosSurfaceFn { + create_ios_surface_mvk: extern "system" fn( + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, ) -> Result, -} -unsafe impl Send for KhrGetDisplayProperties2Fn {} -unsafe impl Sync for KhrGetDisplayProperties2Fn {} -impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { - fn clone(&self) -> Self { - KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: self - .get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: self - .get_physical_device_display_plane_properties2_khr, - get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, - get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, + } + unsafe impl Send for MvkIosSurfaceFn {} + unsafe impl Sync for MvkIosSurfaceFn {} + impl ::std::clone::Clone for MvkIosSurfaceFn { + fn clone(&self) -> Self { + MvkIosSurfaceFn { + create_ios_surface_mvk: self.create_ios_surface_mvk, + } } } -} -impl KhrGetDisplayProperties2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_display_plane_properties2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_mode_properties2_khr: unsafe { - let raw_name = stringify!(vkGetDisplayModeProperties2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_plane_capabilities2_khr: unsafe { - let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl MvkIosSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkIosSurfaceFn { + create_ios_surface_mvk: unsafe { + let raw_name = stringify!(vkCreateIOSSurfaceMVK); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_ios_surface_mvk( + &self, + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_ios_surface_mvk)(instance, p_create_info, p_allocator, p_surface) } } - pub unsafe fn get_physical_device_display_properties2_khr( - &self, - physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayProperties2KHR, - ) -> Result { - (self.get_physical_device_display_properties2_khr)( - physical_device, - p_property_count, - p_properties, - ) + #[doc = "Generated from \'VK_MVK_ios_surface\'"] + impl StructureType { + pub const IOS_SURFACE_CREATE_INFO_M: Self = StructureType(1000122000); } - pub unsafe fn get_physical_device_display_plane_properties2_khr( - &self, - physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPlaneProperties2KHR, - ) -> Result { - (self.get_physical_device_display_plane_properties2_khr)( - physical_device, - p_property_count, - p_properties, - ) + pub struct MvkMacosSurfaceFn { + create_mac_os_surface_mvk: + extern "system" fn( + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result, } - pub unsafe fn get_display_mode_properties2_khr( - &self, - physical_device: PhysicalDevice, - display: DisplayKHR, - p_property_count: *const uint32_t, - p_properties: *const DisplayModeProperties2KHR, - ) -> Result { - (self.get_display_mode_properties2_khr)( - physical_device, - display, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_display_plane_capabilities2_khr( - &self, - physical_device: PhysicalDevice, - p_display_plane_info: *const DisplayPlaneInfo2KHR, - p_capabilities: *const DisplayPlaneCapabilities2KHR, - ) -> Result { - (self.get_display_plane_capabilities2_khr)( - physical_device, - p_display_plane_info, - p_capabilities, - ) - } -} -pub struct MvkIosSurfaceFn { - create_ios_surface_mvk: extern "system" fn( - instance: Instance, - p_create_info: *const IOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result, -} -unsafe impl Send for MvkIosSurfaceFn {} -unsafe impl Sync for MvkIosSurfaceFn {} -impl ::std::clone::Clone for MvkIosSurfaceFn { - fn clone(&self) -> Self { - MvkIosSurfaceFn { - create_ios_surface_mvk: self.create_ios_surface_mvk, + unsafe impl Send for MvkMacosSurfaceFn {} + unsafe impl Sync for MvkMacosSurfaceFn {} + impl ::std::clone::Clone for MvkMacosSurfaceFn { + fn clone(&self) -> Self { + MvkMacosSurfaceFn { + create_mac_os_surface_mvk: self.create_mac_os_surface_mvk, + } } } -} -impl MvkIosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = MvkIosSurfaceFn { - create_ios_surface_mvk: unsafe { - let raw_name = stringify!(vkCreateIOSSurfaceMVK); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl MvkMacosSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkMacosSurfaceFn { + create_mac_os_surface_mvk: unsafe { + let raw_name = stringify!(vkCreateMacOSSurfaceMVK); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_mac_os_surface_mvk( + &self, + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *const SurfaceKHR, + ) -> Result { + (self.create_mac_os_surface_mvk)(instance, p_create_info, p_allocator, p_surface) } } - pub unsafe fn create_ios_surface_mvk( - &self, - instance: Instance, - p_create_info: *const IOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_ios_surface_mvk)(instance, p_create_info, p_allocator, p_surface) + #[doc = "Generated from \'VK_MVK_macos_surface\'"] + impl StructureType { + pub const MACOS_SURFACE_CREATE_INFO_M: Self = StructureType(1000123000); } -} -pub struct MvkMacosSurfaceFn { - create_mac_os_surface_mvk: extern "system" fn( - instance: Instance, - p_create_info: *const MacOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result, -} -unsafe impl Send for MvkMacosSurfaceFn {} -unsafe impl Sync for MvkMacosSurfaceFn {} -impl ::std::clone::Clone for MvkMacosSurfaceFn { - fn clone(&self) -> Self { - MvkMacosSurfaceFn { - create_mac_os_surface_mvk: self.create_mac_os_surface_mvk, + pub struct ExtExternalMemoryDmaBufFn {} + unsafe impl Send for ExtExternalMemoryDmaBufFn {} + unsafe impl Sync for ExtExternalMemoryDmaBufFn {} + impl ::std::clone::Clone for ExtExternalMemoryDmaBufFn { + fn clone(&self) -> Self { + ExtExternalMemoryDmaBufFn {} } } -} -impl MvkMacosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = MvkMacosSurfaceFn { - create_mac_os_surface_mvk: unsafe { - let raw_name = stringify!(vkCreateMacOSSurfaceMVK); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl ExtExternalMemoryDmaBufFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExternalMemoryDmaBufFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } - pub unsafe fn create_mac_os_surface_mvk( - &self, - instance: Instance, - p_create_info: *const MacOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, - ) -> Result { - (self.create_mac_os_surface_mvk)(instance, p_create_info, p_allocator, p_surface) + #[doc = "Generated from \'VK_EXT_external_memory_dma_buf\'"] + impl ExternalMemoryHandleTypeFlags { + pub const DMA_BUF_EXT: Self = ExternalMemoryHandleTypeFlags(0b1000000000); } -} -pub struct ExtDebugUtilsFn { - set_debug_utils_object_name_ext: - extern "system" fn(device: Device, p_name_info: *const DebugUtilsObjectNameInfoEXT) - -> Result, - set_debug_utils_object_tag_ext: - extern "system" fn(device: Device, p_tag_info: *const DebugUtilsObjectTagInfoEXT) -> Result, - queue_begin_debug_utils_label_ext: - extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, - queue_end_debug_utils_label_ext: extern "system" fn(queue: Queue) -> c_void, - queue_insert_debug_utils_label_ext: - extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, - cmd_begin_debug_utils_label_ext: - extern "system" fn(command_buffer: CommandBuffer, p_label_info: *const DebugUtilsLabelEXT) - -> c_void, - cmd_end_debug_utils_label_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, - cmd_insert_debug_utils_label_ext: - extern "system" fn(command_buffer: CommandBuffer, p_label_info: *const DebugUtilsLabelEXT) - -> c_void, - create_debug_utils_messenger_ext: - extern "system" fn( + pub struct ExtQueueFamilyForeignFn {} + unsafe impl Send for ExtQueueFamilyForeignFn {} + unsafe impl Sync for ExtQueueFamilyForeignFn {} + impl ::std::clone::Clone for ExtQueueFamilyForeignFn { + fn clone(&self) -> Self { + ExtQueueFamilyForeignFn {} + } + } + impl ExtQueueFamilyForeignFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtQueueFamilyForeignFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrDedicatedAllocationFn {} + unsafe impl Send for KhrDedicatedAllocationFn {} + unsafe impl Sync for KhrDedicatedAllocationFn {} + impl ::std::clone::Clone for KhrDedicatedAllocationFn { + fn clone(&self) -> Self { + KhrDedicatedAllocationFn {} + } + } + impl KhrDedicatedAllocationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDedicatedAllocationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtDebugUtilsFn { + set_debug_utils_object_name_ext: + extern "system" fn(device: Device, p_name_info: *const DebugUtilsObjectNameInfoEXT) + -> Result, + set_debug_utils_object_tag_ext: + extern "system" fn(device: Device, p_tag_info: *const DebugUtilsObjectTagInfoEXT) + -> Result, + queue_begin_debug_utils_label_ext: + extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, + queue_end_debug_utils_label_ext: extern "system" fn(queue: Queue) -> c_void, + queue_insert_debug_utils_label_ext: + extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, + cmd_begin_debug_utils_label_ext: + extern "system" fn( + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void, + cmd_end_debug_utils_label_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, + cmd_insert_debug_utils_label_ext: + extern "system" fn( + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void, + create_debug_utils_messenger_ext: + extern "system" fn( + instance: Instance, + p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_messenger: *const DebugUtilsMessengerEXT, + ) -> Result, + destroy_debug_utils_messenger_ext: + extern "system" fn( + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + submit_debug_utils_message_ext: + extern "system" fn( + instance: Instance, + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) -> c_void, + } + unsafe impl Send for ExtDebugUtilsFn {} + unsafe impl Sync for ExtDebugUtilsFn {} + impl ::std::clone::Clone for ExtDebugUtilsFn { + fn clone(&self) -> Self { + ExtDebugUtilsFn { + set_debug_utils_object_name_ext: self.set_debug_utils_object_name_ext, + set_debug_utils_object_tag_ext: self.set_debug_utils_object_tag_ext, + queue_begin_debug_utils_label_ext: self.queue_begin_debug_utils_label_ext, + queue_end_debug_utils_label_ext: self.queue_end_debug_utils_label_ext, + queue_insert_debug_utils_label_ext: self.queue_insert_debug_utils_label_ext, + cmd_begin_debug_utils_label_ext: self.cmd_begin_debug_utils_label_ext, + cmd_end_debug_utils_label_ext: self.cmd_end_debug_utils_label_ext, + cmd_insert_debug_utils_label_ext: self.cmd_insert_debug_utils_label_ext, + create_debug_utils_messenger_ext: self.create_debug_utils_messenger_ext, + destroy_debug_utils_messenger_ext: self.destroy_debug_utils_messenger_ext, + submit_debug_utils_message_ext: self.submit_debug_utils_message_ext, + } + } + } + impl ExtDebugUtilsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugUtilsFn { + set_debug_utils_object_name_ext: unsafe { + let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + set_debug_utils_object_tag_ext: unsafe { + let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_begin_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_end_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_insert_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_begin_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_end_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_insert_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_debug_utils_messenger_ext: unsafe { + let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_debug_utils_messenger_ext: unsafe { + let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + submit_debug_utils_message_ext: unsafe { + let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn set_debug_utils_object_name_ext( + &self, + device: Device, + p_name_info: *const DebugUtilsObjectNameInfoEXT, + ) -> Result { + (self.set_debug_utils_object_name_ext)(device, p_name_info) + } + pub unsafe fn set_debug_utils_object_tag_ext( + &self, + device: Device, + p_tag_info: *const DebugUtilsObjectTagInfoEXT, + ) -> Result { + (self.set_debug_utils_object_tag_ext)(device, p_tag_info) + } + pub unsafe fn queue_begin_debug_utils_label_ext( + &self, + queue: Queue, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.queue_begin_debug_utils_label_ext)(queue, p_label_info) + } + pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: Queue) -> c_void { + (self.queue_end_debug_utils_label_ext)(queue) + } + pub unsafe fn queue_insert_debug_utils_label_ext( + &self, + queue: Queue, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.queue_insert_debug_utils_label_ext)(queue, p_label_info) + } + pub unsafe fn cmd_begin_debug_utils_label_ext( + &self, + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.cmd_begin_debug_utils_label_ext)(command_buffer, p_label_info) + } + pub unsafe fn cmd_end_debug_utils_label_ext( + &self, + command_buffer: CommandBuffer, + ) -> c_void { + (self.cmd_end_debug_utils_label_ext)(command_buffer) + } + pub unsafe fn cmd_insert_debug_utils_label_ext( + &self, + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.cmd_insert_debug_utils_label_ext)(command_buffer, p_label_info) + } + pub unsafe fn create_debug_utils_messenger_ext( + &self, instance: Instance, p_create_info: *const DebugUtilsMessengerCreateInfoEXT, p_allocator: *const AllocationCallbacks, p_messenger: *const DebugUtilsMessengerEXT, - ) -> Result, - destroy_debug_utils_messenger_ext: extern "system" fn( - instance: Instance, - messenger: DebugUtilsMessengerEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - submit_debug_utils_message_ext: - extern "system" fn( + ) -> Result { + (self.create_debug_utils_messenger_ext)( + instance, + p_create_info, + p_allocator, + p_messenger, + ) + } + pub unsafe fn destroy_debug_utils_messenger_ext( + &self, + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_debug_utils_messenger_ext)(instance, messenger, p_allocator) + } + pub unsafe fn submit_debug_utils_message_ext( + &self, instance: Instance, message_severity: DebugUtilsMessageSeverityFlagsEXT, message_types: DebugUtilsMessageTypeFlagsEXT, p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, - ) -> c_void, -} -unsafe impl Send for ExtDebugUtilsFn {} -unsafe impl Sync for ExtDebugUtilsFn {} -impl ::std::clone::Clone for ExtDebugUtilsFn { - fn clone(&self) -> Self { - ExtDebugUtilsFn { - set_debug_utils_object_name_ext: self.set_debug_utils_object_name_ext, - set_debug_utils_object_tag_ext: self.set_debug_utils_object_tag_ext, - queue_begin_debug_utils_label_ext: self.queue_begin_debug_utils_label_ext, - queue_end_debug_utils_label_ext: self.queue_end_debug_utils_label_ext, - queue_insert_debug_utils_label_ext: self.queue_insert_debug_utils_label_ext, - cmd_begin_debug_utils_label_ext: self.cmd_begin_debug_utils_label_ext, - cmd_end_debug_utils_label_ext: self.cmd_end_debug_utils_label_ext, - cmd_insert_debug_utils_label_ext: self.cmd_insert_debug_utils_label_ext, - create_debug_utils_messenger_ext: self.create_debug_utils_messenger_ext, - destroy_debug_utils_messenger_ext: self.destroy_debug_utils_messenger_ext, - submit_debug_utils_message_ext: self.submit_debug_utils_message_ext, + ) -> c_void { + (self.submit_debug_utils_message_ext)( + instance, + message_severity, + message_types, + p_callback_data, + ) } } -} -impl ExtDebugUtilsFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDebugUtilsFn { - set_debug_utils_object_name_ext: unsafe { - let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - set_debug_utils_object_tag_ext: unsafe { - let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_begin_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_end_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_insert_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_begin_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_end_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_insert_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_debug_utils_messenger_ext: unsafe { - let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_debug_utils_messenger_ext: unsafe { - let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - submit_debug_utils_message_ext: unsafe { - let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_EXT_debug_utils\'"] + impl StructureType { + pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = StructureType(1000128000); + } + #[doc = "Generated from \'VK_EXT_debug_utils\'"] + impl StructureType { + pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = StructureType(1000128001); + } + #[doc = "Generated from \'VK_EXT_debug_utils\'"] + impl StructureType { + pub const DEBUG_UTILS_LABEL_EXT: Self = StructureType(1000128002); + } + #[doc = "Generated from \'VK_EXT_debug_utils\'"] + impl StructureType { + pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = StructureType(1000128003); + } + #[doc = "Generated from \'VK_EXT_debug_utils\'"] + impl StructureType { + pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = StructureType(1000128004); + } + #[doc = "Generated from \'VK_EXT_debug_utils\'"] + impl ObjectType { + pub const DEBUG_UTILS_MESSENGER_EXT: Self = ObjectType(1000128000); + } + pub struct AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: + extern "system" fn( + device: Device, + buffer: *const AHardwareBuffer, + p_properties: *const AndroidHardwareBufferPropertiesANDROID, + ) -> Result, + get_memory_android_hardware_buffer_android: + extern "system" fn( + device: Device, + p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + p_buffer: *mut *mut AHardwareBuffer, + ) -> Result, + } + unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {} + unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {} + impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { + fn clone(&self) -> Self { + AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: self + .get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: self + .get_memory_android_hardware_buffer_android, + } } } - pub unsafe fn set_debug_utils_object_name_ext( - &self, - device: Device, - p_name_info: *const DebugUtilsObjectNameInfoEXT, - ) -> Result { - (self.set_debug_utils_object_name_ext)(device, p_name_info) - } - pub unsafe fn set_debug_utils_object_tag_ext( - &self, - device: Device, - p_tag_info: *const DebugUtilsObjectTagInfoEXT, - ) -> Result { - (self.set_debug_utils_object_tag_ext)(device, p_tag_info) - } - pub unsafe fn queue_begin_debug_utils_label_ext( - &self, - queue: Queue, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.queue_begin_debug_utils_label_ext)(queue, p_label_info) - } - pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: Queue) -> c_void { - (self.queue_end_debug_utils_label_ext)(queue) - } - pub unsafe fn queue_insert_debug_utils_label_ext( - &self, - queue: Queue, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.queue_insert_debug_utils_label_ext)(queue, p_label_info) - } - pub unsafe fn cmd_begin_debug_utils_label_ext( - &self, - command_buffer: CommandBuffer, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.cmd_begin_debug_utils_label_ext)(command_buffer, p_label_info) - } - pub unsafe fn cmd_end_debug_utils_label_ext(&self, command_buffer: CommandBuffer) -> c_void { - (self.cmd_end_debug_utils_label_ext)(command_buffer) - } - pub unsafe fn cmd_insert_debug_utils_label_ext( - &self, - command_buffer: CommandBuffer, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.cmd_insert_debug_utils_label_ext)(command_buffer, p_label_info) - } - pub unsafe fn create_debug_utils_messenger_ext( - &self, - instance: Instance, - p_create_info: *const DebugUtilsMessengerCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_messenger: *const DebugUtilsMessengerEXT, - ) -> Result { - (self.create_debug_utils_messenger_ext)(instance, p_create_info, p_allocator, p_messenger) - } - pub unsafe fn destroy_debug_utils_messenger_ext( - &self, - instance: Instance, - messenger: DebugUtilsMessengerEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_debug_utils_messenger_ext)(instance, messenger, p_allocator) - } - pub unsafe fn submit_debug_utils_message_ext( - &self, - instance: Instance, - message_severity: DebugUtilsMessageSeverityFlagsEXT, - message_types: DebugUtilsMessageTypeFlagsEXT, - p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, - ) -> c_void { - (self.submit_debug_utils_message_ext)( - instance, - message_severity, - message_types, - p_callback_data, - ) - } -} -pub struct AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: - extern "system" fn( + impl AndroidExternalMemoryAndroidHardwareBufferFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: unsafe { + let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_android_hardware_buffer_android: unsafe { + let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_android_hardware_buffer_properties_android( + &self, device: Device, buffer: *const AHardwareBuffer, p_properties: *const AndroidHardwareBufferPropertiesANDROID, - ) -> Result, - get_memory_android_hardware_buffer_android: - extern "system" fn( + ) -> Result { + (self.get_android_hardware_buffer_properties_android)(device, buffer, p_properties) + } + pub unsafe fn get_memory_android_hardware_buffer_android( + &self, device: Device, p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, p_buffer: *mut *mut AHardwareBuffer, - ) -> Result, -} -unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {} -unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {} -impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { - fn clone(&self) -> Self { - AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: self - .get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: self - .get_memory_android_hardware_buffer_android, + ) -> Result { + (self.get_memory_android_hardware_buffer_android)(device, p_info, p_buffer) } } -} -impl AndroidExternalMemoryAndroidHardwareBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: unsafe { - let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_memory_android_hardware_buffer_android: unsafe { - let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] + impl ExternalMemoryHandleTypeFlags { + pub const ANDROID_HARDWARE_BUFFER_ANDROID: Self = + ExternalMemoryHandleTypeFlags(0b10000000000); + } + #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] + impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = StructureType(1000129000); + } + #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] + impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = StructureType(1000129001); + } + #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] + impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = + StructureType(1000129002); + } + #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] + impl StructureType { + pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = StructureType(1000129003); + } + #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] + impl StructureType { + pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = StructureType(1000129004); + } + #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] + impl StructureType { + pub const EXTERNAL_FORMAT_ANDROID: Self = StructureType(1000129005); + } + pub struct ExtSamplerFilterMinmaxFn {} + unsafe impl Send for ExtSamplerFilterMinmaxFn {} + unsafe impl Sync for ExtSamplerFilterMinmaxFn {} + impl ::std::clone::Clone for ExtSamplerFilterMinmaxFn { + fn clone(&self) -> Self { + ExtSamplerFilterMinmaxFn {} } } - pub unsafe fn get_android_hardware_buffer_properties_android( - &self, - device: Device, - buffer: *const AHardwareBuffer, - p_properties: *const AndroidHardwareBufferPropertiesANDROID, - ) -> Result { - (self.get_android_hardware_buffer_properties_android)(device, buffer, p_properties) + impl ExtSamplerFilterMinmaxFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtSamplerFilterMinmaxFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } } - pub unsafe fn get_memory_android_hardware_buffer_android( - &self, - device: Device, - p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, - p_buffer: *mut *mut AHardwareBuffer, - ) -> Result { - (self.get_memory_android_hardware_buffer_android)(device, p_info, p_buffer) + #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self = + StructureType(1000130000); } -} -pub struct ExtSampleLocationsFn { - cmd_set_sample_locations_ext: - extern "system" fn( + #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] + impl StructureType { + pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self = StructureType(1000130001); + } + #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] + impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = FormatFeatureFlags(0b10000000000000000); + } + pub struct KhrStorageBufferStorageClassFn {} + unsafe impl Send for KhrStorageBufferStorageClassFn {} + unsafe impl Sync for KhrStorageBufferStorageClassFn {} + impl ::std::clone::Clone for KhrStorageBufferStorageClassFn { + fn clone(&self) -> Self { + KhrStorageBufferStorageClassFn {} + } + } + impl KhrStorageBufferStorageClassFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrStorageBufferStorageClassFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdGpuShaderInt16Fn {} + unsafe impl Send for AmdGpuShaderInt16Fn {} + unsafe impl Sync for AmdGpuShaderInt16Fn {} + impl ::std::clone::Clone for AmdGpuShaderInt16Fn { + fn clone(&self) -> Self { + AmdGpuShaderInt16Fn {} + } + } + impl AmdGpuShaderInt16Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdGpuShaderInt16Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdMixedAttachmentSamplesFn {} + unsafe impl Send for AmdMixedAttachmentSamplesFn {} + unsafe impl Sync for AmdMixedAttachmentSamplesFn {} + impl ::std::clone::Clone for AmdMixedAttachmentSamplesFn { + fn clone(&self) -> Self { + AmdMixedAttachmentSamplesFn {} + } + } + impl AmdMixedAttachmentSamplesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdMixedAttachmentSamplesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdShaderFragmentMaskFn {} + unsafe impl Send for AmdShaderFragmentMaskFn {} + unsafe impl Sync for AmdShaderFragmentMaskFn {} + impl ::std::clone::Clone for AmdShaderFragmentMaskFn { + fn clone(&self) -> Self { + AmdShaderFragmentMaskFn {} + } + } + impl AmdShaderFragmentMaskFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderFragmentMaskFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtShaderStencilExportFn {} + unsafe impl Send for ExtShaderStencilExportFn {} + unsafe impl Sync for ExtShaderStencilExportFn {} + impl ::std::clone::Clone for ExtShaderStencilExportFn { + fn clone(&self) -> Self { + ExtShaderStencilExportFn {} + } + } + impl ExtShaderStencilExportFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderStencilExportFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtSampleLocationsFn { + cmd_set_sample_locations_ext: + extern "system" fn( + command_buffer: CommandBuffer, + p_sample_locations_info: *const SampleLocationsInfoEXT, + ) -> c_void, + get_physical_device_multisample_properties_ext: + extern "system" fn( + physical_device: PhysicalDevice, + samples: SampleCountFlags, + p_multisample_properties: *const MultisamplePropertiesEXT, + ) -> c_void, + } + unsafe impl Send for ExtSampleLocationsFn {} + unsafe impl Sync for ExtSampleLocationsFn {} + impl ::std::clone::Clone for ExtSampleLocationsFn { + fn clone(&self) -> Self { + ExtSampleLocationsFn { + cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, + get_physical_device_multisample_properties_ext: self + .get_physical_device_multisample_properties_ext, + } + } + } + impl ExtSampleLocationsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtSampleLocationsFn { + cmd_set_sample_locations_ext: unsafe { + let raw_name = stringify!(vkCmdSetSampleLocationsEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_multisample_properties_ext: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_set_sample_locations_ext( + &self, command_buffer: CommandBuffer, p_sample_locations_info: *const SampleLocationsInfoEXT, - ) -> c_void, - get_physical_device_multisample_properties_ext: - extern "system" fn( + ) -> c_void { + (self.cmd_set_sample_locations_ext)(command_buffer, p_sample_locations_info) + } + pub unsafe fn get_physical_device_multisample_properties_ext( + &self, physical_device: PhysicalDevice, samples: SampleCountFlags, p_multisample_properties: *const MultisamplePropertiesEXT, + ) -> c_void { + (self.get_physical_device_multisample_properties_ext)( + physical_device, + samples, + p_multisample_properties, + ) + } + } + #[doc = "Generated from \'VK_EXT_sample_locations\'"] + impl ImageCreateFlags { + pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT: Self = ImageCreateFlags(0b1000000000000); + } + #[doc = "Generated from \'VK_EXT_sample_locations\'"] + impl StructureType { + pub const SAMPLE_LOCATIONS_INFO_EXT: Self = StructureType(1000143000); + } + #[doc = "Generated from \'VK_EXT_sample_locations\'"] + impl StructureType { + pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = StructureType(1000143001); + } + #[doc = "Generated from \'VK_EXT_sample_locations\'"] + impl StructureType { + pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = StructureType(1000143002); + } + #[doc = "Generated from \'VK_EXT_sample_locations\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = StructureType(1000143003); + } + #[doc = "Generated from \'VK_EXT_sample_locations\'"] + impl StructureType { + pub const MULTISAMPLE_PROPERTIES_EXT: Self = StructureType(1000143004); + } + #[doc = "Generated from \'VK_EXT_sample_locations\'"] + impl DynamicState { + pub const SAMPLE_LOCATIONS_EXT: Self = DynamicState(1000143000); + } + pub struct KhrRelaxedBlockLayoutFn {} + unsafe impl Send for KhrRelaxedBlockLayoutFn {} + unsafe impl Sync for KhrRelaxedBlockLayoutFn {} + impl ::std::clone::Clone for KhrRelaxedBlockLayoutFn { + fn clone(&self) -> Self { + KhrRelaxedBlockLayoutFn {} + } + } + impl KhrRelaxedBlockLayoutFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrRelaxedBlockLayoutFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrGetMemoryRequirements2Fn {} + unsafe impl Send for KhrGetMemoryRequirements2Fn {} + unsafe impl Sync for KhrGetMemoryRequirements2Fn {} + impl ::std::clone::Clone for KhrGetMemoryRequirements2Fn { + fn clone(&self) -> Self { + KhrGetMemoryRequirements2Fn {} + } + } + impl KhrGetMemoryRequirements2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetMemoryRequirements2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrImageFormatListFn {} + unsafe impl Send for KhrImageFormatListFn {} + unsafe impl Sync for KhrImageFormatListFn {} + impl ::std::clone::Clone for KhrImageFormatListFn { + fn clone(&self) -> Self { + KhrImageFormatListFn {} + } + } + impl KhrImageFormatListFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrImageFormatListFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_KHR_image_format_list\'"] + impl StructureType { + pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = StructureType(1000147000); + } + pub struct ExtBlendOperationAdvancedFn {} + unsafe impl Send for ExtBlendOperationAdvancedFn {} + unsafe impl Sync for ExtBlendOperationAdvancedFn {} + impl ::std::clone::Clone for ExtBlendOperationAdvancedFn { + fn clone(&self) -> Self { + ExtBlendOperationAdvancedFn {} + } + } + impl ExtBlendOperationAdvancedFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtBlendOperationAdvancedFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = + StructureType(1000148000); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = + StructureType(1000148001); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl StructureType { + pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = + StructureType(1000148002); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const ZERO_EXT: Self = BlendOp(1000148000); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const SRC_EXT: Self = BlendOp(1000148001); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const DST_EXT: Self = BlendOp(1000148002); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const SRC_OVER_EXT: Self = BlendOp(1000148003); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const DST_OVER_EXT: Self = BlendOp(1000148004); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const SRC_IN_EXT: Self = BlendOp(1000148005); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const DST_IN_EXT: Self = BlendOp(1000148006); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const SRC_OUT_EXT: Self = BlendOp(1000148007); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const DST_OUT_EXT: Self = BlendOp(1000148008); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const SRC_ATOP_EXT: Self = BlendOp(1000148009); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const DST_ATOP_EXT: Self = BlendOp(1000148010); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const XOR_EXT: Self = BlendOp(1000148011); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const MULTIPLY_EXT: Self = BlendOp(1000148012); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const SCREEN_EXT: Self = BlendOp(1000148013); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const OVERLAY_EXT: Self = BlendOp(1000148014); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const DARKEN_EXT: Self = BlendOp(1000148015); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const LIGHTEN_EXT: Self = BlendOp(1000148016); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const COLORDODGE_EXT: Self = BlendOp(1000148017); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const COLORBURN_EXT: Self = BlendOp(1000148018); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const HARDLIGHT_EXT: Self = BlendOp(1000148019); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const SOFTLIGHT_EXT: Self = BlendOp(1000148020); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const DIFFERENCE_EXT: Self = BlendOp(1000148021); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const EXCLUSION_EXT: Self = BlendOp(1000148022); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const INVERT_EXT: Self = BlendOp(1000148023); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const INVERT_RGB_EXT: Self = BlendOp(1000148024); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const LINEARDODGE_EXT: Self = BlendOp(1000148025); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const LINEARBURN_EXT: Self = BlendOp(1000148026); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const VIVIDLIGHT_EXT: Self = BlendOp(1000148027); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const LINEARLIGHT_EXT: Self = BlendOp(1000148028); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const PINLIGHT_EXT: Self = BlendOp(1000148029); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const HARDMIX_EXT: Self = BlendOp(1000148030); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const HSL_HUE_EXT: Self = BlendOp(1000148031); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const HSL_SATURATION_EXT: Self = BlendOp(1000148032); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const HSL_COLOR_EXT: Self = BlendOp(1000148033); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const HSL_LUMINOSITY_EXT: Self = BlendOp(1000148034); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const PLUS_EXT: Self = BlendOp(1000148035); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const PLUS_CLAMPED_EXT: Self = BlendOp(1000148036); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const PLUS_CLAMPED_ALPHA_EXT: Self = BlendOp(1000148037); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const PLUS_DARKER_EXT: Self = BlendOp(1000148038); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const MINUS_EXT: Self = BlendOp(1000148039); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const MINUS_CLAMPED_EXT: Self = BlendOp(1000148040); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const CONTRAST_EXT: Self = BlendOp(1000148041); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const INVERT_OVG_EXT: Self = BlendOp(1000148042); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const RED_EXT: Self = BlendOp(1000148043); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const GREEN_EXT: Self = BlendOp(1000148044); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl BlendOp { + pub const BLUE_EXT: Self = BlendOp(1000148045); + } + #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] + impl AccessFlags { + pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = AccessFlags(0b10000000000000000000); + } + pub struct NvFragmentCoverageToColorFn {} + unsafe impl Send for NvFragmentCoverageToColorFn {} + unsafe impl Sync for NvFragmentCoverageToColorFn {} + impl ::std::clone::Clone for NvFragmentCoverageToColorFn { + fn clone(&self) -> Self { + NvFragmentCoverageToColorFn {} + } + } + impl NvFragmentCoverageToColorFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvFragmentCoverageToColorFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_NV_fragment_coverage_to_color\'"] + impl StructureType { + pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = StructureType(1000149000); + } + pub struct NvFramebufferMixedSamplesFn {} + unsafe impl Send for NvFramebufferMixedSamplesFn {} + unsafe impl Sync for NvFramebufferMixedSamplesFn {} + impl ::std::clone::Clone for NvFramebufferMixedSamplesFn { + fn clone(&self) -> Self { + NvFramebufferMixedSamplesFn {} + } + } + impl NvFramebufferMixedSamplesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvFramebufferMixedSamplesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_NV_framebuffer_mixed_samples\'"] + impl StructureType { + pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = + StructureType(1000152000); + } + pub struct NvFillRectangleFn {} + unsafe impl Send for NvFillRectangleFn {} + unsafe impl Sync for NvFillRectangleFn {} + impl ::std::clone::Clone for NvFillRectangleFn { + fn clone(&self) -> Self { + NvFillRectangleFn {} + } + } + impl NvFillRectangleFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvFillRectangleFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_NV_fill_rectangle\'"] + impl PolygonMode { + pub const FILL_RECTANGLE_NV: Self = PolygonMode(1000153000); + } + pub struct ExtPostDepthCoverageFn {} + unsafe impl Send for ExtPostDepthCoverageFn {} + unsafe impl Sync for ExtPostDepthCoverageFn {} + impl ::std::clone::Clone for ExtPostDepthCoverageFn { + fn clone(&self) -> Self { + ExtPostDepthCoverageFn {} + } + } + impl ExtPostDepthCoverageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtPostDepthCoverageFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrSamplerYcbcrConversionFn {} + unsafe impl Send for KhrSamplerYcbcrConversionFn {} + unsafe impl Sync for KhrSamplerYcbcrConversionFn {} + impl ::std::clone::Clone for KhrSamplerYcbcrConversionFn { + fn clone(&self) -> Self { + KhrSamplerYcbcrConversionFn {} + } + } + impl KhrSamplerYcbcrConversionFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSamplerYcbcrConversionFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrBindMemory2Fn {} + unsafe impl Send for KhrBindMemory2Fn {} + unsafe impl Sync for KhrBindMemory2Fn {} + impl ::std::clone::Clone for KhrBindMemory2Fn { + fn clone(&self) -> Self { + KhrBindMemory2Fn {} + } + } + impl KhrBindMemory2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrBindMemory2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtValidationCacheFn { + create_validation_cache_ext: + extern "system" fn( + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *const ValidationCacheEXT, + ) -> Result, + destroy_validation_cache_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, ) -> c_void, -} -unsafe impl Send for ExtSampleLocationsFn {} -unsafe impl Sync for ExtSampleLocationsFn {} -impl ::std::clone::Clone for ExtSampleLocationsFn { - fn clone(&self) -> Self { - ExtSampleLocationsFn { - cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: self - .get_physical_device_multisample_properties_ext, + merge_validation_caches_ext: extern "system" fn( + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: uint32_t, + p_src_caches: *const ValidationCacheEXT, + ) -> Result, + get_validation_cache_data_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *const size_t, + p_data: *const c_void, + ) -> Result, + } + unsafe impl Send for ExtValidationCacheFn {} + unsafe impl Sync for ExtValidationCacheFn {} + impl ::std::clone::Clone for ExtValidationCacheFn { + fn clone(&self) -> Self { + ExtValidationCacheFn { + create_validation_cache_ext: self.create_validation_cache_ext, + destroy_validation_cache_ext: self.destroy_validation_cache_ext, + merge_validation_caches_ext: self.merge_validation_caches_ext, + get_validation_cache_data_ext: self.get_validation_cache_data_ext, + } } } -} -impl ExtSampleLocationsFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtSampleLocationsFn { - cmd_set_sample_locations_ext: unsafe { - let raw_name = stringify!(vkCmdSetSampleLocationsEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_multisample_properties_ext: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + impl ExtValidationCacheFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtValidationCacheFn { + create_validation_cache_ext: unsafe { + let raw_name = stringify!(vkCreateValidationCacheEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_validation_cache_ext: unsafe { + let raw_name = stringify!(vkDestroyValidationCacheEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + merge_validation_caches_ext: unsafe { + let raw_name = stringify!(vkMergeValidationCachesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_validation_cache_data_ext: unsafe { + let raw_name = stringify!(vkGetValidationCacheDataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } - } - pub unsafe fn cmd_set_sample_locations_ext( - &self, - command_buffer: CommandBuffer, - p_sample_locations_info: *const SampleLocationsInfoEXT, - ) -> c_void { - (self.cmd_set_sample_locations_ext)(command_buffer, p_sample_locations_info) - } - pub unsafe fn get_physical_device_multisample_properties_ext( - &self, - physical_device: PhysicalDevice, - samples: SampleCountFlags, - p_multisample_properties: *const MultisamplePropertiesEXT, - ) -> c_void { - (self.get_physical_device_multisample_properties_ext)( - physical_device, - samples, - p_multisample_properties, - ) - } -} -pub struct ExtValidationCacheFn { - create_validation_cache_ext: - extern "system" fn( + pub unsafe fn create_validation_cache_ext( + &self, device: Device, p_create_info: *const ValidationCacheCreateInfoEXT, p_allocator: *const AllocationCallbacks, p_validation_cache: *const ValidationCacheEXT, - ) -> Result, - destroy_validation_cache_ext: extern "system" fn( - device: Device, - validation_cache: ValidationCacheEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - merge_validation_caches_ext: extern "system" fn( - device: Device, - dst_cache: ValidationCacheEXT, - src_cache_count: uint32_t, - p_src_caches: *const ValidationCacheEXT, - ) -> Result, - get_validation_cache_data_ext: extern "system" fn( - device: Device, - validation_cache: ValidationCacheEXT, - p_data_size: *const size_t, - p_data: *const c_void, - ) -> Result, -} -unsafe impl Send for ExtValidationCacheFn {} -unsafe impl Sync for ExtValidationCacheFn {} -impl ::std::clone::Clone for ExtValidationCacheFn { - fn clone(&self) -> Self { - ExtValidationCacheFn { - create_validation_cache_ext: self.create_validation_cache_ext, - destroy_validation_cache_ext: self.destroy_validation_cache_ext, - merge_validation_caches_ext: self.merge_validation_caches_ext, - get_validation_cache_data_ext: self.get_validation_cache_data_ext, + ) -> Result { + (self.create_validation_cache_ext)( + device, + p_create_info, + p_allocator, + p_validation_cache, + ) + } + pub unsafe fn destroy_validation_cache_ext( + &self, + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator) + } + pub unsafe fn merge_validation_caches_ext( + &self, + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: uint32_t, + p_src_caches: *const ValidationCacheEXT, + ) -> Result { + (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) + } + pub unsafe fn get_validation_cache_data_ext( + &self, + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *const size_t, + p_data: *const c_void, + ) -> Result { + (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) } } -} -impl ExtValidationCacheFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtValidationCacheFn { - create_validation_cache_ext: unsafe { - let raw_name = stringify!(vkCreateValidationCacheEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_validation_cache_ext: unsafe { - let raw_name = stringify!(vkDestroyValidationCacheEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - merge_validation_caches_ext: unsafe { - let raw_name = stringify!(vkMergeValidationCachesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_validation_cache_data_ext: unsafe { - let raw_name = stringify!(vkGetValidationCacheDataEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_EXT_validation_cache\'"] + impl StructureType { + pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = StructureType(1000160000); + } + #[doc = "Generated from \'VK_EXT_validation_cache\'"] + impl StructureType { + pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = StructureType(1000160001); + } + #[doc = "Generated from \'VK_EXT_validation_cache\'"] + impl ObjectType { + pub const VALIDATION_CACHE_EXT: Self = ObjectType(1000160000); + } + pub struct ExtDescriptorIndexingFn {} + unsafe impl Send for ExtDescriptorIndexingFn {} + unsafe impl Sync for ExtDescriptorIndexingFn {} + impl ::std::clone::Clone for ExtDescriptorIndexingFn { + fn clone(&self) -> Self { + ExtDescriptorIndexingFn {} } } - pub unsafe fn create_validation_cache_ext( - &self, - device: Device, - p_create_info: *const ValidationCacheCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_validation_cache: *const ValidationCacheEXT, - ) -> Result { - (self.create_validation_cache_ext)(device, p_create_info, p_allocator, p_validation_cache) - } - pub unsafe fn destroy_validation_cache_ext( - &self, - device: Device, - validation_cache: ValidationCacheEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator) - } - pub unsafe fn merge_validation_caches_ext( - &self, - device: Device, - dst_cache: ValidationCacheEXT, - src_cache_count: uint32_t, - p_src_caches: *const ValidationCacheEXT, - ) -> Result { - (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) - } - pub unsafe fn get_validation_cache_data_ext( - &self, - device: Device, - validation_cache: ValidationCacheEXT, - p_data_size: *const size_t, - p_data: *const c_void, - ) -> Result { - (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) - } -} -pub struct KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void, - cmd_draw_indexed_indirect_count_khr: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void, -} -unsafe impl Send for KhrDrawIndirectCountFn {} -unsafe impl Sync for KhrDrawIndirectCountFn {} -impl ::std::clone::Clone for KhrDrawIndirectCountFn { - fn clone(&self) -> Self { - KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: self.cmd_draw_indirect_count_khr, - cmd_draw_indexed_indirect_count_khr: self.cmd_draw_indexed_indirect_count_khr, + impl ExtDescriptorIndexingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDescriptorIndexingFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } } } -} -impl KhrDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: unsafe { - let raw_name = stringify!(vkCmdDrawIndirectCountKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_draw_indexed_indirect_count_khr: unsafe { - let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = + StructureType(1000161000); + } + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = + StructureType(1000161001); + } + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = + StructureType(1000161002); + } + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl StructureType { + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = + StructureType(1000161003); + } + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl StructureType { + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = + StructureType(1000161004); + } + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl DescriptorPoolCreateFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorPoolCreateFlags(0b10); + } + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl DescriptorSetLayoutCreateFlags { + pub const UPDATE_AFTER_BIND_POOL_EXT: Self = DescriptorSetLayoutCreateFlags(0b10); + } + #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] + impl Result { + pub const ERROR_FRAGMENTATION_EXT: Self = Result(1000161000); + } + pub struct ExtShaderViewportIndexLayerFn {} + unsafe impl Send for ExtShaderViewportIndexLayerFn {} + unsafe impl Sync for ExtShaderViewportIndexLayerFn {} + impl ::std::clone::Clone for ExtShaderViewportIndexLayerFn { + fn clone(&self) -> Self { + ExtShaderViewportIndexLayerFn {} } } - pub unsafe fn cmd_draw_indirect_count_khr( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void { - (self.cmd_draw_indirect_count_khr)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) + impl ExtShaderViewportIndexLayerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderViewportIndexLayerFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } } - pub unsafe fn cmd_draw_indexed_indirect_count_khr( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, - ) -> c_void { - (self.cmd_draw_indexed_indirect_count_khr)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) + pub struct KhrMaintenance3Fn {} + unsafe impl Send for KhrMaintenance3Fn {} + unsafe impl Sync for KhrMaintenance3Fn {} + impl ::std::clone::Clone for KhrMaintenance3Fn { + fn clone(&self) -> Self { + KhrMaintenance3Fn {} + } } -} -pub struct ExtExternalMemoryHostFn { - get_memory_host_pointer_properties_ext: - extern "system" fn( + impl KhrMaintenance3Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMaintenance3Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + cmd_draw_indexed_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void, + } + unsafe impl Send for KhrDrawIndirectCountFn {} + unsafe impl Sync for KhrDrawIndirectCountFn {} + impl ::std::clone::Clone for KhrDrawIndirectCountFn { + fn clone(&self) -> Self { + KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: self.cmd_draw_indirect_count_khr, + cmd_draw_indexed_indirect_count_khr: self.cmd_draw_indexed_indirect_count_khr, + } + } + } + impl KhrDrawIndirectCountFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: unsafe { + let raw_name = stringify!(vkCmdDrawIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed_indirect_count_khr: unsafe { + let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_draw_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + pub unsafe fn cmd_draw_indexed_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: uint32_t, + stride: uint32_t, + ) -> c_void { + (self.cmd_draw_indexed_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + } + pub struct ExtGlobalPriorityFn {} + unsafe impl Send for ExtGlobalPriorityFn {} + unsafe impl Sync for ExtGlobalPriorityFn {} + impl ::std::clone::Clone for ExtGlobalPriorityFn { + fn clone(&self) -> Self { + ExtGlobalPriorityFn {} + } + } + impl ExtGlobalPriorityFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtGlobalPriorityFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_EXT_global_priority\'"] + impl StructureType { + pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = StructureType(1000174000); + } + #[doc = "Generated from \'VK_EXT_global_priority\'"] + impl Result { + pub const ERROR_NOT_PERMITTED_EXT: Self = Result(1000174001); + } + pub struct ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , p_host_pointer : *const c_void , p_memory_host_pointer_properties : *const MemoryHostPointerPropertiesEXT , ) -> Result , } + unsafe impl Send for ExtExternalMemoryHostFn {} + unsafe impl Sync for ExtExternalMemoryHostFn {} + impl ::std::clone::Clone for ExtExternalMemoryHostFn { + fn clone(&self) -> Self { + ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: self.get_memory_host_pointer_properties_ext, + } + } + } + impl ExtExternalMemoryHostFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: unsafe { + let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_host_pointer_properties_ext( + &self, device: Device, handle_type: ExternalMemoryHandleTypeFlags, p_host_pointer: *const c_void, p_memory_host_pointer_properties: *const MemoryHostPointerPropertiesEXT, - ) -> Result, -} -unsafe impl Send for ExtExternalMemoryHostFn {} -unsafe impl Sync for ExtExternalMemoryHostFn {} -impl ::std::clone::Clone for ExtExternalMemoryHostFn { - fn clone(&self) -> Self { - ExtExternalMemoryHostFn { - get_memory_host_pointer_properties_ext: self.get_memory_host_pointer_properties_ext, + ) -> Result { + (self.get_memory_host_pointer_properties_ext)( + device, + handle_type, + p_host_pointer, + p_memory_host_pointer_properties, + ) } } -} -impl ExtExternalMemoryHostFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExternalMemoryHostFn { - get_memory_host_pointer_properties_ext: unsafe { - let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + #[doc = "Generated from \'VK_EXT_external_memory_host\'"] + impl StructureType { + pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = StructureType(1000178000); + } + #[doc = "Generated from \'VK_EXT_external_memory_host\'"] + impl StructureType { + pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = StructureType(1000178001); + } + #[doc = "Generated from \'VK_EXT_external_memory_host\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = + StructureType(1000178002); + } + #[doc = "Generated from \'VK_EXT_external_memory_host\'"] + impl ExternalMemoryHandleTypeFlags { + pub const HOST_ALLOCATION_EXT: Self = ExternalMemoryHandleTypeFlags(0b10000000); + } + #[doc = "Generated from \'VK_EXT_external_memory_host\'"] + impl ExternalMemoryHandleTypeFlags { + pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = ExternalMemoryHandleTypeFlags(0b100000000); + } + pub struct AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: uint32_t, + ) -> c_void, + } + unsafe impl Send for AmdBufferMarkerFn {} + unsafe impl Sync for AmdBufferMarkerFn {} + impl ::std::clone::Clone for AmdBufferMarkerFn { + fn clone(&self) -> Self { + AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: self.cmd_write_buffer_marker_amd, + } } } - pub unsafe fn get_memory_host_pointer_properties_ext( - &self, - device: Device, - handle_type: ExternalMemoryHandleTypeFlags, - p_host_pointer: *const c_void, - p_memory_host_pointer_properties: *const MemoryHostPointerPropertiesEXT, - ) -> Result { - (self.get_memory_host_pointer_properties_ext)( - device, - handle_type, - p_host_pointer, - p_memory_host_pointer_properties, - ) - } -} -pub struct AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: extern "system" fn( - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - dst_buffer: Buffer, - dst_offset: DeviceSize, - marker: uint32_t, - ) -> c_void, -} -unsafe impl Send for AmdBufferMarkerFn {} -unsafe impl Sync for AmdBufferMarkerFn {} -impl ::std::clone::Clone for AmdBufferMarkerFn { - fn clone(&self) -> Self { - AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: self.cmd_write_buffer_marker_amd, + impl AmdBufferMarkerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: unsafe { + let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_write_buffer_marker_amd( + &self, + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: uint32_t, + ) -> c_void { + (self.cmd_write_buffer_marker_amd)( + command_buffer, + pipeline_stage, + dst_buffer, + dst_offset, + marker, + ) } } -} -impl AmdBufferMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: unsafe { - let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) + pub struct AmdShaderCorePropertiesFn {} + unsafe impl Send for AmdShaderCorePropertiesFn {} + unsafe impl Sync for AmdShaderCorePropertiesFn {} + impl ::std::clone::Clone for AmdShaderCorePropertiesFn { + fn clone(&self) -> Self { + AmdShaderCorePropertiesFn {} } } - pub unsafe fn cmd_write_buffer_marker_amd( - &self, - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - dst_buffer: Buffer, - dst_offset: DeviceSize, - marker: uint32_t, - ) -> c_void { - (self.cmd_write_buffer_marker_amd)( - command_buffer, - pipeline_stage, - dst_buffer, - dst_offset, - marker, - ) + impl AmdShaderCorePropertiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderCorePropertiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_AMD_shader_core_properties\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = StructureType(1000185000); + } + pub struct ExtVertexAttributeDivisorFn {} + unsafe impl Send for ExtVertexAttributeDivisorFn {} + unsafe impl Sync for ExtVertexAttributeDivisorFn {} + impl ::std::clone::Clone for ExtVertexAttributeDivisorFn { + fn clone(&self) -> Self { + ExtVertexAttributeDivisorFn {} + } + } + impl ExtVertexAttributeDivisorFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtVertexAttributeDivisorFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = + StructureType(1000190000); + } + #[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] + impl StructureType { + pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = + StructureType(1000190001); + } + pub struct NvShaderSubgroupPartitionedFn {} + unsafe impl Send for NvShaderSubgroupPartitionedFn {} + unsafe impl Sync for NvShaderSubgroupPartitionedFn {} + impl ::std::clone::Clone for NvShaderSubgroupPartitionedFn { + fn clone(&self) -> Self { + NvShaderSubgroupPartitionedFn {} + } + } + impl NvShaderSubgroupPartitionedFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvShaderSubgroupPartitionedFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_NV_shader_subgroup_partitioned\'"] + impl SubgroupFeatureFlags { + pub const PARTITIONED_NV: Self = SubgroupFeatureFlags(0b100000000); } } diff --git a/generator/src/bin/generator.rs b/generator/src/bin/generator.rs index 0ce52c6..c639a2a 100644 --- a/generator/src/bin/generator.rs +++ b/generator/src/bin/generator.rs @@ -1,12 +1,7 @@ -#[macro_use] extern crate generator; -use generator::*; -use std::collections::HashMap; -use std::fs::File; -use std::io::Write; +use generator::write_source_code; use std::path::Path; fn main() { - //let file = File::open("New-Vulkan-XML-Format/vk_new.xml").expect("vknew"); - write_source_code(Path::new("vk.xml")); + write_source_code(Path::new("Vulkan-Headers/registry/vk.xml")); } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 09d1981..5ad486a 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1,7 +1,4 @@ #![recursion_limit = "256"] -// extern crate serde; -// #[macro_use] -// extern crate serde_derive; #[macro_use] extern crate nom; extern crate heck; @@ -15,9 +12,9 @@ pub extern crate vkxml; use heck::{CamelCase, ShoutySnakeCase, SnakeCase}; use itertools::Itertools; -use proc_macro2::{Term, TokenTree}; +use proc_macro2::Term; use quote::Tokens; -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use std::path::Path; use syn::Ident; pub trait ExtensionExt {} @@ -380,6 +377,7 @@ impl ConstantExt for vkxml::ExtensionEnum { self.notation.as_ref().map(|s| s.as_str()) } } + impl ConstantExt for vkxml::Constant { fn variant_ident(&self, enum_name: &str) -> Ident { variant_ident(enum_name, &self.name) @@ -392,6 +390,7 @@ impl ConstantExt for vkxml::Constant { } } +#[derive(Debug)] pub enum Constant { Number(i32), Hex(String), @@ -459,7 +458,6 @@ impl Constant { } pub fn from_extension_enum(constant: &vkxml::ExtensionEnum) -> Option { - println!("{:#?}", constant); let number = constant.number.map(|n| Constant::Number(n)); let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); @@ -593,7 +591,7 @@ impl ToTokens for vkxml::ReferenceType { } } } -fn name_to_tokens(type_name: &str) -> Tokens { +fn name_to_tokens(type_name: &str) -> Ident { let new_name = match type_name { "int" => "c_int", "void" => "c_void", @@ -609,10 +607,7 @@ fn name_to_tokens(type_name: &str) -> Tokens { } }; let new_name = new_name.replace("FlagBits", "Flags"); - let name = Term::intern(new_name.as_str()); - quote! { - #name - } + Ident::from(new_name.as_str()) } fn to_type_tokens(type_name: &str, reference: Option<&vkxml::ReferenceType>) -> Tokens { let new_name = name_to_tokens(type_name); @@ -677,8 +672,6 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo let params: Vec> = commands .iter() .map(|cmd| { - let fn_name_raw = cmd.name.as_str(); - let fn_name_snake = cmd.command_ident(); let params: Vec<_> = cmd .param .iter() @@ -715,7 +708,6 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo .collect(); let expanded_params_ref = &expanded_params; - let params_ref = ¶ms; let return_types: Vec<_> = commands .iter() .map(|cmd| cmd.return_type.type_tokens()) @@ -773,110 +765,122 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo } } } -pub fn generate_interface_item(items: &[vk_parse::InterfaceItem]) -> quote::Tokens { - use vk_parse::InterfaceItem::*; - for item in items { - match item { - Type { name,.. } => println!("type {}", name), - Enum(e) => println!("type {}", name), - _ => () - }; - } - quote!{} +pub struct ExtensionConstant<'a> { + pub name: &'a str, + pub constant: Constant, } -pub fn generate_extension2( +impl<'a> ConstantExt for ExtensionConstant<'a> { + fn variant_ident(&self, enum_name: &str) -> Ident { + variant_ident(enum_name, self.name) + } + fn to_tokens(&self) -> Tokens { + self.constant.to_tokens() + } + fn notation(&self) -> Option<&str> { + None + } +} + +pub fn generate_extension_constants<'a>( + extension: &'a vk_parse::Extension, + const_cache: &mut HashSet<&'a str>, +) -> quote::Tokens { + let items = extension + .items + .iter() + .filter_map(|item| match item { + vk_parse::ExtensionItem::Require { items, .. } => Some(items.iter()), + _ => None, + }) + .flat_map(|iter| iter); + let enum_tokens = items.filter_map(|item| match item { + vk_parse::InterfaceItem::Enum(_enum) => { + use vk_parse::EnumSpec; + if const_cache.contains(_enum.name.as_str()) { + return None; + } + let (constant, extends) = match &_enum.spec { + EnumSpec::Alias { .. } => None, + EnumSpec::Value { .. } => None, + EnumSpec::Bitpos { bitpos, extends } => { + Some((Constant::BitPos(*bitpos as u32), extends.clone())) + } + EnumSpec::Offset { + offset, + extends, + extnumber, + .. + } => { + let ext_base = 1000000000; + let ext_block_size = 1000; + let extnumber = extnumber.unwrap_or_else(|| extension.number.expect("number")); + let value = ext_base + (extnumber - 1) * ext_block_size + offset; + Some((Constant::Number(value as i32), Some(extends.clone()))) + } + _ => None, + }?; + let extends = extends?; + let ext_constant = ExtensionConstant { + name: &_enum.name, + constant, + }; + let ident = name_to_tokens(&extends); + let impl_block = bitflags_impl_block(&ident, &extends, &[&ext_constant]); + let doc_string = format!("Generated from '{}'", extension.name); + let q = quote!{ + #[doc = #doc_string] + #impl_block + }; + + const_cache.insert(_enum.name.as_str()); + Some(q) + } + _ => None, + }); + quote!{ + #(#enum_tokens)* + } +} +pub fn generate_extension_commands( extension: &vk_parse::Extension, cmd_map: &CommandMap, +) -> Tokens { + let commands = extension + .items + .iter() + .filter_map(|ext_item| match ext_item { + vk_parse::ExtensionItem::Require { items, .. } => { + Some(items.iter().filter_map(|item| match item { + vk_parse::InterfaceItem::Command { name, .. } => { + cmd_map.get(name).map(|c| *c) + } + _ => None, + })) + } + _ => None, + }) + .flat_map(|iter| iter) + .collect_vec(); + let name = format!("{}Fn", extension.name.to_camel_case()); + let ident = Ident::from(&name[2..]); + generate_function_pointers(ident, &commands) +} +pub fn generate_extension<'a>( + extension: &'a vk_parse::Extension, + cmd_map: &CommandMap, + const_cache: &mut HashSet<&'a str>, ) -> Option { let _ = extension .supported .as_ref() .filter(|s| s.as_str() == "vulkan")?; - extension - .items - .iter() - .filter_map(|item| match item { - vk_parse::ExtensionItem::Require { - extension: ext, - feature, - items, - .. - } => { - //println!("feature {:?} - {:?}", feature, ext); - let t = generate_interface_item(items); - Some(t) - } - _ => None, - }) - .collect_vec(); - - None -} -pub fn generate_extension(extension: &vkxml::Extension, cmd_map: &CommandMap) -> quote::Tokens { - // Don't generate disabled or reserved extensions - if extension.disabled { - return quote!{}; - } - let cmd_refs = extension - .elements - .iter() - .flat_map(|ext| { - if let &vkxml::ExtensionElement::Require(ref spec) = ext { - spec.elements - .iter() - .filter_map(|extension_spec| match extension_spec { - vkxml::ExtensionSpecificationElement::CommandReference(ref cmd_ref) => { - Some(cmd_ref) - } - _ => None, - }) - .collect() - } else { - vec![] - } - }) - .collect_vec(); - let commands = cmd_refs - .iter() - .filter_map(|cmd_ref| cmd_map.get(&cmd_ref.name).map(|c| *c)) - .collect_vec(); - let name = format!("{}Fn", extension.name.to_camel_case()); - let ident = Ident::from(&name[2..]); - let fp = generate_function_pointers(ident, &commands); - let extension_enums = extension - .elements - .iter() - .flat_map(|ext| { - println!("{:?}", ext); - if let &vkxml::ExtensionElement::Require(ref spec) = ext { - spec.elements - .iter() - .filter_map(|extension_spec| match extension_spec { - vkxml::ExtensionSpecificationElement::Enum(ref _enum) => Some(_enum), - _ => None, - }) - .collect() - } else { - vec![] - } - }) - .collect_vec(); - let extend_enums = extension_enums.iter().filter_map(|&constant| { - let c = Constant::from_extension_enum(constant)?; - let variant_ident = variant_ident(&constant.extends, &constant.name); - let tokens = c.to_tokens(); - let enum_name = name_to_tokens(&constant.extends); - Some(quote! { - impl #enum_name { - pub const #variant_ident: Self = #enum_name(#tokens); - } - }) - }); - //println!("{:#?}", extension_enums); - quote!{ + let extension_tokens = generate_extension_constants(extension, const_cache); + let fp = generate_extension_commands(extension, cmd_map); + let q = quote!{ #fp - #(#extend_enums)* - } + #extension_tokens + }; + Some(q) } pub fn generate_typedef(typedef: &vkxml::Typedef) -> Tokens { let typedef_name = to_type_tokens(&typedef.name, None); @@ -905,34 +909,6 @@ pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { }) } -pub fn to_variant_ident(enum_name: &str, variant_name: &str) -> Ident { - let tag = ["AMD", "NN", "KHR", "NV", "EXT", "NVX", "KHX"] - .iter() - .filter_map(|tag| { - if enum_name.ends_with(tag) { - Some(tag) - } else { - None - } - }) - .nth(0); - - let name_without_tag = tag - .map(|t| enum_name.replace(t, "")) - .unwrap_or(enum_name.into()); - let variant_without_tag = tag - .map(|t| variant_name.replace(&format!("_{}", t), "")) - .unwrap_or(variant_name.into()); - let camel_case_name_enum = &name_without_tag.to_camel_case(); - let name = variant_without_tag.to_camel_case()[2..].replace(camel_case_name_enum, ""); - let is_digit = name.chars().nth(0).map(|c| c.is_digit(10)).unwrap_or(false); - if is_digit { - Ident::from(format!("Type{}", name).as_str()) - } else { - Ident::from(name) - } -} - pub enum EnumType { Bitflags(Tokens), Enum(Tokens), @@ -942,7 +918,6 @@ pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { let _name = enum_name.split("FlagBits").nth(0).expect("split"); let struct_name = _name.to_shouty_snake_case(); let new_variant_name = variant_name.replace(&struct_name, "").replace("VK", ""); - // Not every variant in the vk.xml has a correct shouty snake case name let new_variant_name = new_variant_name .trim_matches('_') .to_shouty_snake_case() @@ -961,13 +936,13 @@ pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { pub fn bitflags_impl_block( ident: &Ident, - _enum: &vkxml::Enumeration, + enum_name: &str, constants: &[&impl ConstantExt], ) -> Tokens { let variants = constants .iter() .map(|constant| { - let variant_ident = constant.variant_ident(&_enum.name); + let variant_ident = constant.variant_ident(enum_name); let tokens = constant.to_tokens(); (variant_ident, tokens) }) @@ -996,9 +971,9 @@ pub fn bitflags_impl_block( } } -pub fn generate_enum( - _enum: &vkxml::Enumeration, - create_info_constants: &[&vkxml::Constant], +pub fn generate_enum<'a>( + _enum: &'a vkxml::Enumeration, + const_cache: &mut HashSet<&'a str>, ) -> EnumType { let name = &_enum.name[2..]; let _name = name.replace("FlagBits", "Flags"); @@ -1011,6 +986,9 @@ pub fn generate_enum( _ => None, }) .collect_vec(); + for constant in &constants { + const_cache.insert(constant.name.as_str()); + } if name.contains("Bit") { let ident = Ident::from(_name.as_str()); @@ -1020,21 +998,21 @@ pub fn generate_enum( .fold(0, |acc, next| acc | next.bits()); let all_bits_term = Term::intern(&format!("0b{:b}", all_bits)); - let impl_bitflags = bitflags_impl_block(&ident, _enum, &constants); + let impl_bitflags = bitflags_impl_block(&ident, &_enum.name, &constants); let q = quote!{ #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct #ident(Flags); + pub struct #ident(pub(crate) Flags); vk_bitflags_wrapped!(#ident, #all_bits_term, Flags); #impl_bitflags }; EnumType::Bitflags(q) } else { - let impl_block = bitflags_impl_block(&ident, _enum, &constants); + let impl_block = bitflags_impl_block(&ident, &_enum.name, &constants); let enum_quote = quote!{ #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] - pub struct #ident(pub i32); + pub struct #ident(pub(crate) i32); #impl_block }; let special_quote = match _name.as_str() { @@ -1263,16 +1241,16 @@ pub fn generate_feature(feature: &vkxml::Feature, commands: &CommandMap) -> quot #device } } -pub fn generate_constant(constant: &vkxml::Constant) -> Tokens { +pub fn generate_constant<'a>( + constant: &'a vkxml::Constant, + cache: &mut HashSet<&'a str>, +) -> Tokens { + cache.insert(constant.name.as_str()); let c = Constant::from_constant(constant); let ident = Ident::from(constant.name.as_str()); let value = c.to_tokens(); let ty = c.ty().to_tokens(); quote!{ - // pub mod constants { - // pub const #ident: #ty = #value; - // } - //pub use constants::*; pub const #ident: #ty = #value; } } @@ -1290,29 +1268,6 @@ pub fn write_source_code(path: &Path) { }) .nth(0) .expect("extension"); - // for ext in extensions { - // println!("{}", ext.name); - // for item in &ext.items { - // match item { - // vk_parse::ExtensionItem::Require { items, .. } => { - // for interface in items { - // match interface { - // vk_parse::InterfaceItem::Enum(ref e) => match &e.spec { - // vk_parse::EnumSpec::Value { value, extends } => { - // print!("{} - ", e.name,); - // println!("{} {:?}", value, extends); - // } - // _ => (), - // }, - // _ => (), - // } - // } - // } - // _ => (), - // } - // } - // println!("ext {} {:?}", ext.name, ext.supported); - // } let spec = vk_parse::parse_file_as_vkxml(path); let commands: HashMap = spec @@ -1325,10 +1280,6 @@ pub fn write_source_code(path: &Path) { .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) .collect(); - let _ = extensions - .iter() - .filter_map(|ext| generate_extension2(ext, &commands)) - .collect_vec(); let features: Vec<&vkxml::Feature> = spec .elements .iter() @@ -1339,16 +1290,6 @@ pub fn write_source_code(path: &Path) { .flat_map(|features| features.elements.iter().map(|feature| feature)) .collect(); - // let extensions: Vec<&vkxml::Extension> = spec - // .elements - // .iter() - // .filter_map(|elem| match elem { - // &vkxml::RegistryElement::Extensions(ref extensions) => Some(extensions), - // _ => None, - // }) - // .flat_map(|extensions| extensions.elements.iter().map(|extension| extension)) - // .collect(); - let definitions: Vec<&vkxml::DefinitionsElement> = spec .elements .iter() @@ -1384,20 +1325,25 @@ pub fn write_source_code(path: &Path) { .flat_map(|constants| constants.elements.iter()) .collect(); - let (enum_code, bitflags_code) = enums.into_iter().map(|e| generate_enum(e, &[])).fold( - (Vec::new(), Vec::new()), - |mut acc, elem| { + let mut const_cache = HashSet::new(); + let (enum_code, bitflags_code) = enums + .into_iter() + .map(|e| generate_enum(e, &mut const_cache)) + .fold((Vec::new(), Vec::new()), |mut acc, elem| { match elem { EnumType::Enum(token) => acc.0.push(token), EnumType::Bitflags(token) => acc.1.push(token), }; acc - }, - ); + }); let constants_code: Vec<_> = constants .iter() - .map(|constant| generate_constant(constant)) + .map(|constant| generate_constant(constant, &mut const_cache)) .collect(); + let extension_code = extensions + .iter() + .filter_map(|ext| generate_extension(ext, &commands, &mut const_cache)) + .collect_vec(); let definition_code: Vec<_> = definitions .into_iter() @@ -1409,10 +1355,6 @@ pub fn write_source_code(path: &Path) { .map(|feature| generate_feature(feature, &commands)) .collect(); - // let extension_code: Vec<_> = extensions - // .iter() - // .map(|ext| generate_extension(ext, &commands)) - // .collect(); let mut file = File::create("../ash/src/vk.rs").expect("vk"); let bitflags_macro = vk_bitflags_wrapped_macro(); let handle_nondispatchable_macro = handle_nondispatchable_macro(); @@ -1420,7 +1362,12 @@ pub fn write_source_code(path: &Path) { let version_macros = vk_version_macros(); let platform_specific_types = platform_specific_types(); let source_code = quote!{ + #[doc(hidden)] pub use libc::*; + #[doc(hidden)] + pub use self::extensions::*; + #[doc(hidden)] + pub use self::bitflags::*; #version_macros #platform_specific_types #bitflags_macro @@ -1429,9 +1376,15 @@ pub fn write_source_code(path: &Path) { #(#feature_code)* #(#definition_code)* #(#enum_code)* - #(#bitflags_code)* + pub mod bitflags { + use super::*; + #(#bitflags_code)* + } #(#constants_code)* - //#(#extension_code)* + pub mod extensions { + use super::*; + #(#extension_code)* + } }; - write!(&mut file, "{}", source_code); + write!(&mut file, "{}", source_code).expect("Unable to write to file"); } From 65f4b7584c981dc8d74e65c1b87d56b681d7f6d1 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 29 Jul 2018 22:46:21 +0200 Subject: [PATCH 026/122] Add submodule --- generator/Vulkan-Headers/.cmake-format.py | 34 + generator/Vulkan-Headers/.gitignore | 5 + generator/Vulkan-Headers/BUILD.md | 270 + generator/Vulkan-Headers/CMakeLists.txt | 37 + generator/Vulkan-Headers/LICENSE.txt | 170 + generator/Vulkan-Headers/README.md | 3 + .../Vulkan-Headers/cmake/Copyright_cmake.txt | 126 + .../cmake/cmake_uninstall.cmake.in | 21 + .../Vulkan-Headers/include/vulkan/vk_icd.h | 170 + .../Vulkan-Headers/include/vulkan/vk_layer.h | 195 + .../include/vulkan/vk_platform.h | 92 + .../include/vulkan/vk_sdk_platform.h | 69 + .../Vulkan-Headers/include/vulkan/vulkan.h | 79 + .../Vulkan-Headers/include/vulkan/vulkan.hpp | 43865 ++++++++++++++++ .../include/vulkan/vulkan_android.h | 126 + .../include/vulkan/vulkan_core.h | 7586 +++ .../include/vulkan/vulkan_ios.h | 58 + .../include/vulkan/vulkan_macos.h | 58 + .../include/vulkan/vulkan_mir.h | 65 + .../Vulkan-Headers/include/vulkan/vulkan_vi.h | 58 + .../include/vulkan/vulkan_wayland.h | 65 + .../include/vulkan/vulkan_win32.h | 276 + .../include/vulkan/vulkan_xcb.h | 66 + .../include/vulkan/vulkan_xlib.h | 66 + .../include/vulkan/vulkan_xlib_xrandr.h | 54 + .../Vulkan-Headers/registry/cgenerator.py | 417 + .../Vulkan-Headers/registry/generator.py | 595 + generator/Vulkan-Headers/registry/genvk.py | 531 + generator/Vulkan-Headers/registry/reg.py | 1066 + .../Vulkan-Headers/registry/validusage.json | 19076 +++++++ generator/Vulkan-Headers/registry/vk.xml | 8842 ++++ 31 files changed, 84141 insertions(+) create mode 100644 generator/Vulkan-Headers/.cmake-format.py create mode 100644 generator/Vulkan-Headers/.gitignore create mode 100644 generator/Vulkan-Headers/BUILD.md create mode 100644 generator/Vulkan-Headers/CMakeLists.txt create mode 100644 generator/Vulkan-Headers/LICENSE.txt create mode 100644 generator/Vulkan-Headers/README.md create mode 100644 generator/Vulkan-Headers/cmake/Copyright_cmake.txt create mode 100644 generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in create mode 100644 generator/Vulkan-Headers/include/vulkan/vk_icd.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vk_layer.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vk_platform.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan.hpp create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_android.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_core.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_ios.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_macos.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_mir.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_vi.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_win32.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h create mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h create mode 100644 generator/Vulkan-Headers/registry/cgenerator.py create mode 100644 generator/Vulkan-Headers/registry/generator.py create mode 100644 generator/Vulkan-Headers/registry/genvk.py create mode 100644 generator/Vulkan-Headers/registry/reg.py create mode 100644 generator/Vulkan-Headers/registry/validusage.json create mode 100644 generator/Vulkan-Headers/registry/vk.xml diff --git a/generator/Vulkan-Headers/.cmake-format.py b/generator/Vulkan-Headers/.cmake-format.py new file mode 100644 index 0000000..9c173ac --- /dev/null +++ b/generator/Vulkan-Headers/.cmake-format.py @@ -0,0 +1,34 @@ +# Configuration for cmake-format (v0.3.6, circa Apr 2018) +# https://github.com/cheshirekow/cmake_format + +# How wide to allow formatted cmake files +line_width = 132 + +# How many spaces to tab for indent +tab_size = 4 + +# If arglists are longer than this, break them always +max_subargs_per_line = 3 + +# If true, separate flow control names from their parentheses with a space +separate_ctrl_name_with_space = False + +# If true, separate function names from parentheses with a space +separate_fn_name_with_space = False + +# If a statement is wrapped to more than one line, than dangle the closing +# parenthesis on it's own line +dangle_parens = False + +# What character to use for bulleted lists +bullet_char = u'*' + +# What character to use as punctuation after numerals in an enumerated list +enum_char = u'.' + +# What style line endings to use in the output. +line_ending = u'unix' + +# Format command names consistently as 'lower' or 'upper' case +command_case = u'lower' + diff --git a/generator/Vulkan-Headers/.gitignore b/generator/Vulkan-Headers/.gitignore new file mode 100644 index 0000000..23e1481 --- /dev/null +++ b/generator/Vulkan-Headers/.gitignore @@ -0,0 +1,5 @@ +# Python cache +__pycache__ +*.pyc +build +.vscode/ diff --git a/generator/Vulkan-Headers/BUILD.md b/generator/Vulkan-Headers/BUILD.md new file mode 100644 index 0000000..0f0114e --- /dev/null +++ b/generator/Vulkan-Headers/BUILD.md @@ -0,0 +1,270 @@ +# Build Instructions + +Instructions for building this repository on Windows, Linux, and MacOS. + +## Index + +1. [Contributing](#contributing-to-the-repository) +1. [Repository Content](#repository-content) +1. [Repository Set-up](#repository-set-up) +1. [Windows Build](#building-on-windows) +1. [Linux Build](#building-on-linux) +1. [MacOS Build](#building-on-macos) + +## Contributing to the Repository + +The contents of this repository are sourced primarily from the Khronos Vulkan +API specification [repository](https://github.com/KhronosGroup/Vulkan-Docs). +Please visit that repository for information on contributing. + +## Repository Content + +This repository contains the Vulkan header files and the Vulkan API definition +(registry) with its related files. This repository does not create libraries +or executables. + +However, this repository contains CMake build configuration files to "install" +the files from this repository to a specific install directory. For example, +you can install the files to a system directory such as `/usr/local` on Linux. + +If you are building other Vulkan-related repositories such as +[Vulkan-Loader](https://github.com/KhronosGroup/Vulkan-Loader), +you need to build the install target of this repository and provide the +resulting install directory to those repositories. + +### Installed Files + +The `install` target installs the following files under the directory +indicated by *install_dir*: + +- *install_dir*`/include/vulkan` : The header files found in the + `include/vulkan` directory of this repository +- *install_dir*`/share/vulkan/registry` : The registry files found in the + `registry` directory of this repository + +The `uninstall` target can be used to remove the above files from the install +directory. + +## Repository Set-Up + +### Download the Repository + +To create your local git repository: + + git clone https://github.com/KhronosGroup/Vulkan-Headers.git + +### Repository Dependencies + +This repository does not depend on any other repositories. + +### Build and Install Directories + +A common convention is to place the build directory in the top directory of +the repository with a name of `build` and place the install directory as a +child of the build directory with the name `install`. The remainder of these +instructions follow this convention, although you can use any name for these +directories and place them in any location. + +## Building On Windows + +### Windows Development Environment Requirements + +- Windows + - Any Personal Computer version supported by Microsoft +- Microsoft [Visual Studio](https://www.visualstudio.com/) + - Versions + - [2013 (update 4)](https://www.visualstudio.com/vs/older-downloads/) + - [2015](https://www.visualstudio.com/vs/older-downloads/) + - [2017](https://www.visualstudio.com/vs/downloads/) + - The Community Edition of each of the above versions is sufficient, as + well as any more capable edition. +- [CMake](http://www.cmake.org/download/) (Version 2.8.11 or better) + - Use the installer option to add CMake to the system PATH +- Git Client Support + - [Git for Windows](http://git-scm.com/download/win) is a popular solution + for Windows + - Some IDEs (e.g., [Visual Studio](https://www.visualstudio.com/), + [GitHub Desktop](https://desktop.github.com/)) have integrated + Git client support + +### Windows Build - Microsoft Visual Studio + +The general approach is to run CMake to generate the Visual Studio project +files. Then either run CMake with the `--build` option to build from the +command line or use the Visual Studio IDE to open the generated solution and +work with the solution interactively. + +#### Windows Quick Start + + cd Vulkan-Headers + mkdir build + cd build + cmake .. + cmake --build . --target install + +See below for the details. + +#### Use `CMake` to Create the Visual Studio Project Files + +Change your current directory to the top of the cloned repository directory, +create a build directory and generate the Visual Studio project files: + + cd Vulkan-Headers + mkdir build + cd build + cmake .. + +> Note: The `..` parameter tells `cmake` the location of the top of the +> repository. If you place your build directory someplace else, you'll need to +> specify the location of the repository top differently. + +The CMake configuration files set the default install directory location to +`$CMAKE_BINARY_DIR\install`, which is a child of your build directory. In this +example, the install directory becomes the `Vulkan-Headers\build\install` +directory. + +The project installs the header files to + + Vulkan-Headers\build\install\include\vulkan + +and installs the registry files to + + Vulkan-Headers\build\install\share\vulkan\registry + +You can change the install directory with the `CMAKE_INSTALL_PREFIX` CMake +variable. + +For example: + + cd Vulkan-Headers + mkdir build + cd build + cmake -DCMAKE_INSTALL_PREFIX=/c/Users/dev/install .. # MINGW64 shell + +As it starts generating the project files, `cmake` responds with something +like: + + -- Building for: Visual Studio 14 2015 + +which is a 32-bit generator. + +Since this repository does not compile anything, there is no need to specify a +specific generator such as "Visual Studio 14 2015 Win64", so the default +generator should suffice. + +The above steps create a Windows solution file named `Vulkan-Headers.sln` in +the build directory. + +At this point, you can build the solution from the command line or open the +generated solution with Visual Studio. + +#### Build the Solution From the Command Line + +While still in the build directory: + + cmake --build . --target install + +to build the install target. + +Build the `uninstall` target to remove the files from the install directory. + + cmake --build . --target uninstall + +#### Build the Solution With Visual Studio + +Launch Visual Studio and open the "Vulkan-Headers.sln" solution file in the +build directory. Build the `INSTALL` target from the Visual Studio solution +explorer. + +Build the `uninstall` target to remove the files from the install directory. + +> Note: Since there are only the `INSTALL` and `uninstall` projects in the +> solution, building the solution from the command line may be more efficient +> than starting Visual Studio for these simple operations. + +## Building On Linux + +### Linux Development Environment Requirements + +There are no specific Linux distribution or compiler version requirements for +building this repository. The required tools are + +- cmake (Version 2.8.11 or better) +- git + +### Linux Build + +The general approach is to run CMake to generate make files. Then either run +CMake with the `--build` option or `make` to build from the command line. + +#### Linux Quick Start + + cd Vulkan-Headers + mkdir build + cd build + cmake -DCMAKE_INSTALL_PREFIX=install .. + make install + +See below for the details. + +#### Use CMake to Create the Make Files + +Change your current directory to the top of the cloned repository directory, +create a build directory and generate the make files: + + cd Vulkan-Headers + mkdir build + cd build + cmake -DCMAKE_INSTALL_PREFIX=install .. + +> Note: The `..` parameter tells `cmake` the location of the top of the +> repository. If you place your `build` directory someplace else, you'll need +> to specify the location of the repository top differently. + +Set the `CMAKE_INSTALL_PREFIX` variable to the directory to serve as the +destination directory for the `install` target. + +The above `cmake` command sets the install directory to +`$CMAKE_BINARY_DIR/install`, which is a child of your `build` directory. In +this example, the install directory becomes the `Vulkan-Headers/build/install` +directory. + +The make file install target installs the header files to + + Vulkan-Headers/build/install/include/vulkan + +and installs the registry files to + + Vulkan-Headers/build/install/share/vulkan/registry + +> Note: For Linux, the default value for `CMAKE_INSTALL_PREFIX` is +> `/usr/local`, which would be used if you do not specify +> `CMAKE_INSTALL_PREFIX`. In this case, you may need to use `sudo` to install +> to system directories later when you run `make install`. + +Note that after generating the make files, running `make`: + + make + +does nothing, since there are no libraries or executables to build. + +To install the header files: + + make install + +or + + cmake --build . --target install + +To uninstall the files from the install directories, you can execute: + + make uninstall + +or + + cmake --build . --target uninstall + +## Building on MacOS + +The instructions for building this repository on MacOS are the same as those +for Linux. diff --git a/generator/Vulkan-Headers/CMakeLists.txt b/generator/Vulkan-Headers/CMakeLists.txt new file mode 100644 index 0000000..fb95d64 --- /dev/null +++ b/generator/Vulkan-Headers/CMakeLists.txt @@ -0,0 +1,37 @@ +# ~~~ +# Copyright (c) 2018 Valve Corporation +# Copyright (c) 2018 LunarG, Inc. +# +# 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. +# ~~~ + +cmake_minimum_required(VERSION 2.8.11) + +project(Vulkan-Headers NONE) + +include(GNUInstallDirs) +# Set a better default install location for Windows only if the user did not provide one. +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32) + set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "default install path" FORCE) +endif() + +install(DIRECTORY "${CMAKE_SOURCE_DIR}/include/vulkan" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) +install(DIRECTORY "${CMAKE_SOURCE_DIR}/registry" DESTINATION ${CMAKE_INSTALL_DATADIR}/vulkan) + +# uninstall target +if(NOT TARGET uninstall) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE + @ONLY) + add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) +endif() diff --git a/generator/Vulkan-Headers/LICENSE.txt b/generator/Vulkan-Headers/LICENSE.txt new file mode 100644 index 0000000..3c65815 --- /dev/null +++ b/generator/Vulkan-Headers/LICENSE.txt @@ -0,0 +1,170 @@ +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 + +APPENDIX: HOW TO APPLY THE APACHE LICENSE TO YOUR WORK +To apply the Apache License to your work, attach the following boilerplate notice, with +the fields enclosed by brackets "[]" replaced with your own identifying information. +(Don't include the brackets!) The text should be enclosed in the appropriate comment +syntax for the file format. We also recommend that a file or class name and description +of purpose be included on the same "printed page" as the copyright notice for easier +identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + diff --git a/generator/Vulkan-Headers/README.md b/generator/Vulkan-Headers/README.md new file mode 100644 index 0000000..e9661fe --- /dev/null +++ b/generator/Vulkan-Headers/README.md @@ -0,0 +1,3 @@ +# Vulkan-Headers + +Vulkan Header files and API registry diff --git a/generator/Vulkan-Headers/cmake/Copyright_cmake.txt b/generator/Vulkan-Headers/cmake/Copyright_cmake.txt new file mode 100644 index 0000000..743c634 --- /dev/null +++ b/generator/Vulkan-Headers/cmake/Copyright_cmake.txt @@ -0,0 +1,126 @@ +CMake - Cross Platform Makefile Generator +Copyright 2000-2018 Kitware, Inc. and Contributors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +* Neither the name of Kitware, Inc. nor the names of Contributors + may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +------------------------------------------------------------------------------ + +The following individuals and institutions are among the Contributors: + +* Aaron C. Meadows +* Adriaan de Groot +* Aleksey Avdeev +* Alexander Neundorf +* Alexander Smorkalov +* Alexey Sokolov +* Alex Turbov +* Andreas Pakulat +* Andreas Schneider +* André Rigland Brodtkorb +* Axel Huebl, Helmholtz-Zentrum Dresden - Rossendorf +* Benjamin Eikel +* Bjoern Ricks +* Brad Hards +* Christopher Harvey +* Christoph Grüninger +* Clement Creusot +* Daniel Blezek +* Daniel Pfeifer +* Enrico Scholz +* Eran Ifrah +* Esben Mose Hansen, Ange Optimization ApS +* Geoffrey Viola +* Google Inc +* Gregor Jasny +* Helio Chissini de Castro +* Ilya Lavrenov +* Insight Software Consortium +* Jan Woetzel +* Kelly Thompson +* Konstantin Podsvirov +* Mario Bensi +* Mathieu Malaterre +* Matthaeus G. Chajdas +* Matthias Kretz +* Matthias Maennich +* Michael Stürmer +* Miguel A. Figueroa-Villanueva +* Mike Jackson +* Mike McQuaid +* Nicolas Bock +* Nicolas Despres +* Nikita Krupen'ko +* NVIDIA Corporation +* OpenGamma Ltd. +* Patrick Stotko +* Per Øyvind Karlsen +* Peter Collingbourne +* Petr Gotthard +* Philip Lowman +* Philippe Proulx +* Raffi Enficiaud, Max Planck Society +* Raumfeld +* Roger Leigh +* Rolf Eike Beer +* Roman Donchenko +* Roman Kharitonov +* Ruslan Baratov +* Sebastian Holtermann +* Stephen Kelly +* Sylvain Joubert +* Thomas Sondergaard +* Tobias Hunger +* Todd Gamblin +* Tristan Carel +* University of Dundee +* Vadim Zhukov +* Will Dicharry + +See version control history for details of individual contributions. + +The above copyright and license notice applies to distributions of +CMake in source and binary form. Third-party software packages supplied +with CMake under compatible licenses provide their own copyright notices +documented in corresponding subdirectories or source files. + +------------------------------------------------------------------------------ + +CMake was initially developed by Kitware with the following sponsorship: + + * National Library of Medicine at the National Institutes of Health + as part of the Insight Segmentation and Registration Toolkit (ITK). + + * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel + Visualization Initiative. + + * National Alliance for Medical Image Computing (NAMIC) is funded by the + National Institutes of Health through the NIH Roadmap for Medical Research, + Grant U54 EB005149. + + * Kitware, Inc. diff --git a/generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in b/generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in new file mode 100644 index 0000000..2037e36 --- /dev/null +++ b/generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in @@ -0,0 +1,21 @@ +if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") +endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + +file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) +string(REGEX REPLACE "\n" ";" files "${files}") +foreach(file ${files}) + message(STATUS "Uninstalling $ENV{DESTDIR}${file}") + if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + exec_program( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + if(NOT "${rm_retval}" STREQUAL 0) + message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") + endif(NOT "${rm_retval}" STREQUAL 0) + else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + message(STATUS "File $ENV{DESTDIR}${file} does not exist.") + endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") +endforeach(file) diff --git a/generator/Vulkan-Headers/include/vulkan/vk_icd.h b/generator/Vulkan-Headers/include/vulkan/vk_icd.h new file mode 100644 index 0000000..b935fa1 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vk_icd.h @@ -0,0 +1,170 @@ +// +// File: vk_icd.h +// +/* + * Copyright (c) 2015-2016 The Khronos Group Inc. + * Copyright (c) 2015-2016 Valve Corporation + * Copyright (c) 2015-2016 LunarG, Inc. + * + * 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. + * + */ + +#ifndef VKICD_H +#define VKICD_H + +#include "vulkan.h" +#include + +// Loader-ICD version negotiation API. Versions add the following features: +// Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr +// or vk_icdNegotiateLoaderICDInterfaceVersion. +// Version 1 - Add support for vk_icdGetInstanceProcAddr. +// Version 2 - Add Loader/ICD Interface version negotiation +// via vk_icdNegotiateLoaderICDInterfaceVersion. +// Version 3 - Add ICD creation/destruction of KHR_surface objects. +// Version 4 - Add unknown physical device extension qyering via +// vk_icdGetPhysicalDeviceProcAddr. +// Version 5 - Tells ICDs that the loader is now paying attention to the +// application version of Vulkan passed into the ApplicationInfo +// structure during vkCreateInstance. This will tell the ICD +// that if the loader is older, it should automatically fail a +// call for any API version > 1.0. Otherwise, the loader will +// manually determine if it can support the expected version. +#define CURRENT_LOADER_ICD_INTERFACE_VERSION 5 +#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 +#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 +typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); + +// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this +// file directly, it won't be found. +#ifndef PFN_GetPhysicalDeviceProcAddr +typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName); +#endif + +/* + * The ICD must reserve space for a pointer for the loader's dispatch + * table, at the start of . + * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. + */ + +#define ICD_LOADER_MAGIC 0x01CDC0DE + +typedef union { + uintptr_t loaderMagic; + void *loaderData; +} VK_LOADER_DATA; + +static inline void set_loader_magic_value(void *pNewObject) { + VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; + loader_info->loaderMagic = ICD_LOADER_MAGIC; +} + +static inline bool valid_loader_magic_value(void *pNewObject) { + const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; + return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; +} + +/* + * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that + * contains the platform-specific connection and surface information. + */ +typedef enum { + VK_ICD_WSI_PLATFORM_MIR, + VK_ICD_WSI_PLATFORM_WAYLAND, + VK_ICD_WSI_PLATFORM_WIN32, + VK_ICD_WSI_PLATFORM_XCB, + VK_ICD_WSI_PLATFORM_XLIB, + VK_ICD_WSI_PLATFORM_ANDROID, + VK_ICD_WSI_PLATFORM_MACOS, + VK_ICD_WSI_PLATFORM_IOS, + VK_ICD_WSI_PLATFORM_DISPLAY +} VkIcdWsiPlatform; + +typedef struct { + VkIcdWsiPlatform platform; +} VkIcdSurfaceBase; + +#ifdef VK_USE_PLATFORM_MIR_KHR +typedef struct { + VkIcdSurfaceBase base; + MirConnection *connection; + MirSurface *mirSurface; +} VkIcdSurfaceMir; +#endif // VK_USE_PLATFORM_MIR_KHR + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +typedef struct { + VkIcdSurfaceBase base; + struct wl_display *display; + struct wl_surface *surface; +} VkIcdSurfaceWayland; +#endif // VK_USE_PLATFORM_WAYLAND_KHR + +#ifdef VK_USE_PLATFORM_WIN32_KHR +typedef struct { + VkIcdSurfaceBase base; + HINSTANCE hinstance; + HWND hwnd; +} VkIcdSurfaceWin32; +#endif // VK_USE_PLATFORM_WIN32_KHR + +#ifdef VK_USE_PLATFORM_XCB_KHR +typedef struct { + VkIcdSurfaceBase base; + xcb_connection_t *connection; + xcb_window_t window; +} VkIcdSurfaceXcb; +#endif // VK_USE_PLATFORM_XCB_KHR + +#ifdef VK_USE_PLATFORM_XLIB_KHR +typedef struct { + VkIcdSurfaceBase base; + Display *dpy; + Window window; +} VkIcdSurfaceXlib; +#endif // VK_USE_PLATFORM_XLIB_KHR + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +typedef struct { + VkIcdSurfaceBase base; + struct ANativeWindow *window; +} VkIcdSurfaceAndroid; +#endif // VK_USE_PLATFORM_ANDROID_KHR + +#ifdef VK_USE_PLATFORM_MACOS_MVK +typedef struct { + VkIcdSurfaceBase base; + const void *pView; +} VkIcdSurfaceMacOS; +#endif // VK_USE_PLATFORM_MACOS_MVK + +#ifdef VK_USE_PLATFORM_IOS_MVK +typedef struct { + VkIcdSurfaceBase base; + const void *pView; +} VkIcdSurfaceIOS; +#endif // VK_USE_PLATFORM_IOS_MVK + +typedef struct { + VkIcdSurfaceBase base; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkIcdSurfaceDisplay; + +#endif // VKICD_H diff --git a/generator/Vulkan-Headers/include/vulkan/vk_layer.h b/generator/Vulkan-Headers/include/vulkan/vk_layer.h new file mode 100644 index 0000000..823c88a --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vk_layer.h @@ -0,0 +1,195 @@ +// +// File: vk_layer.h +// +/* + * Copyright (c) 2015-2017 The Khronos Group Inc. + * Copyright (c) 2015-2017 Valve Corporation + * Copyright (c) 2015-2017 LunarG, Inc. + * + * 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. + * + */ + +/* Need to define dispatch table + * Core struct can then have ptr to dispatch table at the top + * Along with object ptrs for current and next OBJ + */ +#pragma once + +#include "vulkan.h" +#if defined(__GNUC__) && __GNUC__ >= 4 +#define VK_LAYER_EXPORT __attribute__((visibility("default"))) +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) +#define VK_LAYER_EXPORT __attribute__((visibility("default"))) +#else +#define VK_LAYER_EXPORT +#endif + +#define MAX_NUM_UNKNOWN_EXTS 250 + + // Loader-Layer version negotiation API. Versions add the following features: + // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr + // or vk_icdNegotiateLoaderLayerInterfaceVersion. + // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and + // vk_icdNegotiateLoaderLayerInterfaceVersion. +#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 +#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 + +#define VK_CURRENT_CHAIN_VERSION 1 + +// Typedef for use in the interfaces below +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); + +// Version negotiation values +typedef enum VkNegotiateLayerStructType { + LAYER_NEGOTIATE_UNINTIALIZED = 0, + LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, +} VkNegotiateLayerStructType; + +// Version negotiation structures +typedef struct VkNegotiateLayerInterface { + VkNegotiateLayerStructType sType; + void *pNext; + uint32_t loaderLayerInterfaceVersion; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; + PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; +} VkNegotiateLayerInterface; + +// Version negotiation functions +typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); + +// Function prototype for unknown physical device extension command +typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); + +// ------------------------------------------------------------------------------------------------ +// CreateInstance and CreateDevice support structures + +/* Sub type of structure for instance and device loader ext of CreateInfo. + * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + * then VkLayerFunction indicates struct type pointed to by pNext + */ +typedef enum VkLayerFunction_ { + VK_LAYER_LINK_INFO = 0, + VK_LOADER_DATA_CALLBACK = 1 +} VkLayerFunction; + +typedef struct VkLayerInstanceLink_ { + struct VkLayerInstanceLink_ *pNext; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; + PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; +} VkLayerInstanceLink; + +/* + * When creating the device chain the loader needs to pass + * down information about it's device structure needed at + * the end of the chain. Passing the data via the + * VkLayerDeviceInfo avoids issues with finding the + * exact instance being used. + */ +typedef struct VkLayerDeviceInfo_ { + void *device_info; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; +} VkLayerDeviceInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, + void *object); +typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, + void *object); + +typedef struct { + VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + const void *pNext; + VkLayerFunction function; + union { + VkLayerInstanceLink *pLayerInfo; + PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; + } u; +} VkLayerInstanceCreateInfo; + +typedef struct VkLayerDeviceLink_ { + struct VkLayerDeviceLink_ *pNext; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; +} VkLayerDeviceLink; + +typedef struct { + VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + const void *pNext; + VkLayerFunction function; + union { + VkLayerDeviceLink *pLayerInfo; + PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; + } u; +} VkLayerDeviceCreateInfo; + +#ifdef __cplusplus +extern "C" { +#endif + +VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); + +typedef enum VkChainType { + VK_CHAIN_TYPE_UNKNOWN = 0, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, +} VkChainType; + +typedef struct VkChainHeader { + VkChainType type; + uint32_t version; + uint32_t size; +} VkChainHeader; + +typedef struct VkEnumerateInstanceExtensionPropertiesChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, + VkExtensionProperties *); + const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { + return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); + } +#endif +} VkEnumerateInstanceExtensionPropertiesChain; + +typedef struct VkEnumerateInstanceLayerPropertiesChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); + const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { + return pfnNextLayer(pNextLink, pPropertyCount, pProperties); + } +#endif +} VkEnumerateInstanceLayerPropertiesChain; + +typedef struct VkEnumerateInstanceVersionChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); + const struct VkEnumerateInstanceVersionChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(uint32_t *pApiVersion) const { + return pfnNextLayer(pNextLink, pApiVersion); + } +#endif +} VkEnumerateInstanceVersionChain; + +#ifdef __cplusplus +} +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vk_platform.h b/generator/Vulkan-Headers/include/vulkan/vk_platform.h new file mode 100644 index 0000000..7289299 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vk_platform.h @@ -0,0 +1,92 @@ +// +// File: vk_platform.h +// +/* +** Copyright (c) 2014-2017 The Khronos Group Inc. +** +** 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. +*/ + + +#ifndef VK_PLATFORM_H_ +#define VK_PLATFORM_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* Platform-specific directives and type declarations +*************************************************************************************************** +*/ + +/* Platform-specific calling convention macros. + * + * Platforms should define these so that Vulkan clients call Vulkan commands + * with the same calling conventions that the Vulkan implementation expects. + * + * VKAPI_ATTR - Placed before the return type in function declarations. + * Useful for C++11 and GCC/Clang-style function attribute syntax. + * VKAPI_CALL - Placed after the return type in function declarations. + * Useful for MSVC-style calling convention syntax. + * VKAPI_PTR - Placed between the '(' and '*' in function pointer types. + * + * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); + * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); + */ +#if defined(_WIN32) + // On Windows, Vulkan commands use the stdcall convention + #define VKAPI_ATTR + #define VKAPI_CALL __stdcall + #define VKAPI_PTR VKAPI_CALL +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 + #error "Vulkan isn't supported for the 'armeabi' NDK ABI" +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) + // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" + // calling convention, i.e. float parameters are passed in registers. This + // is true even if the rest of the application passes floats on the stack, + // as it does by default when compiling for the armeabi-v7a NDK ABI. + #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) + #define VKAPI_CALL + #define VKAPI_PTR VKAPI_ATTR +#else + // On other platforms, use the default calling convention + #define VKAPI_ATTR + #define VKAPI_CALL + #define VKAPI_PTR +#endif + +#include + +#if !defined(VK_NO_STDINT_H) + #if defined(_MSC_VER) && (_MSC_VER < 1600) + typedef signed __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef signed __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef signed __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + #include + #endif +#endif // !defined(VK_NO_STDINT_H) + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h b/generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h new file mode 100644 index 0000000..96d8676 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h @@ -0,0 +1,69 @@ +// +// File: vk_sdk_platform.h +// +/* + * Copyright (c) 2015-2016 The Khronos Group Inc. + * Copyright (c) 2015-2016 Valve Corporation + * Copyright (c) 2015-2016 LunarG, Inc. + * + * 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. + */ + +#ifndef VK_SDK_PLATFORM_H +#define VK_SDK_PLATFORM_H + +#if defined(_WIN32) +#define NOMINMAX +#ifndef __cplusplus +#undef inline +#define inline __inline +#endif // __cplusplus + +#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/) +// C99: +// Microsoft didn't implement C99 in Visual Studio; but started adding it with +// VS2013. However, VS2013 still didn't have snprintf(). The following is a +// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the +// "CMakeLists.txt" file). +// NOTE: This is fixed in Visual Studio 2015. +#define snprintf _snprintf +#endif + +#define strdup _strdup + +#endif // _WIN32 + +// Check for noexcept support using clang, with fallback to Windows or GCC version numbers +#ifndef NOEXCEPT +#if defined(__clang__) +#if __has_feature(cxx_noexcept) +#define HAS_NOEXCEPT +#endif +#else +#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 +#define HAS_NOEXCEPT +#else +#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS +#define HAS_NOEXCEPT +#endif +#endif +#endif + +#ifdef HAS_NOEXCEPT +#define NOEXCEPT noexcept +#else +#define NOEXCEPT +#endif +#endif + +#endif // VK_SDK_PLATFORM_H diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan.h b/generator/Vulkan-Headers/include/vulkan/vulkan.h new file mode 100644 index 0000000..d05c849 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan.h @@ -0,0 +1,79 @@ +#ifndef VULKAN_H_ +#define VULKAN_H_ 1 + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +#include "vk_platform.h" +#include "vulkan_core.h" + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#include "vulkan_android.h" +#endif + + +#ifdef VK_USE_PLATFORM_IOS_MVK +#include "vulkan_ios.h" +#endif + + +#ifdef VK_USE_PLATFORM_MACOS_MVK +#include "vulkan_macos.h" +#endif + + +#ifdef VK_USE_PLATFORM_MIR_KHR +#include +#include "vulkan_mir.h" +#endif + + +#ifdef VK_USE_PLATFORM_VI_NN +#include "vulkan_vi.h" +#endif + + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#include +#include "vulkan_wayland.h" +#endif + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#include +#include "vulkan_win32.h" +#endif + + +#ifdef VK_USE_PLATFORM_XCB_KHR +#include +#include "vulkan_xcb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#include +#include "vulkan_xlib.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +#include +#include +#include "vulkan_xlib_xrandr.h" +#endif + +#endif // VULKAN_H_ diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan.hpp b/generator/Vulkan-Headers/include/vulkan/vulkan.hpp new file mode 100644 index 0000000..df24587 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan.hpp @@ -0,0 +1,43865 @@ +// Copyright (c) 2015-2018 The Khronos Group Inc. +// +// 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. +// +// ---- Exceptions to the Apache 2.0 License: ---- +// +// As an exception, if you use this Software to generate code and portions of +// this Software are embedded into the generated code as a result, you may +// redistribute such product without providing attribution as would otherwise +// be required by Sections 4(a), 4(b) and 4(d) of the License. +// +// In addition, if you combine or link code generated by this Software with +// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1 +// ("`Combined Software`") and if a court of competent jurisdiction determines +// that the patent provision (Section 3), the indemnity provision (Section 9) +// or other Section of the License conflicts with the conditions of the +// applicable GPL or LGPL license, you may retroactively and prospectively +// choose to deem waived or otherwise exclude such Section(s) of the License, +// but only in their entirety and only with respect to the Combined Software. +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_HPP +#define VULKAN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE +# include +# include +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#if !defined(VULKAN_HPP_ASSERT) +# include +# define VULKAN_HPP_ASSERT assert +#endif +static_assert( VK_HEADER_VERSION == 79 , "Wrong VK_HEADER_VERSION!" ); + +// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. +// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) +# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION ) +# define VULKAN_HPP_TYPESAFE_CONVERSION +# endif +#endif + +#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS) +# if defined(__clang__) +# if __has_feature(cxx_unrestricted_unions) +# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS +# endif +# elif defined(__GNUC__) +# define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) +# if 40600 <= GCC_VERSION +# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS +# endif +# elif defined(_MSC_VER) +# if 1900 <= _MSC_VER +# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS +# endif +# endif +#endif + +#if !defined(VULKAN_HPP_INLINE) +# if defined(__clang___) +# if __has_attribute(always_inline) +# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__ +# else +# define VULKAN_HPP_INLINE inline +# endif +# elif defined(__GNUC__) +# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__ +# elif defined(_MSC_VER) +# define VULKAN_HPP_INLINE __forceinline +# else +# define VULKAN_HPP_INLINE inline +# endif +#endif + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) +# define VULKAN_HPP_TYPESAFE_EXPLICIT +#else +# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit +#endif + +#if defined(_MSC_VER) && (_MSC_VER <= 1800) +# define VULKAN_HPP_CONSTEXPR +#else +# define VULKAN_HPP_CONSTEXPR constexpr +#endif + + +#if !defined(VULKAN_HPP_NAMESPACE) +#define VULKAN_HPP_NAMESPACE vk +#endif + +#define VULKAN_HPP_STRINGIFY2(text) #text +#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text) +#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE) + +namespace VULKAN_HPP_NAMESPACE +{ + + template struct FlagTraits + { + enum { allFlags = 0 }; + }; + + template + class Flags + { + public: + VULKAN_HPP_CONSTEXPR Flags() + : m_mask(0) + { + } + + Flags(BitType bit) + : m_mask(static_cast(bit)) + { + } + + Flags(Flags const& rhs) + : m_mask(rhs.m_mask) + { + } + + explicit Flags(MaskType flags) + : m_mask(flags) + { + } + + Flags & operator=(Flags const& rhs) + { + m_mask = rhs.m_mask; + return *this; + } + + Flags & operator|=(Flags const& rhs) + { + m_mask |= rhs.m_mask; + return *this; + } + + Flags & operator&=(Flags const& rhs) + { + m_mask &= rhs.m_mask; + return *this; + } + + Flags & operator^=(Flags const& rhs) + { + m_mask ^= rhs.m_mask; + return *this; + } + + Flags operator|(Flags const& rhs) const + { + Flags result(*this); + result |= rhs; + return result; + } + + Flags operator&(Flags const& rhs) const + { + Flags result(*this); + result &= rhs; + return result; + } + + Flags operator^(Flags const& rhs) const + { + Flags result(*this); + result ^= rhs; + return result; + } + + bool operator!() const + { + return !m_mask; + } + + Flags operator~() const + { + Flags result(*this); + result.m_mask ^= FlagTraits::allFlags; + return result; + } + + bool operator==(Flags const& rhs) const + { + return m_mask == rhs.m_mask; + } + + bool operator!=(Flags const& rhs) const + { + return m_mask != rhs.m_mask; + } + + explicit operator bool() const + { + return !!m_mask; + } + + explicit operator MaskType() const + { + return m_mask; + } + + private: + MaskType m_mask; + }; + + template + Flags operator|(BitType bit, Flags const& flags) + { + return flags | bit; + } + + template + Flags operator&(BitType bit, Flags const& flags) + { + return flags & bit; + } + + template + Flags operator^(BitType bit, Flags const& flags) + { + return flags ^ bit; + } + + + template + class Optional + { + public: + Optional(RefType & reference) { m_ptr = &reference; } + Optional(RefType * ptr) { m_ptr = ptr; } + Optional(std::nullptr_t) { m_ptr = nullptr; } + + operator RefType*() const { return m_ptr; } + RefType const* operator->() const { return m_ptr; } + explicit operator bool() const { return !!m_ptr; } + + private: + RefType *m_ptr; + }; + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + class ArrayProxy + { + public: + VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) + : m_count(0) + , m_ptr(nullptr) + {} + + ArrayProxy(T & ptr) + : m_count(1) + , m_ptr(&ptr) + {} + + ArrayProxy(uint32_t count, T * ptr) + : m_count(count) + , m_ptr(ptr) + {} + + template + ArrayProxy(std::array::type, N> & data) + : m_count(N) + , m_ptr(data.data()) + {} + + template + ArrayProxy(std::array::type, N> const& data) + : m_count(N) + , m_ptr(data.data()) + {} + + template ::type>> + ArrayProxy(std::vector::type, Allocator> & data) + : m_count(static_cast(data.size())) + , m_ptr(data.data()) + {} + + template ::type>> + ArrayProxy(std::vector::type, Allocator> const& data) + : m_count(static_cast(data.size())) + , m_ptr(data.data()) + {} + + ArrayProxy(std::initializer_list const& data) + : m_count(static_cast(data.end() - data.begin())) + , m_ptr(data.begin()) + {} + + const T * begin() const + { + return m_ptr; + } + + const T * end() const + { + return m_ptr + m_count; + } + + const T & front() const + { + VULKAN_HPP_ASSERT(m_count && m_ptr); + return *m_ptr; + } + + const T & back() const + { + VULKAN_HPP_ASSERT(m_count && m_ptr); + return *(m_ptr + m_count - 1); + } + + bool empty() const + { + return (m_count == 0); + } + + uint32_t size() const + { + return m_count; + } + + T * data() const + { + return m_ptr; + } + + private: + uint32_t m_count; + T * m_ptr; + }; +#endif + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + + template class UniqueHandleTraits; + + template + class UniqueHandle : public UniqueHandleTraits::deleter + { + private: + using Deleter = typename UniqueHandleTraits::deleter; + public: + explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() ) + : Deleter( deleter) + , m_value( value ) + {} + + UniqueHandle( UniqueHandle const& ) = delete; + + UniqueHandle( UniqueHandle && other ) + : Deleter( std::move( static_cast( other ) ) ) + , m_value( other.release() ) + {} + + ~UniqueHandle() + { + if ( m_value ) this->destroy( m_value ); + } + + UniqueHandle & operator=( UniqueHandle const& ) = delete; + + UniqueHandle & operator=( UniqueHandle && other ) + { + reset( other.release() ); + *static_cast(this) = std::move( static_cast(other) ); + return *this; + } + + explicit operator bool() const + { + return m_value.operator bool(); + } + + Type const* operator->() const + { + return &m_value; + } + + Type * operator->() + { + return &m_value; + } + + Type const& operator*() const + { + return m_value; + } + + Type & operator*() + { + return m_value; + } + + const Type & get() const + { + return m_value; + } + + Type & get() + { + return m_value; + } + + void reset( Type const& value = Type() ) + { + if ( m_value != value ) + { + if ( m_value ) this->destroy( m_value ); + m_value = value; + } + } + + Type release() + { + Type value = m_value; + m_value = nullptr; + return value; + } + + void swap( UniqueHandle & rhs ) + { + std::swap(m_value, rhs.m_value); + std::swap(static_cast(*this), static_cast(rhs)); + } + + private: + Type m_value; + }; + + template + VULKAN_HPP_INLINE void swap( UniqueHandle & lhs, UniqueHandle & rhs ) + { + lhs.swap( rhs ); + } +#endif + + + template struct isStructureChainValid { enum { value = false }; }; + + template + class StructureChainElement + { + public: + explicit operator Element&() { return value; } + explicit operator const Element&() const { return value; } + private: + Element value; + }; + + template + class StructureChain : private StructureChainElement... + { + public: + StructureChain() + { + link(); + } + + StructureChain(StructureChain const &rhs) + { + linkAndCopy(rhs); + } + + StructureChain(StructureElements const &... elems) + { + linkAndCopyElements(elems...); + } + + StructureChain& operator=(StructureChain const &rhs) + { + linkAndCopy(rhs); + return *this; + } + + template ClassType& get() { return static_cast(*this);} + + private: + template + void link() + { + } + + template + void link() + { + static_assert(isStructureChainValid::value, "The structure chain is not valid!"); + X& x = static_cast(*this); + Y& y = static_cast(*this); + x.pNext = &y; + link(); + } + + template + void linkAndCopy(StructureChain const &rhs) + { + static_cast(*this) = static_cast(rhs); + } + + template + void linkAndCopy(StructureChain const &rhs) + { + static_assert(isStructureChainValid::value, "The structure chain is not valid!"); + X& x = static_cast(*this); + Y& y = static_cast(*this); + x = static_cast(rhs); + x.pNext = &y; + linkAndCopy(rhs); + } + + template + void linkAndCopyElements(X const &xelem) + { + static_cast(*this) = xelem; + } + + template + void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem) + { + static_assert(isStructureChainValid::value, "The structure chain is not valid!"); + X& x = static_cast(*this); + Y& y = static_cast(*this); + x = xelem; + x.pNext = &y; + linkAndCopyElements(yelem, zelem...); + } + }; + + enum class Result + { + eSuccess = VK_SUCCESS, + eNotReady = VK_NOT_READY, + eTimeout = VK_TIMEOUT, + eEventSet = VK_EVENT_SET, + eEventReset = VK_EVENT_RESET, + eIncomplete = VK_INCOMPLETE, + eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY, + eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY, + eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED, + eErrorDeviceLost = VK_ERROR_DEVICE_LOST, + eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED, + eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT, + eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT, + eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT, + eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER, + eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS, + eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED, + eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL, + eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY, + eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY, + eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE, + eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR, + eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, + eSuboptimalKHR = VK_SUBOPTIMAL_KHR, + eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR, + eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, + eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, + eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, + eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT, + eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT + }; + + VULKAN_HPP_INLINE std::string to_string(Result value) + { + switch (value) + { + case Result::eSuccess: return "Success"; + case Result::eNotReady: return "NotReady"; + case Result::eTimeout: return "Timeout"; + case Result::eEventSet: return "EventSet"; + case Result::eEventReset: return "EventReset"; + case Result::eIncomplete: return "Incomplete"; + case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory"; + case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory"; + case Result::eErrorInitializationFailed: return "ErrorInitializationFailed"; + case Result::eErrorDeviceLost: return "ErrorDeviceLost"; + case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed"; + case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent"; + case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent"; + case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent"; + case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver"; + case Result::eErrorTooManyObjects: return "ErrorTooManyObjects"; + case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported"; + case Result::eErrorFragmentedPool: return "ErrorFragmentedPool"; + case Result::eErrorOutOfPoolMemory: return "ErrorOutOfPoolMemory"; + case Result::eErrorInvalidExternalHandle: return "ErrorInvalidExternalHandle"; + case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR"; + case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR"; + case Result::eSuboptimalKHR: return "SuboptimalKHR"; + case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR"; + case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR"; + case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT"; + case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV"; + case Result::eErrorFragmentationEXT: return "ErrorFragmentationEXT"; + case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT"; + default: return "invalid"; + } + } + +#ifndef VULKAN_HPP_NO_EXCEPTIONS +#if defined(_MSC_VER) && (_MSC_VER == 1800) +# define noexcept _NOEXCEPT +#endif + + class ErrorCategoryImpl : public std::error_category + { + public: + virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; } + virtual std::string message(int ev) const override { return to_string(static_cast(ev)); } + }; + +#if defined(_MSC_VER) && (_MSC_VER == 1800) +# undef noexcept +#endif + + VULKAN_HPP_INLINE const std::error_category& errorCategory() + { + static ErrorCategoryImpl instance; + return instance; + } + + VULKAN_HPP_INLINE std::error_code make_error_code(Result e) + { + return std::error_code(static_cast(e), errorCategory()); + } + + VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) + { + return std::error_condition(static_cast(e), errorCategory()); + } + +#if defined(_MSC_VER) && (_MSC_VER == 1800) +# define noexcept _NOEXCEPT +#endif + + class Error + { + public: + virtual ~Error() = default; + + virtual const char* what() const noexcept = 0; + }; + + class LogicError : public Error, public std::logic_error + { + public: + explicit LogicError( const std::string& what ) + : Error(), std::logic_error(what) {} + explicit LogicError( char const * what ) + : Error(), std::logic_error(what) {} + virtual ~LogicError() = default; + + virtual const char* what() const noexcept { return std::logic_error::what(); } + }; + + class SystemError : public Error, public std::system_error + { + public: + SystemError( std::error_code ec ) + : Error(), std::system_error(ec) {} + SystemError( std::error_code ec, std::string const& what ) + : Error(), std::system_error(ec, what) {} + SystemError( std::error_code ec, char const * what ) + : Error(), std::system_error(ec, what) {} + SystemError( int ev, std::error_category const& ecat ) + : Error(), std::system_error(ev, ecat) {} + SystemError( int ev, std::error_category const& ecat, std::string const& what) + : Error(), std::system_error(ev, ecat, what) {} + SystemError( int ev, std::error_category const& ecat, char const * what) + : Error(), std::system_error(ev, ecat, what) {} + virtual ~SystemError() = default; + + virtual const char* what() const noexcept { return std::system_error::what(); } + }; + +#if defined(_MSC_VER) && (_MSC_VER == 1800) +# undef noexcept +#endif + + class OutOfHostMemoryError : public SystemError + { + public: + OutOfHostMemoryError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} + OutOfHostMemoryError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} + }; + class OutOfDeviceMemoryError : public SystemError + { + public: + OutOfDeviceMemoryError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} + OutOfDeviceMemoryError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} + }; + class InitializationFailedError : public SystemError + { + public: + InitializationFailedError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} + InitializationFailedError( char const * message ) + : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} + }; + class DeviceLostError : public SystemError + { + public: + DeviceLostError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} + DeviceLostError( char const * message ) + : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} + }; + class MemoryMapFailedError : public SystemError + { + public: + MemoryMapFailedError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} + MemoryMapFailedError( char const * message ) + : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} + }; + class LayerNotPresentError : public SystemError + { + public: + LayerNotPresentError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} + LayerNotPresentError( char const * message ) + : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} + }; + class ExtensionNotPresentError : public SystemError + { + public: + ExtensionNotPresentError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} + ExtensionNotPresentError( char const * message ) + : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} + }; + class FeatureNotPresentError : public SystemError + { + public: + FeatureNotPresentError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} + FeatureNotPresentError( char const * message ) + : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} + }; + class IncompatibleDriverError : public SystemError + { + public: + IncompatibleDriverError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} + IncompatibleDriverError( char const * message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} + }; + class TooManyObjectsError : public SystemError + { + public: + TooManyObjectsError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} + TooManyObjectsError( char const * message ) + : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} + }; + class FormatNotSupportedError : public SystemError + { + public: + FormatNotSupportedError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} + FormatNotSupportedError( char const * message ) + : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} + }; + class FragmentedPoolError : public SystemError + { + public: + FragmentedPoolError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} + FragmentedPoolError( char const * message ) + : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} + }; + class OutOfPoolMemoryError : public SystemError + { + public: + OutOfPoolMemoryError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} + OutOfPoolMemoryError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} + }; + class InvalidExternalHandleError : public SystemError + { + public: + InvalidExternalHandleError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} + InvalidExternalHandleError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} + }; + class SurfaceLostKHRError : public SystemError + { + public: + SurfaceLostKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} + SurfaceLostKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} + }; + class NativeWindowInUseKHRError : public SystemError + { + public: + NativeWindowInUseKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} + NativeWindowInUseKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} + }; + class OutOfDateKHRError : public SystemError + { + public: + OutOfDateKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} + OutOfDateKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} + }; + class IncompatibleDisplayKHRError : public SystemError + { + public: + IncompatibleDisplayKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} + IncompatibleDisplayKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} + }; + class ValidationFailedEXTError : public SystemError + { + public: + ValidationFailedEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} + ValidationFailedEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} + }; + class InvalidShaderNVError : public SystemError + { + public: + InvalidShaderNVError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} + InvalidShaderNVError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} + }; + class FragmentationEXTError : public SystemError + { + public: + FragmentationEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {} + FragmentationEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {} + }; + class NotPermittedEXTError : public SystemError + { + public: + NotPermittedEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} + NotPermittedEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} + }; + + VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) + { + switch ( result ) + { + case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError ( message ); + case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError ( message ); + case Result::eErrorInitializationFailed: throw InitializationFailedError ( message ); + case Result::eErrorDeviceLost: throw DeviceLostError ( message ); + case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError ( message ); + case Result::eErrorLayerNotPresent: throw LayerNotPresentError ( message ); + case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError ( message ); + case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError ( message ); + case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError ( message ); + case Result::eErrorTooManyObjects: throw TooManyObjectsError ( message ); + case Result::eErrorFormatNotSupported: throw FormatNotSupportedError ( message ); + case Result::eErrorFragmentedPool: throw FragmentedPoolError ( message ); + case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError ( message ); + case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError ( message ); + case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError ( message ); + case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError ( message ); + case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError ( message ); + case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message ); + case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message ); + case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message ); + case Result::eErrorFragmentationEXT: throw FragmentationEXTError ( message ); + case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message ); + default: throw SystemError( make_error_code( result ) ); + } + } +#endif +} // namespace VULKAN_HPP_NAMESPACE + +namespace std +{ + template <> + struct is_error_code_enum : public true_type + {}; +} + +namespace VULKAN_HPP_NAMESPACE +{ + + template + struct ResultValue + { + ResultValue( Result r, T & v ) + : result( r ) + , value( v ) + {} + + ResultValue( Result r, T && v ) + : result( r ) + , value( std::move( v ) ) + {} + + Result result; + T value; + + operator std::tuple() { return std::tuple(result, value); } + }; + + template + struct ResultValueType + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + typedef ResultValue type; +#else + typedef T type; +#endif + }; + + template <> + struct ResultValueType + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + typedef Result type; +#else + typedef void type; +#endif + }; + + VULKAN_HPP_INLINE ResultValueType::type createResultValue( Result result, char const * message ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( result == Result::eSuccess ); + return result; +#else + if ( result != Result::eSuccess ) + { + throwResultException( result, message ); + } +#endif + } + + template + VULKAN_HPP_INLINE typename ResultValueType::type createResultValue( Result result, T & data, char const * message ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( result == Result::eSuccess ); + return ResultValue( result, data ); +#else + if ( result != Result::eSuccess ) + { + throwResultException( result, message ); + } + return std::move( data ); +#endif + } + + VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list successCodes ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); +#else + if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) + { + throwResultException( result, message ); + } +#endif + return result; + } + + template + VULKAN_HPP_INLINE ResultValue createResultValue( Result result, T & data, char const * message, std::initializer_list successCodes ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); +#else + if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) + { + throwResultException( result, message ); + } +#endif + return ResultValue( result, data ); + } + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits::deleter const& deleter ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( result == Result::eSuccess ); + return ResultValue>( result, UniqueHandle(data, deleter) ); +#else + if ( result != Result::eSuccess ) + { + throwResultException( result, message ); + } + return UniqueHandle(data, deleter); +#endif + } +#endif + + + struct AllocationCallbacks; + + template + class ObjectDestroy + { + public: + ObjectDestroy(OwnerType owner = OwnerType(), Optional allocator = nullptr) + : m_owner(owner) + , m_allocator(allocator) + {} + + OwnerType getOwner() const { return m_owner; } + Optional getAllocator() const { return m_allocator; } + + protected: + template + void destroy(T t) + { + m_owner.destroy(t, m_allocator); + } + + private: + OwnerType m_owner; + Optional m_allocator; + }; + + class NoParent; + + template <> + class ObjectDestroy + { + public: + ObjectDestroy( Optional allocator = nullptr ) + : m_allocator( allocator ) + {} + + Optional getAllocator() const { return m_allocator; } + + protected: + template + void destroy(T t) + { + t.destroy( m_allocator ); + } + + private: + Optional m_allocator; + }; + + template + class ObjectFree + { + public: + ObjectFree(OwnerType owner = OwnerType(), Optional allocator = nullptr) + : m_owner(owner) + , m_allocator(allocator) + {} + + OwnerType getOwner() const { return m_owner; } + Optional getAllocator() const { return m_allocator; } + + protected: + template + void destroy(T t) + { + m_owner.free(t, m_allocator); + } + + private: + OwnerType m_owner; + Optional m_allocator; + }; + + template + class PoolFree + { + public: + PoolFree(OwnerType owner = OwnerType(), PoolType pool = PoolType()) + : m_owner(owner) + , m_pool(pool) + {} + + OwnerType getOwner() const { return m_owner; } + PoolType getPool() const { return m_pool; } + + protected: + template + void destroy(T t) + { + m_owner.free(m_pool, t); + } + + private: + OwnerType m_owner; + PoolType m_pool; + }; + +class DispatchLoaderStatic +{ +public: + VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex ) const + { + return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex); + } + VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex ) const + { + return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex); + } +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const + { + return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display); + } +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const + { + return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers); + } + VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets ) const + { + return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets); + } + VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory ) const + { + return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory); + } + VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo ) const + { + return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo); + } + VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const + { + return ::vkBindBufferMemory( device, buffer, memory, memoryOffset); + } + VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const + { + return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos); + } + VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const + { + return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos); + } + VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const + { + return ::vkBindImageMemory( device, image, memory, memoryOffset); + } + VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const + { + return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos); + } + VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const + { + return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos); + } + void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const + { + return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo); + } + void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const + { + return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags); + } + void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents ) const + { + return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents); + } + void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const + { + return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + } + void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const + { + return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType); + } + void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const + { + return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline); + } + void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets ) const + { + return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + } + void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter ) const + { + return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + } + void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects ) const + { + return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + } + void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const + { + return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + } + void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const + { + return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + } + void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions ) const + { + return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + } + void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const + { + return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions ) const + { + return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const + { + return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + } + void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags ) const + { + return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + } + void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const + { + return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo); + } + void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const + { + return ::vkCmdDebugMarkerEndEXT( commandBuffer); + } + void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const + { + return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo); + } + void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const + { + return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const + { + return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const + { + return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const + { + return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset); + } + void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const + { + return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + } + void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const + { + return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + } + void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const + { + return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const + { + return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const + { + return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const + { + return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const + { + return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const + { + return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const + { + return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer); + } + void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const + { + return ::vkCmdEndQuery( commandBuffer, queryPool, query); + } + void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const + { + return ::vkCmdEndRenderPass( commandBuffer); + } + void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const + { + return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers); + } + void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const + { + return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data); + } + void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const + { + return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo); + } + void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const + { + return ::vkCmdNextSubpass( commandBuffer, contents); + } + void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const + { + return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + } + void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const + { + return ::vkCmdProcessCommandsNVX( commandBuffer, pProcessCommandsInfo); + } + void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const + { + return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues); + } + void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites ) const + { + return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + } + void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData ) const + { + return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } + void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const + { + return ::vkCmdReserveSpaceForCommandsNVX( commandBuffer, pReserveSpaceInfo); + } + void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const + { + return ::vkCmdResetEvent( commandBuffer, event, stageMask); + } + void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const + { + return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount); + } + void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions ) const + { + return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const + { + return ::vkCmdSetBlendConstants( commandBuffer, blendConstants); + } + void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const + { + return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + } + void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const + { + return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds); + } + void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const + { + return ::vkCmdSetDeviceMask( commandBuffer, deviceMask); + } + void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const + { + return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask); + } + void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles ) const + { + return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); + } + void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const + { + return ::vkCmdSetEvent( commandBuffer, event, stageMask); + } + void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const + { + return ::vkCmdSetLineWidth( commandBuffer, lineWidth); + } + void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo ) const + { + return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo); + } + void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors ) const + { + return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors); + } + void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const + { + return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask); + } + void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const + { + return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference); + } + void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const + { + return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask); + } + void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports ) const + { + return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports); + } + void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings ) const + { + return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings); + } + void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData ) const + { + return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData); + } + void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const + { + return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + } + void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const + { + return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); + } + void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) const + { + return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query); + } +#ifdef VK_USE_PLATFORM_ANDROID_KHR + VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer ) const + { + return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer); + } + VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView ) const + { + return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView); + } + VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool ) const + { + return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool); + } + VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const + { + return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback ) const + { + return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback); + } + VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger ) const + { + return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger); + } + VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool ) const + { + return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool); + } + VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout ) const + { + return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout); + } + VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const + { + return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + } + VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const + { + return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + } + VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice ) const + { + return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice); + } + VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode ) const + { + return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode); + } + VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); + } + VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent ) const + { + return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent); + } + VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const + { + return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence); + } + VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer ) const + { + return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer); + } + VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const + { + return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } +#ifdef VK_USE_PLATFORM_IOS_MVK + VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage ) const + { + return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage); + } + VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView ) const + { + return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView); + } + VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const + { + return ::vkCreateIndirectCommandsLayoutNVX( device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + } + VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance ) const + { + return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance); + } +#ifdef VK_USE_PLATFORM_MACOS_MVK + VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ +#ifdef VK_USE_PLATFORM_MIR_KHR + VkResult vkCreateMirSurfaceKHR( VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateMirSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable ) const + { + return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable); + } + VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache ) const + { + return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache); + } + VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout ) const + { + return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout); + } + VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool ) const + { + return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool); + } + VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const + { + return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass); + } + VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler ) const + { + return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler); + } + VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const + { + return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion); + } + VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const + { + return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion); + } + VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore ) const + { + return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore); + } + VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule ) const + { + return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule); + } + VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains ) const + { + return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + } + VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain ) const + { + return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain); + } + VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache ) const + { + return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache); + } +#ifdef VK_USE_PLATFORM_VI_NN + VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_VI_NN*/ +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo ) const + { + return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo); + } + VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo ) const + { + return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo); + } + void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const + { + return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); + } + void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyBuffer( device, buffer, pAllocator); + } + void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyBufferView( device, bufferView, pAllocator); + } + void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyCommandPool( device, commandPool, pAllocator); + } + void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator); + } + void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator); + } + void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator); + } + void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator); + } + void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator); + } + void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator); + } + void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyDevice( device, pAllocator); + } + void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyEvent( device, event, pAllocator); + } + void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyFence( device, fence, pAllocator); + } + void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyFramebuffer( device, framebuffer, pAllocator); + } + void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyImage( device, image, pAllocator); + } + void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyImageView( device, imageView, pAllocator); + } + void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyIndirectCommandsLayoutNVX( device, indirectCommandsLayout, pAllocator); + } + void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyInstance( instance, pAllocator); + } + void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyObjectTableNVX( device, objectTable, pAllocator); + } + void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyPipeline( device, pipeline, pAllocator); + } + void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator); + } + void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator); + } + void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyQueryPool( device, queryPool, pAllocator); + } + void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyRenderPass( device, renderPass, pAllocator); + } + void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroySampler( device, sampler, pAllocator); + } + void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator); + } + void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator); + } + void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroySemaphore( device, semaphore, pAllocator); + } + void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyShaderModule( device, shaderModule, pAllocator); + } + void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroySurfaceKHR( instance, surface, pAllocator); + } + void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroySwapchainKHR( device, swapchain, pAllocator); + } + void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator); + } + VkResult vkDeviceWaitIdle( VkDevice device ) const + { + return ::vkDeviceWaitIdle( device); + } + VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo ) const + { + return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo); + } + VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const + { + return ::vkEndCommandBuffer( commandBuffer); + } + VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const + { + return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties); + } + VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const + { + return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties); + } + VkResult vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const + { + return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties); + } + VkResult vkEnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const + { + return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties); + } + VkResult vkEnumerateInstanceVersion( uint32_t* pApiVersion ) const + { + return ::vkEnumerateInstanceVersion( pApiVersion); + } + VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const + { + return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + } + VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const + { + return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + } + VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices ) const + { + return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices); + } + VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const + { + return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges); + } + void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const + { + return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers); + } + VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets ) const + { + return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets); + } + void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkFreeMemory( device, memory, pAllocator); + } +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const + { + return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties); + } +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements ) const + { + return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements); + } + void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const + { + return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements); + } + void vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const + { + return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements); + } + void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const + { + return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport); + } + void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const + { + return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport); + } + void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const + { + return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + } + void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const + { + return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + } + VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities ) const + { + return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities); + } + VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes ) const + { + return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes); + } + void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes ) const + { + return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes); + } + PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char* pName ) const + { + return ::vkGetDeviceProcAddr( device, pName); + } + void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue ) const + { + return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue); + } + void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue ) const + { + return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue); + } + VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties ) const + { + return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties); + } + VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties ) const + { + return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties); + } + VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities ) const + { + return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities); + } + VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities ) const + { + return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities); + } + VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays ) const + { + return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays); + } + VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const + { + return ::vkGetEventStatus( device, event); + } + VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const + { + return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd); + } + VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const + { + return ::vkGetFenceStatus( device, fence); + } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const + { + return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements ) const + { + return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements); + } + void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const + { + return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements); + } + void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const + { + return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements ) const + { + return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const + { + return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const + { + return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout ) const + { + return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout); + } + PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName ) const + { + return ::vkGetInstanceProcAddr( instance, pName); + } +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer ) const + { + return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer); + } +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const + { + return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd); + } + VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties ) const + { + return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties); + } + VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const + { + return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties); + } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const + { + return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_NV + VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const + { + return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle); + } +#endif /*VK_USE_PLATFORM_WIN32_NV*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const + { + return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings ) const + { + return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings); + } + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties ) const + { + return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties ) const + { + return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties ) const + { + return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties ) const + { + return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties); + } + void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const + { + return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + } + void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const + { + return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + } + void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const + { + return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + } + void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const + { + return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + } + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const + { + return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); + } + void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const + { + return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + } + void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const + { + return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + } + void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures ) const + { + return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const + { + return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const + { + return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties ) const + { + return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties); + } + void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const + { + return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties); + } + void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const + { + return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties); + } + void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits ) const + { + return ::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( physicalDevice, pFeatures, pLimits); + } + VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties ) const + { + return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const + { + return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const + { + return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties ) const + { + return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties); + } + void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const + { + return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties); + } + void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const + { + return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties); + } +#ifdef VK_USE_PLATFORM_MIR_KHR + VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection ) const + { + return ::vkGetPhysicalDeviceMirPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection); + } +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties ) const + { + return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties); + } + VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects ) const + { + return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects); + } + void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties ) const + { + return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties); + } + void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const + { + return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties); + } + void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const + { + return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties ) const + { + return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const + { + return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const + { + return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties ) const + { + return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const + { + return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const + { + return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities ) const + { + return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities ) const + { + return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities ) const + { + return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities); + } + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats ) const + { + return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); + } + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats ) const + { + return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); + } + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const + { + return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes); + } + VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported ) const + { + return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported); + } +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display ) const + { + return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display); + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const + { + return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const + { + return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id); + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const + { + return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID); + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData ) const + { + return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData); + } + VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const + { + return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + } +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ) const + { + return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay); + } +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const + { + return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties); + } + void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity ) const + { + return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity); + } + VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const + { + return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd); + } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const + { + return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const + { + return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + } + VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const + { + return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue); + } + VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages ) const + { + return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages); + } + VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const + { + return ::vkGetSwapchainStatusKHR( device, swapchain); + } + VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const + { + return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData); + } + VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo ) const + { + return ::vkImportFenceFdKHR( device, pImportFenceFdInfo); + } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const + { + return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const + { + return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo); + } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const + { + return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const + { + return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges); + } + VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData ) const + { + return ::vkMapMemory( device, memory, offset, size, flags, ppData); + } + VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches ) const + { + return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches); + } + VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches ) const + { + return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches); + } + void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const + { + return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo); + } + VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence ) const + { + return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence); + } + void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const + { + return ::vkQueueEndDebugUtilsLabelEXT( queue); + } + void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const + { + return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo); + } + VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo ) const + { + return ::vkQueuePresentKHR( queue, pPresentInfo); + } + VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence ) const + { + return ::vkQueueSubmit( queue, submitCount, pSubmits, fence); + } + VkResult vkQueueWaitIdle( VkQueue queue ) const + { + return ::vkQueueWaitIdle( queue); + } + VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const + { + return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence); + } + VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const + { + return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence); + } + VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const + { + return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); + } + VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const + { + return ::vkReleaseDisplayEXT( physicalDevice, display); + } + VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const + { + return ::vkResetCommandBuffer( commandBuffer, flags); + } + VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const + { + return ::vkResetCommandPool( device, commandPool, flags); + } + VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const + { + return ::vkResetDescriptorPool( device, descriptorPool, flags); + } + VkResult vkResetEvent( VkDevice device, VkEvent event ) const + { + return ::vkResetEvent( device, event); + } + VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences ) const + { + return ::vkResetFences( device, fenceCount, pFences); + } + VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo ) const + { + return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo); + } + VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo ) const + { + return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo); + } + VkResult vkSetEvent( VkDevice device, VkEvent event ) const + { + return ::vkSetEvent( device, event); + } + void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata ) const + { + return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata); + } + void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData ) const + { + return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData); + } + void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const + { + return ::vkTrimCommandPool( device, commandPool, flags); + } + void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const + { + return ::vkTrimCommandPoolKHR( device, commandPool, flags); + } + void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const + { + return ::vkUnmapMemory( device, memory); + } + VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const + { + return ::vkUnregisterObjectsNVX( device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); + } + void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const + { + return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData); + } + void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const + { + return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData); + } + void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies ) const + { + return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + } + VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout ) const + { + return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout); + } +}; + using SampleMask = uint32_t; + + using Bool32 = uint32_t; + + using DeviceSize = uint64_t; + + enum class FramebufferCreateFlagBits + { + }; + + using FramebufferCreateFlags = Flags; + + enum class QueryPoolCreateFlagBits + { + }; + + using QueryPoolCreateFlags = Flags; + + enum class RenderPassCreateFlagBits + { + }; + + using RenderPassCreateFlags = Flags; + + enum class SamplerCreateFlagBits + { + }; + + using SamplerCreateFlags = Flags; + + enum class PipelineLayoutCreateFlagBits + { + }; + + using PipelineLayoutCreateFlags = Flags; + + enum class PipelineCacheCreateFlagBits + { + }; + + using PipelineCacheCreateFlags = Flags; + + enum class PipelineDepthStencilStateCreateFlagBits + { + }; + + using PipelineDepthStencilStateCreateFlags = Flags; + + enum class PipelineDynamicStateCreateFlagBits + { + }; + + using PipelineDynamicStateCreateFlags = Flags; + + enum class PipelineColorBlendStateCreateFlagBits + { + }; + + using PipelineColorBlendStateCreateFlags = Flags; + + enum class PipelineMultisampleStateCreateFlagBits + { + }; + + using PipelineMultisampleStateCreateFlags = Flags; + + enum class PipelineRasterizationStateCreateFlagBits + { + }; + + using PipelineRasterizationStateCreateFlags = Flags; + + enum class PipelineViewportStateCreateFlagBits + { + }; + + using PipelineViewportStateCreateFlags = Flags; + + enum class PipelineTessellationStateCreateFlagBits + { + }; + + using PipelineTessellationStateCreateFlags = Flags; + + enum class PipelineInputAssemblyStateCreateFlagBits + { + }; + + using PipelineInputAssemblyStateCreateFlags = Flags; + + enum class PipelineVertexInputStateCreateFlagBits + { + }; + + using PipelineVertexInputStateCreateFlags = Flags; + + enum class PipelineShaderStageCreateFlagBits + { + }; + + using PipelineShaderStageCreateFlags = Flags; + + enum class BufferViewCreateFlagBits + { + }; + + using BufferViewCreateFlags = Flags; + + enum class InstanceCreateFlagBits + { + }; + + using InstanceCreateFlags = Flags; + + enum class DeviceCreateFlagBits + { + }; + + using DeviceCreateFlags = Flags; + + enum class ImageViewCreateFlagBits + { + }; + + using ImageViewCreateFlags = Flags; + + enum class SemaphoreCreateFlagBits + { + }; + + using SemaphoreCreateFlags = Flags; + + enum class ShaderModuleCreateFlagBits + { + }; + + using ShaderModuleCreateFlags = Flags; + + enum class EventCreateFlagBits + { + }; + + using EventCreateFlags = Flags; + + enum class MemoryMapFlagBits + { + }; + + using MemoryMapFlags = Flags; + + enum class DescriptorPoolResetFlagBits + { + }; + + using DescriptorPoolResetFlags = Flags; + + enum class DescriptorUpdateTemplateCreateFlagBits + { + }; + + using DescriptorUpdateTemplateCreateFlags = Flags; + + using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; + + enum class DisplayModeCreateFlagBitsKHR + { + }; + + using DisplayModeCreateFlagsKHR = Flags; + + enum class DisplaySurfaceCreateFlagBitsKHR + { + }; + + using DisplaySurfaceCreateFlagsKHR = Flags; + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + enum class AndroidSurfaceCreateFlagBitsKHR + { + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + using AndroidSurfaceCreateFlagsKHR = Flags; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + enum class MirSurfaceCreateFlagBitsKHR + { + }; +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + using MirSurfaceCreateFlagsKHR = Flags; +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + +#ifdef VK_USE_PLATFORM_VI_NN + enum class ViSurfaceCreateFlagBitsNN + { + }; +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_VI_NN + using ViSurfaceCreateFlagsNN = Flags; +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + enum class WaylandSurfaceCreateFlagBitsKHR + { + }; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + using WaylandSurfaceCreateFlagsKHR = Flags; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + enum class Win32SurfaceCreateFlagBitsKHR + { + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + using Win32SurfaceCreateFlagsKHR = Flags; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + enum class XlibSurfaceCreateFlagBitsKHR + { + }; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + using XlibSurfaceCreateFlagsKHR = Flags; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + enum class XcbSurfaceCreateFlagBitsKHR + { + }; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + using XcbSurfaceCreateFlagsKHR = Flags; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#ifdef VK_USE_PLATFORM_IOS_MVK + enum class IOSSurfaceCreateFlagBitsMVK + { + }; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#ifdef VK_USE_PLATFORM_IOS_MVK + using IOSSurfaceCreateFlagsMVK = Flags; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + enum class MacOSSurfaceCreateFlagBitsMVK + { + }; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + using MacOSSurfaceCreateFlagsMVK = Flags; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + enum class CommandPoolTrimFlagBits + { + }; + + using CommandPoolTrimFlags = Flags; + + using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; + + enum class PipelineViewportSwizzleStateCreateFlagBitsNV + { + }; + + using PipelineViewportSwizzleStateCreateFlagsNV = Flags; + + enum class PipelineDiscardRectangleStateCreateFlagBitsEXT + { + }; + + using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; + + enum class PipelineCoverageToColorStateCreateFlagBitsNV + { + }; + + using PipelineCoverageToColorStateCreateFlagsNV = Flags; + + enum class PipelineCoverageModulationStateCreateFlagBitsNV + { + }; + + using PipelineCoverageModulationStateCreateFlagsNV = Flags; + + enum class ValidationCacheCreateFlagBitsEXT + { + }; + + using ValidationCacheCreateFlagsEXT = Flags; + + enum class DebugUtilsMessengerCreateFlagBitsEXT + { + }; + + using DebugUtilsMessengerCreateFlagsEXT = Flags; + + enum class DebugUtilsMessengerCallbackDataFlagBitsEXT + { + }; + + using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; + + enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT + { + }; + + using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; + + class DeviceMemory + { + public: + VULKAN_HPP_CONSTEXPR DeviceMemory() + : m_deviceMemory(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) + : m_deviceMemory(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) + : m_deviceMemory( deviceMemory ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DeviceMemory & operator=(VkDeviceMemory deviceMemory) + { + m_deviceMemory = deviceMemory; + return *this; + } +#endif + + DeviceMemory & operator=( std::nullptr_t ) + { + m_deviceMemory = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DeviceMemory const & rhs ) const + { + return m_deviceMemory == rhs.m_deviceMemory; + } + + bool operator!=(DeviceMemory const & rhs ) const + { + return m_deviceMemory != rhs.m_deviceMemory; + } + + bool operator<(DeviceMemory const & rhs ) const + { + return m_deviceMemory < rhs.m_deviceMemory; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const + { + return m_deviceMemory; + } + + explicit operator bool() const + { + return m_deviceMemory != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_deviceMemory == VK_NULL_HANDLE; + } + + private: + VkDeviceMemory m_deviceMemory; + }; + + static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); + + class CommandPool + { + public: + VULKAN_HPP_CONSTEXPR CommandPool() + : m_commandPool(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) + : m_commandPool(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) + : m_commandPool( commandPool ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + CommandPool & operator=(VkCommandPool commandPool) + { + m_commandPool = commandPool; + return *this; + } +#endif + + CommandPool & operator=( std::nullptr_t ) + { + m_commandPool = VK_NULL_HANDLE; + return *this; + } + + bool operator==( CommandPool const & rhs ) const + { + return m_commandPool == rhs.m_commandPool; + } + + bool operator!=(CommandPool const & rhs ) const + { + return m_commandPool != rhs.m_commandPool; + } + + bool operator<(CommandPool const & rhs ) const + { + return m_commandPool < rhs.m_commandPool; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const + { + return m_commandPool; + } + + explicit operator bool() const + { + return m_commandPool != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_commandPool == VK_NULL_HANDLE; + } + + private: + VkCommandPool m_commandPool; + }; + + static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); + + class Buffer + { + public: + VULKAN_HPP_CONSTEXPR Buffer() + : m_buffer(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) + : m_buffer(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) + : m_buffer( buffer ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Buffer & operator=(VkBuffer buffer) + { + m_buffer = buffer; + return *this; + } +#endif + + Buffer & operator=( std::nullptr_t ) + { + m_buffer = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Buffer const & rhs ) const + { + return m_buffer == rhs.m_buffer; + } + + bool operator!=(Buffer const & rhs ) const + { + return m_buffer != rhs.m_buffer; + } + + bool operator<(Buffer const & rhs ) const + { + return m_buffer < rhs.m_buffer; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const + { + return m_buffer; + } + + explicit operator bool() const + { + return m_buffer != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_buffer == VK_NULL_HANDLE; + } + + private: + VkBuffer m_buffer; + }; + + static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); + + class BufferView + { + public: + VULKAN_HPP_CONSTEXPR BufferView() + : m_bufferView(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) + : m_bufferView(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) + : m_bufferView( bufferView ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + BufferView & operator=(VkBufferView bufferView) + { + m_bufferView = bufferView; + return *this; + } +#endif + + BufferView & operator=( std::nullptr_t ) + { + m_bufferView = VK_NULL_HANDLE; + return *this; + } + + bool operator==( BufferView const & rhs ) const + { + return m_bufferView == rhs.m_bufferView; + } + + bool operator!=(BufferView const & rhs ) const + { + return m_bufferView != rhs.m_bufferView; + } + + bool operator<(BufferView const & rhs ) const + { + return m_bufferView < rhs.m_bufferView; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const + { + return m_bufferView; + } + + explicit operator bool() const + { + return m_bufferView != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_bufferView == VK_NULL_HANDLE; + } + + private: + VkBufferView m_bufferView; + }; + + static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); + + class Image + { + public: + VULKAN_HPP_CONSTEXPR Image() + : m_image(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) + : m_image(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) + : m_image( image ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Image & operator=(VkImage image) + { + m_image = image; + return *this; + } +#endif + + Image & operator=( std::nullptr_t ) + { + m_image = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Image const & rhs ) const + { + return m_image == rhs.m_image; + } + + bool operator!=(Image const & rhs ) const + { + return m_image != rhs.m_image; + } + + bool operator<(Image const & rhs ) const + { + return m_image < rhs.m_image; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const + { + return m_image; + } + + explicit operator bool() const + { + return m_image != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_image == VK_NULL_HANDLE; + } + + private: + VkImage m_image; + }; + + static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); + + class ImageView + { + public: + VULKAN_HPP_CONSTEXPR ImageView() + : m_imageView(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) + : m_imageView(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) + : m_imageView( imageView ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + ImageView & operator=(VkImageView imageView) + { + m_imageView = imageView; + return *this; + } +#endif + + ImageView & operator=( std::nullptr_t ) + { + m_imageView = VK_NULL_HANDLE; + return *this; + } + + bool operator==( ImageView const & rhs ) const + { + return m_imageView == rhs.m_imageView; + } + + bool operator!=(ImageView const & rhs ) const + { + return m_imageView != rhs.m_imageView; + } + + bool operator<(ImageView const & rhs ) const + { + return m_imageView < rhs.m_imageView; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const + { + return m_imageView; + } + + explicit operator bool() const + { + return m_imageView != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_imageView == VK_NULL_HANDLE; + } + + private: + VkImageView m_imageView; + }; + + static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); + + class ShaderModule + { + public: + VULKAN_HPP_CONSTEXPR ShaderModule() + : m_shaderModule(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) + : m_shaderModule(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) + : m_shaderModule( shaderModule ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + ShaderModule & operator=(VkShaderModule shaderModule) + { + m_shaderModule = shaderModule; + return *this; + } +#endif + + ShaderModule & operator=( std::nullptr_t ) + { + m_shaderModule = VK_NULL_HANDLE; + return *this; + } + + bool operator==( ShaderModule const & rhs ) const + { + return m_shaderModule == rhs.m_shaderModule; + } + + bool operator!=(ShaderModule const & rhs ) const + { + return m_shaderModule != rhs.m_shaderModule; + } + + bool operator<(ShaderModule const & rhs ) const + { + return m_shaderModule < rhs.m_shaderModule; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const + { + return m_shaderModule; + } + + explicit operator bool() const + { + return m_shaderModule != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_shaderModule == VK_NULL_HANDLE; + } + + private: + VkShaderModule m_shaderModule; + }; + + static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); + + class Pipeline + { + public: + VULKAN_HPP_CONSTEXPR Pipeline() + : m_pipeline(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) + : m_pipeline(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) + : m_pipeline( pipeline ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Pipeline & operator=(VkPipeline pipeline) + { + m_pipeline = pipeline; + return *this; + } +#endif + + Pipeline & operator=( std::nullptr_t ) + { + m_pipeline = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Pipeline const & rhs ) const + { + return m_pipeline == rhs.m_pipeline; + } + + bool operator!=(Pipeline const & rhs ) const + { + return m_pipeline != rhs.m_pipeline; + } + + bool operator<(Pipeline const & rhs ) const + { + return m_pipeline < rhs.m_pipeline; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const + { + return m_pipeline; + } + + explicit operator bool() const + { + return m_pipeline != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_pipeline == VK_NULL_HANDLE; + } + + private: + VkPipeline m_pipeline; + }; + + static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); + + class PipelineLayout + { + public: + VULKAN_HPP_CONSTEXPR PipelineLayout() + : m_pipelineLayout(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) + : m_pipelineLayout(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) + : m_pipelineLayout( pipelineLayout ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + PipelineLayout & operator=(VkPipelineLayout pipelineLayout) + { + m_pipelineLayout = pipelineLayout; + return *this; + } +#endif + + PipelineLayout & operator=( std::nullptr_t ) + { + m_pipelineLayout = VK_NULL_HANDLE; + return *this; + } + + bool operator==( PipelineLayout const & rhs ) const + { + return m_pipelineLayout == rhs.m_pipelineLayout; + } + + bool operator!=(PipelineLayout const & rhs ) const + { + return m_pipelineLayout != rhs.m_pipelineLayout; + } + + bool operator<(PipelineLayout const & rhs ) const + { + return m_pipelineLayout < rhs.m_pipelineLayout; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const + { + return m_pipelineLayout; + } + + explicit operator bool() const + { + return m_pipelineLayout != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_pipelineLayout == VK_NULL_HANDLE; + } + + private: + VkPipelineLayout m_pipelineLayout; + }; + + static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); + + class Sampler + { + public: + VULKAN_HPP_CONSTEXPR Sampler() + : m_sampler(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) + : m_sampler(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) + : m_sampler( sampler ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Sampler & operator=(VkSampler sampler) + { + m_sampler = sampler; + return *this; + } +#endif + + Sampler & operator=( std::nullptr_t ) + { + m_sampler = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Sampler const & rhs ) const + { + return m_sampler == rhs.m_sampler; + } + + bool operator!=(Sampler const & rhs ) const + { + return m_sampler != rhs.m_sampler; + } + + bool operator<(Sampler const & rhs ) const + { + return m_sampler < rhs.m_sampler; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const + { + return m_sampler; + } + + explicit operator bool() const + { + return m_sampler != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_sampler == VK_NULL_HANDLE; + } + + private: + VkSampler m_sampler; + }; + + static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); + + class DescriptorSet + { + public: + VULKAN_HPP_CONSTEXPR DescriptorSet() + : m_descriptorSet(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) + : m_descriptorSet(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) + : m_descriptorSet( descriptorSet ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DescriptorSet & operator=(VkDescriptorSet descriptorSet) + { + m_descriptorSet = descriptorSet; + return *this; + } +#endif + + DescriptorSet & operator=( std::nullptr_t ) + { + m_descriptorSet = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DescriptorSet const & rhs ) const + { + return m_descriptorSet == rhs.m_descriptorSet; + } + + bool operator!=(DescriptorSet const & rhs ) const + { + return m_descriptorSet != rhs.m_descriptorSet; + } + + bool operator<(DescriptorSet const & rhs ) const + { + return m_descriptorSet < rhs.m_descriptorSet; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const + { + return m_descriptorSet; + } + + explicit operator bool() const + { + return m_descriptorSet != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_descriptorSet == VK_NULL_HANDLE; + } + + private: + VkDescriptorSet m_descriptorSet; + }; + + static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); + + class DescriptorSetLayout + { + public: + VULKAN_HPP_CONSTEXPR DescriptorSetLayout() + : m_descriptorSetLayout(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) + : m_descriptorSetLayout(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) + : m_descriptorSetLayout( descriptorSetLayout ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) + { + m_descriptorSetLayout = descriptorSetLayout; + return *this; + } +#endif + + DescriptorSetLayout & operator=( std::nullptr_t ) + { + m_descriptorSetLayout = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DescriptorSetLayout const & rhs ) const + { + return m_descriptorSetLayout == rhs.m_descriptorSetLayout; + } + + bool operator!=(DescriptorSetLayout const & rhs ) const + { + return m_descriptorSetLayout != rhs.m_descriptorSetLayout; + } + + bool operator<(DescriptorSetLayout const & rhs ) const + { + return m_descriptorSetLayout < rhs.m_descriptorSetLayout; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const + { + return m_descriptorSetLayout; + } + + explicit operator bool() const + { + return m_descriptorSetLayout != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_descriptorSetLayout == VK_NULL_HANDLE; + } + + private: + VkDescriptorSetLayout m_descriptorSetLayout; + }; + + static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); + + class DescriptorPool + { + public: + VULKAN_HPP_CONSTEXPR DescriptorPool() + : m_descriptorPool(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) + : m_descriptorPool(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) + : m_descriptorPool( descriptorPool ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DescriptorPool & operator=(VkDescriptorPool descriptorPool) + { + m_descriptorPool = descriptorPool; + return *this; + } +#endif + + DescriptorPool & operator=( std::nullptr_t ) + { + m_descriptorPool = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DescriptorPool const & rhs ) const + { + return m_descriptorPool == rhs.m_descriptorPool; + } + + bool operator!=(DescriptorPool const & rhs ) const + { + return m_descriptorPool != rhs.m_descriptorPool; + } + + bool operator<(DescriptorPool const & rhs ) const + { + return m_descriptorPool < rhs.m_descriptorPool; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const + { + return m_descriptorPool; + } + + explicit operator bool() const + { + return m_descriptorPool != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_descriptorPool == VK_NULL_HANDLE; + } + + private: + VkDescriptorPool m_descriptorPool; + }; + + static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); + + class Fence + { + public: + VULKAN_HPP_CONSTEXPR Fence() + : m_fence(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) + : m_fence(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) + : m_fence( fence ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Fence & operator=(VkFence fence) + { + m_fence = fence; + return *this; + } +#endif + + Fence & operator=( std::nullptr_t ) + { + m_fence = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Fence const & rhs ) const + { + return m_fence == rhs.m_fence; + } + + bool operator!=(Fence const & rhs ) const + { + return m_fence != rhs.m_fence; + } + + bool operator<(Fence const & rhs ) const + { + return m_fence < rhs.m_fence; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const + { + return m_fence; + } + + explicit operator bool() const + { + return m_fence != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_fence == VK_NULL_HANDLE; + } + + private: + VkFence m_fence; + }; + + static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); + + class Semaphore + { + public: + VULKAN_HPP_CONSTEXPR Semaphore() + : m_semaphore(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) + : m_semaphore(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) + : m_semaphore( semaphore ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Semaphore & operator=(VkSemaphore semaphore) + { + m_semaphore = semaphore; + return *this; + } +#endif + + Semaphore & operator=( std::nullptr_t ) + { + m_semaphore = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Semaphore const & rhs ) const + { + return m_semaphore == rhs.m_semaphore; + } + + bool operator!=(Semaphore const & rhs ) const + { + return m_semaphore != rhs.m_semaphore; + } + + bool operator<(Semaphore const & rhs ) const + { + return m_semaphore < rhs.m_semaphore; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const + { + return m_semaphore; + } + + explicit operator bool() const + { + return m_semaphore != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_semaphore == VK_NULL_HANDLE; + } + + private: + VkSemaphore m_semaphore; + }; + + static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); + + class Event + { + public: + VULKAN_HPP_CONSTEXPR Event() + : m_event(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) + : m_event(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) + : m_event( event ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Event & operator=(VkEvent event) + { + m_event = event; + return *this; + } +#endif + + Event & operator=( std::nullptr_t ) + { + m_event = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Event const & rhs ) const + { + return m_event == rhs.m_event; + } + + bool operator!=(Event const & rhs ) const + { + return m_event != rhs.m_event; + } + + bool operator<(Event const & rhs ) const + { + return m_event < rhs.m_event; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const + { + return m_event; + } + + explicit operator bool() const + { + return m_event != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_event == VK_NULL_HANDLE; + } + + private: + VkEvent m_event; + }; + + static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); + + class QueryPool + { + public: + VULKAN_HPP_CONSTEXPR QueryPool() + : m_queryPool(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) + : m_queryPool(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) + : m_queryPool( queryPool ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + QueryPool & operator=(VkQueryPool queryPool) + { + m_queryPool = queryPool; + return *this; + } +#endif + + QueryPool & operator=( std::nullptr_t ) + { + m_queryPool = VK_NULL_HANDLE; + return *this; + } + + bool operator==( QueryPool const & rhs ) const + { + return m_queryPool == rhs.m_queryPool; + } + + bool operator!=(QueryPool const & rhs ) const + { + return m_queryPool != rhs.m_queryPool; + } + + bool operator<(QueryPool const & rhs ) const + { + return m_queryPool < rhs.m_queryPool; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const + { + return m_queryPool; + } + + explicit operator bool() const + { + return m_queryPool != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_queryPool == VK_NULL_HANDLE; + } + + private: + VkQueryPool m_queryPool; + }; + + static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); + + class Framebuffer + { + public: + VULKAN_HPP_CONSTEXPR Framebuffer() + : m_framebuffer(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) + : m_framebuffer(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) + : m_framebuffer( framebuffer ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Framebuffer & operator=(VkFramebuffer framebuffer) + { + m_framebuffer = framebuffer; + return *this; + } +#endif + + Framebuffer & operator=( std::nullptr_t ) + { + m_framebuffer = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Framebuffer const & rhs ) const + { + return m_framebuffer == rhs.m_framebuffer; + } + + bool operator!=(Framebuffer const & rhs ) const + { + return m_framebuffer != rhs.m_framebuffer; + } + + bool operator<(Framebuffer const & rhs ) const + { + return m_framebuffer < rhs.m_framebuffer; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const + { + return m_framebuffer; + } + + explicit operator bool() const + { + return m_framebuffer != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_framebuffer == VK_NULL_HANDLE; + } + + private: + VkFramebuffer m_framebuffer; + }; + + static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); + + class RenderPass + { + public: + VULKAN_HPP_CONSTEXPR RenderPass() + : m_renderPass(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) + : m_renderPass(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) + : m_renderPass( renderPass ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + RenderPass & operator=(VkRenderPass renderPass) + { + m_renderPass = renderPass; + return *this; + } +#endif + + RenderPass & operator=( std::nullptr_t ) + { + m_renderPass = VK_NULL_HANDLE; + return *this; + } + + bool operator==( RenderPass const & rhs ) const + { + return m_renderPass == rhs.m_renderPass; + } + + bool operator!=(RenderPass const & rhs ) const + { + return m_renderPass != rhs.m_renderPass; + } + + bool operator<(RenderPass const & rhs ) const + { + return m_renderPass < rhs.m_renderPass; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const + { + return m_renderPass; + } + + explicit operator bool() const + { + return m_renderPass != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_renderPass == VK_NULL_HANDLE; + } + + private: + VkRenderPass m_renderPass; + }; + + static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); + + class PipelineCache + { + public: + VULKAN_HPP_CONSTEXPR PipelineCache() + : m_pipelineCache(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) + : m_pipelineCache(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) + : m_pipelineCache( pipelineCache ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + PipelineCache & operator=(VkPipelineCache pipelineCache) + { + m_pipelineCache = pipelineCache; + return *this; + } +#endif + + PipelineCache & operator=( std::nullptr_t ) + { + m_pipelineCache = VK_NULL_HANDLE; + return *this; + } + + bool operator==( PipelineCache const & rhs ) const + { + return m_pipelineCache == rhs.m_pipelineCache; + } + + bool operator!=(PipelineCache const & rhs ) const + { + return m_pipelineCache != rhs.m_pipelineCache; + } + + bool operator<(PipelineCache const & rhs ) const + { + return m_pipelineCache < rhs.m_pipelineCache; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const + { + return m_pipelineCache; + } + + explicit operator bool() const + { + return m_pipelineCache != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_pipelineCache == VK_NULL_HANDLE; + } + + private: + VkPipelineCache m_pipelineCache; + }; + + static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); + + class ObjectTableNVX + { + public: + VULKAN_HPP_CONSTEXPR ObjectTableNVX() + : m_objectTableNVX(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR ObjectTableNVX( std::nullptr_t ) + : m_objectTableNVX(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX ) + : m_objectTableNVX( objectTableNVX ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX) + { + m_objectTableNVX = objectTableNVX; + return *this; + } +#endif + + ObjectTableNVX & operator=( std::nullptr_t ) + { + m_objectTableNVX = VK_NULL_HANDLE; + return *this; + } + + bool operator==( ObjectTableNVX const & rhs ) const + { + return m_objectTableNVX == rhs.m_objectTableNVX; + } + + bool operator!=(ObjectTableNVX const & rhs ) const + { + return m_objectTableNVX != rhs.m_objectTableNVX; + } + + bool operator<(ObjectTableNVX const & rhs ) const + { + return m_objectTableNVX < rhs.m_objectTableNVX; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const + { + return m_objectTableNVX; + } + + explicit operator bool() const + { + return m_objectTableNVX != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_objectTableNVX == VK_NULL_HANDLE; + } + + private: + VkObjectTableNVX m_objectTableNVX; + }; + + static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" ); + + class IndirectCommandsLayoutNVX + { + public: + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX() + : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX( std::nullptr_t ) + : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX ) + : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) + { + m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX; + return *this; + } +#endif + + IndirectCommandsLayoutNVX & operator=( std::nullptr_t ) + { + m_indirectCommandsLayoutNVX = VK_NULL_HANDLE; + return *this; + } + + bool operator==( IndirectCommandsLayoutNVX const & rhs ) const + { + return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX; + } + + bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const + { + return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX; + } + + bool operator<(IndirectCommandsLayoutNVX const & rhs ) const + { + return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const + { + return m_indirectCommandsLayoutNVX; + } + + explicit operator bool() const + { + return m_indirectCommandsLayoutNVX != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_indirectCommandsLayoutNVX == VK_NULL_HANDLE; + } + + private: + VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX; + }; + + static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" ); + + class DescriptorUpdateTemplate + { + public: + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() + : m_descriptorUpdateTemplate(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) + : m_descriptorUpdateTemplate(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) + : m_descriptorUpdateTemplate( descriptorUpdateTemplate ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate) + { + m_descriptorUpdateTemplate = descriptorUpdateTemplate; + return *this; + } +#endif + + DescriptorUpdateTemplate & operator=( std::nullptr_t ) + { + m_descriptorUpdateTemplate = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DescriptorUpdateTemplate const & rhs ) const + { + return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate; + } + + bool operator!=(DescriptorUpdateTemplate const & rhs ) const + { + return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate; + } + + bool operator<(DescriptorUpdateTemplate const & rhs ) const + { + return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const + { + return m_descriptorUpdateTemplate; + } + + explicit operator bool() const + { + return m_descriptorUpdateTemplate != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_descriptorUpdateTemplate == VK_NULL_HANDLE; + } + + private: + VkDescriptorUpdateTemplate m_descriptorUpdateTemplate; + }; + + static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); + + using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; + + class SamplerYcbcrConversion + { + public: + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() + : m_samplerYcbcrConversion(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) + : m_samplerYcbcrConversion(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) + : m_samplerYcbcrConversion( samplerYcbcrConversion ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion) + { + m_samplerYcbcrConversion = samplerYcbcrConversion; + return *this; + } +#endif + + SamplerYcbcrConversion & operator=( std::nullptr_t ) + { + m_samplerYcbcrConversion = VK_NULL_HANDLE; + return *this; + } + + bool operator==( SamplerYcbcrConversion const & rhs ) const + { + return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion; + } + + bool operator!=(SamplerYcbcrConversion const & rhs ) const + { + return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion; + } + + bool operator<(SamplerYcbcrConversion const & rhs ) const + { + return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const + { + return m_samplerYcbcrConversion; + } + + explicit operator bool() const + { + return m_samplerYcbcrConversion != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_samplerYcbcrConversion == VK_NULL_HANDLE; + } + + private: + VkSamplerYcbcrConversion m_samplerYcbcrConversion; + }; + + static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); + + using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; + + class ValidationCacheEXT + { + public: + VULKAN_HPP_CONSTEXPR ValidationCacheEXT() + : m_validationCacheEXT(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) + : m_validationCacheEXT(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) + : m_validationCacheEXT( validationCacheEXT ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT) + { + m_validationCacheEXT = validationCacheEXT; + return *this; + } +#endif + + ValidationCacheEXT & operator=( std::nullptr_t ) + { + m_validationCacheEXT = VK_NULL_HANDLE; + return *this; + } + + bool operator==( ValidationCacheEXT const & rhs ) const + { + return m_validationCacheEXT == rhs.m_validationCacheEXT; + } + + bool operator!=(ValidationCacheEXT const & rhs ) const + { + return m_validationCacheEXT != rhs.m_validationCacheEXT; + } + + bool operator<(ValidationCacheEXT const & rhs ) const + { + return m_validationCacheEXT < rhs.m_validationCacheEXT; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const + { + return m_validationCacheEXT; + } + + explicit operator bool() const + { + return m_validationCacheEXT != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_validationCacheEXT == VK_NULL_HANDLE; + } + + private: + VkValidationCacheEXT m_validationCacheEXT; + }; + + static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); + + class DisplayKHR + { + public: + VULKAN_HPP_CONSTEXPR DisplayKHR() + : m_displayKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) + : m_displayKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) + : m_displayKHR( displayKHR ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DisplayKHR & operator=(VkDisplayKHR displayKHR) + { + m_displayKHR = displayKHR; + return *this; + } +#endif + + DisplayKHR & operator=( std::nullptr_t ) + { + m_displayKHR = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DisplayKHR const & rhs ) const + { + return m_displayKHR == rhs.m_displayKHR; + } + + bool operator!=(DisplayKHR const & rhs ) const + { + return m_displayKHR != rhs.m_displayKHR; + } + + bool operator<(DisplayKHR const & rhs ) const + { + return m_displayKHR < rhs.m_displayKHR; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const + { + return m_displayKHR; + } + + explicit operator bool() const + { + return m_displayKHR != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_displayKHR == VK_NULL_HANDLE; + } + + private: + VkDisplayKHR m_displayKHR; + }; + + static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); + + class DisplayModeKHR + { + public: + VULKAN_HPP_CONSTEXPR DisplayModeKHR() + : m_displayModeKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) + : m_displayModeKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) + : m_displayModeKHR( displayModeKHR ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) + { + m_displayModeKHR = displayModeKHR; + return *this; + } +#endif + + DisplayModeKHR & operator=( std::nullptr_t ) + { + m_displayModeKHR = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DisplayModeKHR const & rhs ) const + { + return m_displayModeKHR == rhs.m_displayModeKHR; + } + + bool operator!=(DisplayModeKHR const & rhs ) const + { + return m_displayModeKHR != rhs.m_displayModeKHR; + } + + bool operator<(DisplayModeKHR const & rhs ) const + { + return m_displayModeKHR < rhs.m_displayModeKHR; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const + { + return m_displayModeKHR; + } + + explicit operator bool() const + { + return m_displayModeKHR != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_displayModeKHR == VK_NULL_HANDLE; + } + + private: + VkDisplayModeKHR m_displayModeKHR; + }; + + static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); + + class SurfaceKHR + { + public: + VULKAN_HPP_CONSTEXPR SurfaceKHR() + : m_surfaceKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) + : m_surfaceKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) + : m_surfaceKHR( surfaceKHR ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) + { + m_surfaceKHR = surfaceKHR; + return *this; + } +#endif + + SurfaceKHR & operator=( std::nullptr_t ) + { + m_surfaceKHR = VK_NULL_HANDLE; + return *this; + } + + bool operator==( SurfaceKHR const & rhs ) const + { + return m_surfaceKHR == rhs.m_surfaceKHR; + } + + bool operator!=(SurfaceKHR const & rhs ) const + { + return m_surfaceKHR != rhs.m_surfaceKHR; + } + + bool operator<(SurfaceKHR const & rhs ) const + { + return m_surfaceKHR < rhs.m_surfaceKHR; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const + { + return m_surfaceKHR; + } + + explicit operator bool() const + { + return m_surfaceKHR != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_surfaceKHR == VK_NULL_HANDLE; + } + + private: + VkSurfaceKHR m_surfaceKHR; + }; + + static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); + + class SwapchainKHR + { + public: + VULKAN_HPP_CONSTEXPR SwapchainKHR() + : m_swapchainKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) + : m_swapchainKHR(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) + : m_swapchainKHR( swapchainKHR ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) + { + m_swapchainKHR = swapchainKHR; + return *this; + } +#endif + + SwapchainKHR & operator=( std::nullptr_t ) + { + m_swapchainKHR = VK_NULL_HANDLE; + return *this; + } + + bool operator==( SwapchainKHR const & rhs ) const + { + return m_swapchainKHR == rhs.m_swapchainKHR; + } + + bool operator!=(SwapchainKHR const & rhs ) const + { + return m_swapchainKHR != rhs.m_swapchainKHR; + } + + bool operator<(SwapchainKHR const & rhs ) const + { + return m_swapchainKHR < rhs.m_swapchainKHR; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const + { + return m_swapchainKHR; + } + + explicit operator bool() const + { + return m_swapchainKHR != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_swapchainKHR == VK_NULL_HANDLE; + } + + private: + VkSwapchainKHR m_swapchainKHR; + }; + + static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); + + class DebugReportCallbackEXT + { + public: + VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() + : m_debugReportCallbackEXT(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) + : m_debugReportCallbackEXT(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) + : m_debugReportCallbackEXT( debugReportCallbackEXT ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) + { + m_debugReportCallbackEXT = debugReportCallbackEXT; + return *this; + } +#endif + + DebugReportCallbackEXT & operator=( std::nullptr_t ) + { + m_debugReportCallbackEXT = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DebugReportCallbackEXT const & rhs ) const + { + return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT; + } + + bool operator!=(DebugReportCallbackEXT const & rhs ) const + { + return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT; + } + + bool operator<(DebugReportCallbackEXT const & rhs ) const + { + return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const + { + return m_debugReportCallbackEXT; + } + + explicit operator bool() const + { + return m_debugReportCallbackEXT != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_debugReportCallbackEXT == VK_NULL_HANDLE; + } + + private: + VkDebugReportCallbackEXT m_debugReportCallbackEXT; + }; + + static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); + + class DebugUtilsMessengerEXT + { + public: + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() + : m_debugUtilsMessengerEXT(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) + : m_debugUtilsMessengerEXT(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) + : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) + { + m_debugUtilsMessengerEXT = debugUtilsMessengerEXT; + return *this; + } +#endif + + DebugUtilsMessengerEXT & operator=( std::nullptr_t ) + { + m_debugUtilsMessengerEXT = VK_NULL_HANDLE; + return *this; + } + + bool operator==( DebugUtilsMessengerEXT const & rhs ) const + { + return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT; + } + + bool operator!=(DebugUtilsMessengerEXT const & rhs ) const + { + return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT; + } + + bool operator<(DebugUtilsMessengerEXT const & rhs ) const + { + return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT; + } + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const + { + return m_debugUtilsMessengerEXT; + } + + explicit operator bool() const + { + return m_debugUtilsMessengerEXT != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_debugUtilsMessengerEXT == VK_NULL_HANDLE; + } + + private: + VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT; + }; + + static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" ); + + struct Offset2D + { + Offset2D( int32_t x_ = 0, + int32_t y_ = 0 ) + : x( x_ ) + , y( y_ ) + { + } + + Offset2D( VkOffset2D const & rhs ) + { + memcpy( this, &rhs, sizeof( Offset2D ) ); + } + + Offset2D& operator=( VkOffset2D const & rhs ) + { + memcpy( this, &rhs, sizeof( Offset2D ) ); + return *this; + } + Offset2D& setX( int32_t x_ ) + { + x = x_; + return *this; + } + + Offset2D& setY( int32_t y_ ) + { + y = y_; + return *this; + } + + operator const VkOffset2D&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Offset2D const& rhs ) const + { + return ( x == rhs.x ) + && ( y == rhs.y ); + } + + bool operator!=( Offset2D const& rhs ) const + { + return !operator==( rhs ); + } + + int32_t x; + int32_t y; + }; + static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" ); + + struct Offset3D + { + Offset3D( int32_t x_ = 0, + int32_t y_ = 0, + int32_t z_ = 0 ) + : x( x_ ) + , y( y_ ) + , z( z_ ) + { + } + + explicit Offset3D( Offset2D const& offset2D, + int32_t z_ = 0 ) + : x( offset2D.x ) + , y( offset2D.y ) + , z( z_ ) + {} + + Offset3D( VkOffset3D const & rhs ) + { + memcpy( this, &rhs, sizeof( Offset3D ) ); + } + + Offset3D& operator=( VkOffset3D const & rhs ) + { + memcpy( this, &rhs, sizeof( Offset3D ) ); + return *this; + } + Offset3D& setX( int32_t x_ ) + { + x = x_; + return *this; + } + + Offset3D& setY( int32_t y_ ) + { + y = y_; + return *this; + } + + Offset3D& setZ( int32_t z_ ) + { + z = z_; + return *this; + } + + operator const VkOffset3D&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Offset3D const& rhs ) const + { + return ( x == rhs.x ) + && ( y == rhs.y ) + && ( z == rhs.z ); + } + + bool operator!=( Offset3D const& rhs ) const + { + return !operator==( rhs ); + } + + int32_t x; + int32_t y; + int32_t z; + }; + static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" ); + + struct Extent2D + { + Extent2D( uint32_t width_ = 0, + uint32_t height_ = 0 ) + : width( width_ ) + , height( height_ ) + { + } + + Extent2D( VkExtent2D const & rhs ) + { + memcpy( this, &rhs, sizeof( Extent2D ) ); + } + + Extent2D& operator=( VkExtent2D const & rhs ) + { + memcpy( this, &rhs, sizeof( Extent2D ) ); + return *this; + } + Extent2D& setWidth( uint32_t width_ ) + { + width = width_; + return *this; + } + + Extent2D& setHeight( uint32_t height_ ) + { + height = height_; + return *this; + } + + operator const VkExtent2D&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Extent2D const& rhs ) const + { + return ( width == rhs.width ) + && ( height == rhs.height ); + } + + bool operator!=( Extent2D const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t width; + uint32_t height; + }; + static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" ); + + struct Extent3D + { + Extent3D( uint32_t width_ = 0, + uint32_t height_ = 0, + uint32_t depth_ = 0 ) + : width( width_ ) + , height( height_ ) + , depth( depth_ ) + { + } + + explicit Extent3D( Extent2D const& extent2D, + uint32_t depth_ = 0 ) + : width( extent2D.width ) + , height( extent2D.height ) + , depth( depth_ ) + {} + + Extent3D( VkExtent3D const & rhs ) + { + memcpy( this, &rhs, sizeof( Extent3D ) ); + } + + Extent3D& operator=( VkExtent3D const & rhs ) + { + memcpy( this, &rhs, sizeof( Extent3D ) ); + return *this; + } + Extent3D& setWidth( uint32_t width_ ) + { + width = width_; + return *this; + } + + Extent3D& setHeight( uint32_t height_ ) + { + height = height_; + return *this; + } + + Extent3D& setDepth( uint32_t depth_ ) + { + depth = depth_; + return *this; + } + + operator const VkExtent3D&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Extent3D const& rhs ) const + { + return ( width == rhs.width ) + && ( height == rhs.height ) + && ( depth == rhs.depth ); + } + + bool operator!=( Extent3D const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t width; + uint32_t height; + uint32_t depth; + }; + static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" ); + + struct Viewport + { + Viewport( float x_ = 0, + float y_ = 0, + float width_ = 0, + float height_ = 0, + float minDepth_ = 0, + float maxDepth_ = 0 ) + : x( x_ ) + , y( y_ ) + , width( width_ ) + , height( height_ ) + , minDepth( minDepth_ ) + , maxDepth( maxDepth_ ) + { + } + + Viewport( VkViewport const & rhs ) + { + memcpy( this, &rhs, sizeof( Viewport ) ); + } + + Viewport& operator=( VkViewport const & rhs ) + { + memcpy( this, &rhs, sizeof( Viewport ) ); + return *this; + } + Viewport& setX( float x_ ) + { + x = x_; + return *this; + } + + Viewport& setY( float y_ ) + { + y = y_; + return *this; + } + + Viewport& setWidth( float width_ ) + { + width = width_; + return *this; + } + + Viewport& setHeight( float height_ ) + { + height = height_; + return *this; + } + + Viewport& setMinDepth( float minDepth_ ) + { + minDepth = minDepth_; + return *this; + } + + Viewport& setMaxDepth( float maxDepth_ ) + { + maxDepth = maxDepth_; + return *this; + } + + operator const VkViewport&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Viewport const& rhs ) const + { + return ( x == rhs.x ) + && ( y == rhs.y ) + && ( width == rhs.width ) + && ( height == rhs.height ) + && ( minDepth == rhs.minDepth ) + && ( maxDepth == rhs.maxDepth ); + } + + bool operator!=( Viewport const& rhs ) const + { + return !operator==( rhs ); + } + + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; + }; + static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); + + struct Rect2D + { + Rect2D( Offset2D offset_ = Offset2D(), + Extent2D extent_ = Extent2D() ) + : offset( offset_ ) + , extent( extent_ ) + { + } + + Rect2D( VkRect2D const & rhs ) + { + memcpy( this, &rhs, sizeof( Rect2D ) ); + } + + Rect2D& operator=( VkRect2D const & rhs ) + { + memcpy( this, &rhs, sizeof( Rect2D ) ); + return *this; + } + Rect2D& setOffset( Offset2D offset_ ) + { + offset = offset_; + return *this; + } + + Rect2D& setExtent( Extent2D extent_ ) + { + extent = extent_; + return *this; + } + + operator const VkRect2D&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Rect2D const& rhs ) const + { + return ( offset == rhs.offset ) + && ( extent == rhs.extent ); + } + + bool operator!=( Rect2D const& rhs ) const + { + return !operator==( rhs ); + } + + Offset2D offset; + Extent2D extent; + }; + static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); + + struct ClearRect + { + ClearRect( Rect2D rect_ = Rect2D(), + uint32_t baseArrayLayer_ = 0, + uint32_t layerCount_ = 0 ) + : rect( rect_ ) + , baseArrayLayer( baseArrayLayer_ ) + , layerCount( layerCount_ ) + { + } + + ClearRect( VkClearRect const & rhs ) + { + memcpy( this, &rhs, sizeof( ClearRect ) ); + } + + ClearRect& operator=( VkClearRect const & rhs ) + { + memcpy( this, &rhs, sizeof( ClearRect ) ); + return *this; + } + ClearRect& setRect( Rect2D rect_ ) + { + rect = rect_; + return *this; + } + + ClearRect& setBaseArrayLayer( uint32_t baseArrayLayer_ ) + { + baseArrayLayer = baseArrayLayer_; + return *this; + } + + ClearRect& setLayerCount( uint32_t layerCount_ ) + { + layerCount = layerCount_; + return *this; + } + + operator const VkClearRect&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ClearRect const& rhs ) const + { + return ( rect == rhs.rect ) + && ( baseArrayLayer == rhs.baseArrayLayer ) + && ( layerCount == rhs.layerCount ); + } + + bool operator!=( ClearRect const& rhs ) const + { + return !operator==( rhs ); + } + + Rect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; + }; + static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" ); + + struct ExtensionProperties + { + operator const VkExtensionProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExtensionProperties const& rhs ) const + { + return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 ) + && ( specVersion == rhs.specVersion ); + } + + bool operator!=( ExtensionProperties const& rhs ) const + { + return !operator==( rhs ); + } + + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + }; + static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" ); + + struct LayerProperties + { + operator const VkLayerProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( LayerProperties const& rhs ) const + { + return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 ) + && ( specVersion == rhs.specVersion ) + && ( implementationVersion == rhs.implementationVersion ) + && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ); + } + + bool operator!=( LayerProperties const& rhs ) const + { + return !operator==( rhs ); + } + + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; + }; + static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" ); + + struct AllocationCallbacks + { + AllocationCallbacks( void* pUserData_ = nullptr, + PFN_vkAllocationFunction pfnAllocation_ = nullptr, + PFN_vkReallocationFunction pfnReallocation_ = nullptr, + PFN_vkFreeFunction pfnFree_ = nullptr, + PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr, + PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr ) + : pUserData( pUserData_ ) + , pfnAllocation( pfnAllocation_ ) + , pfnReallocation( pfnReallocation_ ) + , pfnFree( pfnFree_ ) + , pfnInternalAllocation( pfnInternalAllocation_ ) + , pfnInternalFree( pfnInternalFree_ ) + { + } + + AllocationCallbacks( VkAllocationCallbacks const & rhs ) + { + memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); + } + + AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) + { + memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); + return *this; + } + AllocationCallbacks& setPUserData( void* pUserData_ ) + { + pUserData = pUserData_; + return *this; + } + + AllocationCallbacks& setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) + { + pfnAllocation = pfnAllocation_; + return *this; + } + + AllocationCallbacks& setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) + { + pfnReallocation = pfnReallocation_; + return *this; + } + + AllocationCallbacks& setPfnFree( PFN_vkFreeFunction pfnFree_ ) + { + pfnFree = pfnFree_; + return *this; + } + + AllocationCallbacks& setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) + { + pfnInternalAllocation = pfnInternalAllocation_; + return *this; + } + + AllocationCallbacks& setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) + { + pfnInternalFree = pfnInternalFree_; + return *this; + } + + operator const VkAllocationCallbacks&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AllocationCallbacks const& rhs ) const + { + return ( pUserData == rhs.pUserData ) + && ( pfnAllocation == rhs.pfnAllocation ) + && ( pfnReallocation == rhs.pfnReallocation ) + && ( pfnFree == rhs.pfnFree ) + && ( pfnInternalAllocation == rhs.pfnInternalAllocation ) + && ( pfnInternalFree == rhs.pfnInternalFree ); + } + + bool operator!=( AllocationCallbacks const& rhs ) const + { + return !operator==( rhs ); + } + + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; + }; + static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" ); + + struct MemoryRequirements + { + operator const VkMemoryRequirements&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryRequirements const& rhs ) const + { + return ( size == rhs.size ) + && ( alignment == rhs.alignment ) + && ( memoryTypeBits == rhs.memoryTypeBits ); + } + + bool operator!=( MemoryRequirements const& rhs ) const + { + return !operator==( rhs ); + } + + DeviceSize size; + DeviceSize alignment; + uint32_t memoryTypeBits; + }; + static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); + + struct DescriptorBufferInfo + { + DescriptorBufferInfo( Buffer buffer_ = Buffer(), + DeviceSize offset_ = 0, + DeviceSize range_ = 0 ) + : buffer( buffer_ ) + , offset( offset_ ) + , range( range_ ) + { + } + + DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); + } + + DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); + return *this; + } + DescriptorBufferInfo& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + DescriptorBufferInfo& setOffset( DeviceSize offset_ ) + { + offset = offset_; + return *this; + } + + DescriptorBufferInfo& setRange( DeviceSize range_ ) + { + range = range_; + return *this; + } + + operator const VkDescriptorBufferInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorBufferInfo const& rhs ) const + { + return ( buffer == rhs.buffer ) + && ( offset == rhs.offset ) + && ( range == rhs.range ); + } + + bool operator!=( DescriptorBufferInfo const& rhs ) const + { + return !operator==( rhs ); + } + + Buffer buffer; + DeviceSize offset; + DeviceSize range; + }; + static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" ); + + struct SubresourceLayout + { + operator const VkSubresourceLayout&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SubresourceLayout const& rhs ) const + { + return ( offset == rhs.offset ) + && ( size == rhs.size ) + && ( rowPitch == rhs.rowPitch ) + && ( arrayPitch == rhs.arrayPitch ) + && ( depthPitch == rhs.depthPitch ); + } + + bool operator!=( SubresourceLayout const& rhs ) const + { + return !operator==( rhs ); + } + + DeviceSize offset; + DeviceSize size; + DeviceSize rowPitch; + DeviceSize arrayPitch; + DeviceSize depthPitch; + }; + static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); + + struct BufferCopy + { + BufferCopy( DeviceSize srcOffset_ = 0, + DeviceSize dstOffset_ = 0, + DeviceSize size_ = 0 ) + : srcOffset( srcOffset_ ) + , dstOffset( dstOffset_ ) + , size( size_ ) + { + } + + BufferCopy( VkBufferCopy const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferCopy ) ); + } + + BufferCopy& operator=( VkBufferCopy const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferCopy ) ); + return *this; + } + BufferCopy& setSrcOffset( DeviceSize srcOffset_ ) + { + srcOffset = srcOffset_; + return *this; + } + + BufferCopy& setDstOffset( DeviceSize dstOffset_ ) + { + dstOffset = dstOffset_; + return *this; + } + + BufferCopy& setSize( DeviceSize size_ ) + { + size = size_; + return *this; + } + + operator const VkBufferCopy&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferCopy const& rhs ) const + { + return ( srcOffset == rhs.srcOffset ) + && ( dstOffset == rhs.dstOffset ) + && ( size == rhs.size ); + } + + bool operator!=( BufferCopy const& rhs ) const + { + return !operator==( rhs ); + } + + DeviceSize srcOffset; + DeviceSize dstOffset; + DeviceSize size; + }; + static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); + + struct SpecializationMapEntry + { + SpecializationMapEntry( uint32_t constantID_ = 0, + uint32_t offset_ = 0, + size_t size_ = 0 ) + : constantID( constantID_ ) + , offset( offset_ ) + , size( size_ ) + { + } + + SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) + { + memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); + } + + SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) + { + memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); + return *this; + } + SpecializationMapEntry& setConstantID( uint32_t constantID_ ) + { + constantID = constantID_; + return *this; + } + + SpecializationMapEntry& setOffset( uint32_t offset_ ) + { + offset = offset_; + return *this; + } + + SpecializationMapEntry& setSize( size_t size_ ) + { + size = size_; + return *this; + } + + operator const VkSpecializationMapEntry&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SpecializationMapEntry const& rhs ) const + { + return ( constantID == rhs.constantID ) + && ( offset == rhs.offset ) + && ( size == rhs.size ); + } + + bool operator!=( SpecializationMapEntry const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t constantID; + uint32_t offset; + size_t size; + }; + static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" ); + + struct SpecializationInfo + { + SpecializationInfo( uint32_t mapEntryCount_ = 0, + const SpecializationMapEntry* pMapEntries_ = nullptr, + size_t dataSize_ = 0, + const void* pData_ = nullptr ) + : mapEntryCount( mapEntryCount_ ) + , pMapEntries( pMapEntries_ ) + , dataSize( dataSize_ ) + , pData( pData_ ) + { + } + + SpecializationInfo( VkSpecializationInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SpecializationInfo ) ); + } + + SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SpecializationInfo ) ); + return *this; + } + SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ ) + { + mapEntryCount = mapEntryCount_; + return *this; + } + + SpecializationInfo& setPMapEntries( const SpecializationMapEntry* pMapEntries_ ) + { + pMapEntries = pMapEntries_; + return *this; + } + + SpecializationInfo& setDataSize( size_t dataSize_ ) + { + dataSize = dataSize_; + return *this; + } + + SpecializationInfo& setPData( const void* pData_ ) + { + pData = pData_; + return *this; + } + + operator const VkSpecializationInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SpecializationInfo const& rhs ) const + { + return ( mapEntryCount == rhs.mapEntryCount ) + && ( pMapEntries == rhs.pMapEntries ) + && ( dataSize == rhs.dataSize ) + && ( pData == rhs.pData ); + } + + bool operator!=( SpecializationInfo const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t mapEntryCount; + const SpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; + }; + static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); + + union ClearColorValue + { + ClearColorValue( const std::array& float32_ = { {0} } ) + { + memcpy( &float32, float32_.data(), 4 * sizeof( float ) ); + } + + ClearColorValue( const std::array& int32_ ) + { + memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) ); + } + + ClearColorValue( const std::array& uint32_ ) + { + memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) ); + } + + ClearColorValue& setFloat32( std::array float32_ ) + { + memcpy( &float32, float32_.data(), 4 * sizeof( float ) ); + return *this; + } + + ClearColorValue& setInt32( std::array int32_ ) + { + memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) ); + return *this; + } + + ClearColorValue& setUint32( std::array uint32_ ) + { + memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) ); + return *this; + } + + operator VkClearColorValue const& () const + { + return *reinterpret_cast(this); + } + + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; + }; + + struct ClearDepthStencilValue + { + ClearDepthStencilValue( float depth_ = 0, + uint32_t stencil_ = 0 ) + : depth( depth_ ) + , stencil( stencil_ ) + { + } + + ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) + { + memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); + } + + ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) + { + memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); + return *this; + } + ClearDepthStencilValue& setDepth( float depth_ ) + { + depth = depth_; + return *this; + } + + ClearDepthStencilValue& setStencil( uint32_t stencil_ ) + { + stencil = stencil_; + return *this; + } + + operator const VkClearDepthStencilValue&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ClearDepthStencilValue const& rhs ) const + { + return ( depth == rhs.depth ) + && ( stencil == rhs.stencil ); + } + + bool operator!=( ClearDepthStencilValue const& rhs ) const + { + return !operator==( rhs ); + } + + float depth; + uint32_t stencil; + }; + static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" ); + + union ClearValue + { + ClearValue( ClearColorValue color_ = ClearColorValue() ) + { + color = color_; + } + + ClearValue( ClearDepthStencilValue depthStencil_ ) + { + depthStencil = depthStencil_; + } + + ClearValue& setColor( ClearColorValue color_ ) + { + color = color_; + return *this; + } + + ClearValue& setDepthStencil( ClearDepthStencilValue depthStencil_ ) + { + depthStencil = depthStencil_; + return *this; + } + + operator VkClearValue const& () const + { + return *reinterpret_cast(this); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + ClearColorValue color; + ClearDepthStencilValue depthStencil; +#else + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +#endif // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + }; + + struct PhysicalDeviceFeatures + { + PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0, + Bool32 fullDrawIndexUint32_ = 0, + Bool32 imageCubeArray_ = 0, + Bool32 independentBlend_ = 0, + Bool32 geometryShader_ = 0, + Bool32 tessellationShader_ = 0, + Bool32 sampleRateShading_ = 0, + Bool32 dualSrcBlend_ = 0, + Bool32 logicOp_ = 0, + Bool32 multiDrawIndirect_ = 0, + Bool32 drawIndirectFirstInstance_ = 0, + Bool32 depthClamp_ = 0, + Bool32 depthBiasClamp_ = 0, + Bool32 fillModeNonSolid_ = 0, + Bool32 depthBounds_ = 0, + Bool32 wideLines_ = 0, + Bool32 largePoints_ = 0, + Bool32 alphaToOne_ = 0, + Bool32 multiViewport_ = 0, + Bool32 samplerAnisotropy_ = 0, + Bool32 textureCompressionETC2_ = 0, + Bool32 textureCompressionASTC_LDR_ = 0, + Bool32 textureCompressionBC_ = 0, + Bool32 occlusionQueryPrecise_ = 0, + Bool32 pipelineStatisticsQuery_ = 0, + Bool32 vertexPipelineStoresAndAtomics_ = 0, + Bool32 fragmentStoresAndAtomics_ = 0, + Bool32 shaderTessellationAndGeometryPointSize_ = 0, + Bool32 shaderImageGatherExtended_ = 0, + Bool32 shaderStorageImageExtendedFormats_ = 0, + Bool32 shaderStorageImageMultisample_ = 0, + Bool32 shaderStorageImageReadWithoutFormat_ = 0, + Bool32 shaderStorageImageWriteWithoutFormat_ = 0, + Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0, + Bool32 shaderSampledImageArrayDynamicIndexing_ = 0, + Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0, + Bool32 shaderStorageImageArrayDynamicIndexing_ = 0, + Bool32 shaderClipDistance_ = 0, + Bool32 shaderCullDistance_ = 0, + Bool32 shaderFloat64_ = 0, + Bool32 shaderInt64_ = 0, + Bool32 shaderInt16_ = 0, + Bool32 shaderResourceResidency_ = 0, + Bool32 shaderResourceMinLod_ = 0, + Bool32 sparseBinding_ = 0, + Bool32 sparseResidencyBuffer_ = 0, + Bool32 sparseResidencyImage2D_ = 0, + Bool32 sparseResidencyImage3D_ = 0, + Bool32 sparseResidency2Samples_ = 0, + Bool32 sparseResidency4Samples_ = 0, + Bool32 sparseResidency8Samples_ = 0, + Bool32 sparseResidency16Samples_ = 0, + Bool32 sparseResidencyAliased_ = 0, + Bool32 variableMultisampleRate_ = 0, + Bool32 inheritedQueries_ = 0 ) + : robustBufferAccess( robustBufferAccess_ ) + , fullDrawIndexUint32( fullDrawIndexUint32_ ) + , imageCubeArray( imageCubeArray_ ) + , independentBlend( independentBlend_ ) + , geometryShader( geometryShader_ ) + , tessellationShader( tessellationShader_ ) + , sampleRateShading( sampleRateShading_ ) + , dualSrcBlend( dualSrcBlend_ ) + , logicOp( logicOp_ ) + , multiDrawIndirect( multiDrawIndirect_ ) + , drawIndirectFirstInstance( drawIndirectFirstInstance_ ) + , depthClamp( depthClamp_ ) + , depthBiasClamp( depthBiasClamp_ ) + , fillModeNonSolid( fillModeNonSolid_ ) + , depthBounds( depthBounds_ ) + , wideLines( wideLines_ ) + , largePoints( largePoints_ ) + , alphaToOne( alphaToOne_ ) + , multiViewport( multiViewport_ ) + , samplerAnisotropy( samplerAnisotropy_ ) + , textureCompressionETC2( textureCompressionETC2_ ) + , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ ) + , textureCompressionBC( textureCompressionBC_ ) + , occlusionQueryPrecise( occlusionQueryPrecise_ ) + , pipelineStatisticsQuery( pipelineStatisticsQuery_ ) + , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ ) + , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ ) + , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ ) + , shaderImageGatherExtended( shaderImageGatherExtended_ ) + , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ ) + , shaderStorageImageMultisample( shaderStorageImageMultisample_ ) + , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ ) + , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ ) + , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ ) + , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ ) + , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ ) + , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ ) + , shaderClipDistance( shaderClipDistance_ ) + , shaderCullDistance( shaderCullDistance_ ) + , shaderFloat64( shaderFloat64_ ) + , shaderInt64( shaderInt64_ ) + , shaderInt16( shaderInt16_ ) + , shaderResourceResidency( shaderResourceResidency_ ) + , shaderResourceMinLod( shaderResourceMinLod_ ) + , sparseBinding( sparseBinding_ ) + , sparseResidencyBuffer( sparseResidencyBuffer_ ) + , sparseResidencyImage2D( sparseResidencyImage2D_ ) + , sparseResidencyImage3D( sparseResidencyImage3D_ ) + , sparseResidency2Samples( sparseResidency2Samples_ ) + , sparseResidency4Samples( sparseResidency4Samples_ ) + , sparseResidency8Samples( sparseResidency8Samples_ ) + , sparseResidency16Samples( sparseResidency16Samples_ ) + , sparseResidencyAliased( sparseResidencyAliased_ ) + , variableMultisampleRate( variableMultisampleRate_ ) + , inheritedQueries( inheritedQueries_ ) + { + } + + PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); + } + + PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); + return *this; + } + PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ ) + { + robustBufferAccess = robustBufferAccess_; + return *this; + } + + PhysicalDeviceFeatures& setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) + { + fullDrawIndexUint32 = fullDrawIndexUint32_; + return *this; + } + + PhysicalDeviceFeatures& setImageCubeArray( Bool32 imageCubeArray_ ) + { + imageCubeArray = imageCubeArray_; + return *this; + } + + PhysicalDeviceFeatures& setIndependentBlend( Bool32 independentBlend_ ) + { + independentBlend = independentBlend_; + return *this; + } + + PhysicalDeviceFeatures& setGeometryShader( Bool32 geometryShader_ ) + { + geometryShader = geometryShader_; + return *this; + } + + PhysicalDeviceFeatures& setTessellationShader( Bool32 tessellationShader_ ) + { + tessellationShader = tessellationShader_; + return *this; + } + + PhysicalDeviceFeatures& setSampleRateShading( Bool32 sampleRateShading_ ) + { + sampleRateShading = sampleRateShading_; + return *this; + } + + PhysicalDeviceFeatures& setDualSrcBlend( Bool32 dualSrcBlend_ ) + { + dualSrcBlend = dualSrcBlend_; + return *this; + } + + PhysicalDeviceFeatures& setLogicOp( Bool32 logicOp_ ) + { + logicOp = logicOp_; + return *this; + } + + PhysicalDeviceFeatures& setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) + { + multiDrawIndirect = multiDrawIndirect_; + return *this; + } + + PhysicalDeviceFeatures& setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) + { + drawIndirectFirstInstance = drawIndirectFirstInstance_; + return *this; + } + + PhysicalDeviceFeatures& setDepthClamp( Bool32 depthClamp_ ) + { + depthClamp = depthClamp_; + return *this; + } + + PhysicalDeviceFeatures& setDepthBiasClamp( Bool32 depthBiasClamp_ ) + { + depthBiasClamp = depthBiasClamp_; + return *this; + } + + PhysicalDeviceFeatures& setFillModeNonSolid( Bool32 fillModeNonSolid_ ) + { + fillModeNonSolid = fillModeNonSolid_; + return *this; + } + + PhysicalDeviceFeatures& setDepthBounds( Bool32 depthBounds_ ) + { + depthBounds = depthBounds_; + return *this; + } + + PhysicalDeviceFeatures& setWideLines( Bool32 wideLines_ ) + { + wideLines = wideLines_; + return *this; + } + + PhysicalDeviceFeatures& setLargePoints( Bool32 largePoints_ ) + { + largePoints = largePoints_; + return *this; + } + + PhysicalDeviceFeatures& setAlphaToOne( Bool32 alphaToOne_ ) + { + alphaToOne = alphaToOne_; + return *this; + } + + PhysicalDeviceFeatures& setMultiViewport( Bool32 multiViewport_ ) + { + multiViewport = multiViewport_; + return *this; + } + + PhysicalDeviceFeatures& setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) + { + samplerAnisotropy = samplerAnisotropy_; + return *this; + } + + PhysicalDeviceFeatures& setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) + { + textureCompressionETC2 = textureCompressionETC2_; + return *this; + } + + PhysicalDeviceFeatures& setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) + { + textureCompressionASTC_LDR = textureCompressionASTC_LDR_; + return *this; + } + + PhysicalDeviceFeatures& setTextureCompressionBC( Bool32 textureCompressionBC_ ) + { + textureCompressionBC = textureCompressionBC_; + return *this; + } + + PhysicalDeviceFeatures& setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) + { + occlusionQueryPrecise = occlusionQueryPrecise_; + return *this; + } + + PhysicalDeviceFeatures& setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) + { + pipelineStatisticsQuery = pipelineStatisticsQuery_; + return *this; + } + + PhysicalDeviceFeatures& setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) + { + vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_; + return *this; + } + + PhysicalDeviceFeatures& setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) + { + fragmentStoresAndAtomics = fragmentStoresAndAtomics_; + return *this; + } + + PhysicalDeviceFeatures& setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) + { + shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_; + return *this; + } + + PhysicalDeviceFeatures& setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) + { + shaderImageGatherExtended = shaderImageGatherExtended_; + return *this; + } + + PhysicalDeviceFeatures& setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) + { + shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_; + return *this; + } + + PhysicalDeviceFeatures& setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ ) + { + shaderStorageImageMultisample = shaderStorageImageMultisample_; + return *this; + } + + PhysicalDeviceFeatures& setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ ) + { + shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_; + return *this; + } + + PhysicalDeviceFeatures& setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ ) + { + shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_; + return *this; + } + + PhysicalDeviceFeatures& setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ ) + { + shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_; + return *this; + } + + PhysicalDeviceFeatures& setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ ) + { + shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_; + return *this; + } + + PhysicalDeviceFeatures& setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ ) + { + shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_; + return *this; + } + + PhysicalDeviceFeatures& setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ ) + { + shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_; + return *this; + } + + PhysicalDeviceFeatures& setShaderClipDistance( Bool32 shaderClipDistance_ ) + { + shaderClipDistance = shaderClipDistance_; + return *this; + } + + PhysicalDeviceFeatures& setShaderCullDistance( Bool32 shaderCullDistance_ ) + { + shaderCullDistance = shaderCullDistance_; + return *this; + } + + PhysicalDeviceFeatures& setShaderFloat64( Bool32 shaderFloat64_ ) + { + shaderFloat64 = shaderFloat64_; + return *this; + } + + PhysicalDeviceFeatures& setShaderInt64( Bool32 shaderInt64_ ) + { + shaderInt64 = shaderInt64_; + return *this; + } + + PhysicalDeviceFeatures& setShaderInt16( Bool32 shaderInt16_ ) + { + shaderInt16 = shaderInt16_; + return *this; + } + + PhysicalDeviceFeatures& setShaderResourceResidency( Bool32 shaderResourceResidency_ ) + { + shaderResourceResidency = shaderResourceResidency_; + return *this; + } + + PhysicalDeviceFeatures& setShaderResourceMinLod( Bool32 shaderResourceMinLod_ ) + { + shaderResourceMinLod = shaderResourceMinLod_; + return *this; + } + + PhysicalDeviceFeatures& setSparseBinding( Bool32 sparseBinding_ ) + { + sparseBinding = sparseBinding_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ ) + { + sparseResidencyBuffer = sparseResidencyBuffer_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ ) + { + sparseResidencyImage2D = sparseResidencyImage2D_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ ) + { + sparseResidencyImage3D = sparseResidencyImage3D_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidency2Samples( Bool32 sparseResidency2Samples_ ) + { + sparseResidency2Samples = sparseResidency2Samples_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidency4Samples( Bool32 sparseResidency4Samples_ ) + { + sparseResidency4Samples = sparseResidency4Samples_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidency8Samples( Bool32 sparseResidency8Samples_ ) + { + sparseResidency8Samples = sparseResidency8Samples_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidency16Samples( Bool32 sparseResidency16Samples_ ) + { + sparseResidency16Samples = sparseResidency16Samples_; + return *this; + } + + PhysicalDeviceFeatures& setSparseResidencyAliased( Bool32 sparseResidencyAliased_ ) + { + sparseResidencyAliased = sparseResidencyAliased_; + return *this; + } + + PhysicalDeviceFeatures& setVariableMultisampleRate( Bool32 variableMultisampleRate_ ) + { + variableMultisampleRate = variableMultisampleRate_; + return *this; + } + + PhysicalDeviceFeatures& setInheritedQueries( Bool32 inheritedQueries_ ) + { + inheritedQueries = inheritedQueries_; + return *this; + } + + operator const VkPhysicalDeviceFeatures&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceFeatures const& rhs ) const + { + return ( robustBufferAccess == rhs.robustBufferAccess ) + && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) + && ( imageCubeArray == rhs.imageCubeArray ) + && ( independentBlend == rhs.independentBlend ) + && ( geometryShader == rhs.geometryShader ) + && ( tessellationShader == rhs.tessellationShader ) + && ( sampleRateShading == rhs.sampleRateShading ) + && ( dualSrcBlend == rhs.dualSrcBlend ) + && ( logicOp == rhs.logicOp ) + && ( multiDrawIndirect == rhs.multiDrawIndirect ) + && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) + && ( depthClamp == rhs.depthClamp ) + && ( depthBiasClamp == rhs.depthBiasClamp ) + && ( fillModeNonSolid == rhs.fillModeNonSolid ) + && ( depthBounds == rhs.depthBounds ) + && ( wideLines == rhs.wideLines ) + && ( largePoints == rhs.largePoints ) + && ( alphaToOne == rhs.alphaToOne ) + && ( multiViewport == rhs.multiViewport ) + && ( samplerAnisotropy == rhs.samplerAnisotropy ) + && ( textureCompressionETC2 == rhs.textureCompressionETC2 ) + && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) + && ( textureCompressionBC == rhs.textureCompressionBC ) + && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) + && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) + && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) + && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) + && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) + && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) + && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) + && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) + && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) + && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) + && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) + && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) + && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) + && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) + && ( shaderClipDistance == rhs.shaderClipDistance ) + && ( shaderCullDistance == rhs.shaderCullDistance ) + && ( shaderFloat64 == rhs.shaderFloat64 ) + && ( shaderInt64 == rhs.shaderInt64 ) + && ( shaderInt16 == rhs.shaderInt16 ) + && ( shaderResourceResidency == rhs.shaderResourceResidency ) + && ( shaderResourceMinLod == rhs.shaderResourceMinLod ) + && ( sparseBinding == rhs.sparseBinding ) + && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) + && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) + && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) + && ( sparseResidency2Samples == rhs.sparseResidency2Samples ) + && ( sparseResidency4Samples == rhs.sparseResidency4Samples ) + && ( sparseResidency8Samples == rhs.sparseResidency8Samples ) + && ( sparseResidency16Samples == rhs.sparseResidency16Samples ) + && ( sparseResidencyAliased == rhs.sparseResidencyAliased ) + && ( variableMultisampleRate == rhs.variableMultisampleRate ) + && ( inheritedQueries == rhs.inheritedQueries ); + } + + bool operator!=( PhysicalDeviceFeatures const& rhs ) const + { + return !operator==( rhs ); + } + + Bool32 robustBufferAccess; + Bool32 fullDrawIndexUint32; + Bool32 imageCubeArray; + Bool32 independentBlend; + Bool32 geometryShader; + Bool32 tessellationShader; + Bool32 sampleRateShading; + Bool32 dualSrcBlend; + Bool32 logicOp; + Bool32 multiDrawIndirect; + Bool32 drawIndirectFirstInstance; + Bool32 depthClamp; + Bool32 depthBiasClamp; + Bool32 fillModeNonSolid; + Bool32 depthBounds; + Bool32 wideLines; + Bool32 largePoints; + Bool32 alphaToOne; + Bool32 multiViewport; + Bool32 samplerAnisotropy; + Bool32 textureCompressionETC2; + Bool32 textureCompressionASTC_LDR; + Bool32 textureCompressionBC; + Bool32 occlusionQueryPrecise; + Bool32 pipelineStatisticsQuery; + Bool32 vertexPipelineStoresAndAtomics; + Bool32 fragmentStoresAndAtomics; + Bool32 shaderTessellationAndGeometryPointSize; + Bool32 shaderImageGatherExtended; + Bool32 shaderStorageImageExtendedFormats; + Bool32 shaderStorageImageMultisample; + Bool32 shaderStorageImageReadWithoutFormat; + Bool32 shaderStorageImageWriteWithoutFormat; + Bool32 shaderUniformBufferArrayDynamicIndexing; + Bool32 shaderSampledImageArrayDynamicIndexing; + Bool32 shaderStorageBufferArrayDynamicIndexing; + Bool32 shaderStorageImageArrayDynamicIndexing; + Bool32 shaderClipDistance; + Bool32 shaderCullDistance; + Bool32 shaderFloat64; + Bool32 shaderInt64; + Bool32 shaderInt16; + Bool32 shaderResourceResidency; + Bool32 shaderResourceMinLod; + Bool32 sparseBinding; + Bool32 sparseResidencyBuffer; + Bool32 sparseResidencyImage2D; + Bool32 sparseResidencyImage3D; + Bool32 sparseResidency2Samples; + Bool32 sparseResidency4Samples; + Bool32 sparseResidency8Samples; + Bool32 sparseResidency16Samples; + Bool32 sparseResidencyAliased; + Bool32 variableMultisampleRate; + Bool32 inheritedQueries; + }; + static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceSparseProperties + { + operator const VkPhysicalDeviceSparseProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSparseProperties const& rhs ) const + { + return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) + && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) + && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) + && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) + && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); + } + + bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const + { + return !operator==( rhs ); + } + + Bool32 residencyStandard2DBlockShape; + Bool32 residencyStandard2DMultisampleBlockShape; + Bool32 residencyStandard3DBlockShape; + Bool32 residencyAlignedMipSize; + Bool32 residencyNonResidentStrict; + }; + static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" ); + + struct DrawIndirectCommand + { + DrawIndirectCommand( uint32_t vertexCount_ = 0, + uint32_t instanceCount_ = 0, + uint32_t firstVertex_ = 0, + uint32_t firstInstance_ = 0 ) + : vertexCount( vertexCount_ ) + , instanceCount( instanceCount_ ) + , firstVertex( firstVertex_ ) + , firstInstance( firstInstance_ ) + { + } + + DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) + { + memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); + } + + DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) + { + memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); + return *this; + } + DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ ) + { + vertexCount = vertexCount_; + return *this; + } + + DrawIndirectCommand& setInstanceCount( uint32_t instanceCount_ ) + { + instanceCount = instanceCount_; + return *this; + } + + DrawIndirectCommand& setFirstVertex( uint32_t firstVertex_ ) + { + firstVertex = firstVertex_; + return *this; + } + + DrawIndirectCommand& setFirstInstance( uint32_t firstInstance_ ) + { + firstInstance = firstInstance_; + return *this; + } + + operator const VkDrawIndirectCommand&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DrawIndirectCommand const& rhs ) const + { + return ( vertexCount == rhs.vertexCount ) + && ( instanceCount == rhs.instanceCount ) + && ( firstVertex == rhs.firstVertex ) + && ( firstInstance == rhs.firstInstance ); + } + + bool operator!=( DrawIndirectCommand const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; + }; + static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" ); + + struct DrawIndexedIndirectCommand + { + DrawIndexedIndirectCommand( uint32_t indexCount_ = 0, + uint32_t instanceCount_ = 0, + uint32_t firstIndex_ = 0, + int32_t vertexOffset_ = 0, + uint32_t firstInstance_ = 0 ) + : indexCount( indexCount_ ) + , instanceCount( instanceCount_ ) + , firstIndex( firstIndex_ ) + , vertexOffset( vertexOffset_ ) + , firstInstance( firstInstance_ ) + { + } + + DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) + { + memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); + } + + DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) + { + memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); + return *this; + } + DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ ) + { + indexCount = indexCount_; + return *this; + } + + DrawIndexedIndirectCommand& setInstanceCount( uint32_t instanceCount_ ) + { + instanceCount = instanceCount_; + return *this; + } + + DrawIndexedIndirectCommand& setFirstIndex( uint32_t firstIndex_ ) + { + firstIndex = firstIndex_; + return *this; + } + + DrawIndexedIndirectCommand& setVertexOffset( int32_t vertexOffset_ ) + { + vertexOffset = vertexOffset_; + return *this; + } + + DrawIndexedIndirectCommand& setFirstInstance( uint32_t firstInstance_ ) + { + firstInstance = firstInstance_; + return *this; + } + + operator const VkDrawIndexedIndirectCommand&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DrawIndexedIndirectCommand const& rhs ) const + { + return ( indexCount == rhs.indexCount ) + && ( instanceCount == rhs.instanceCount ) + && ( firstIndex == rhs.firstIndex ) + && ( vertexOffset == rhs.vertexOffset ) + && ( firstInstance == rhs.firstInstance ); + } + + bool operator!=( DrawIndexedIndirectCommand const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; + }; + static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" ); + + struct DispatchIndirectCommand + { + DispatchIndirectCommand( uint32_t x_ = 0, + uint32_t y_ = 0, + uint32_t z_ = 0 ) + : x( x_ ) + , y( y_ ) + , z( z_ ) + { + } + + DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) + { + memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); + } + + DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) + { + memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); + return *this; + } + DispatchIndirectCommand& setX( uint32_t x_ ) + { + x = x_; + return *this; + } + + DispatchIndirectCommand& setY( uint32_t y_ ) + { + y = y_; + return *this; + } + + DispatchIndirectCommand& setZ( uint32_t z_ ) + { + z = z_; + return *this; + } + + operator const VkDispatchIndirectCommand&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DispatchIndirectCommand const& rhs ) const + { + return ( x == rhs.x ) + && ( y == rhs.y ) + && ( z == rhs.z ); + } + + bool operator!=( DispatchIndirectCommand const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t x; + uint32_t y; + uint32_t z; + }; + static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" ); + + struct DisplayPlanePropertiesKHR + { + operator const VkDisplayPlanePropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPlanePropertiesKHR const& rhs ) const + { + return ( currentDisplay == rhs.currentDisplay ) + && ( currentStackIndex == rhs.currentStackIndex ); + } + + bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + DisplayKHR currentDisplay; + uint32_t currentStackIndex; + }; + static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" ); + + struct DisplayModeParametersKHR + { + DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(), + uint32_t refreshRate_ = 0 ) + : visibleRegion( visibleRegion_ ) + , refreshRate( refreshRate_ ) + { + } + + DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); + } + + DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); + return *this; + } + DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ ) + { + visibleRegion = visibleRegion_; + return *this; + } + + DisplayModeParametersKHR& setRefreshRate( uint32_t refreshRate_ ) + { + refreshRate = refreshRate_; + return *this; + } + + operator const VkDisplayModeParametersKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayModeParametersKHR const& rhs ) const + { + return ( visibleRegion == rhs.visibleRegion ) + && ( refreshRate == rhs.refreshRate ); + } + + bool operator!=( DisplayModeParametersKHR const& rhs ) const + { + return !operator==( rhs ); + } + + Extent2D visibleRegion; + uint32_t refreshRate; + }; + static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" ); + + struct DisplayModePropertiesKHR + { + operator const VkDisplayModePropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayModePropertiesKHR const& rhs ) const + { + return ( displayMode == rhs.displayMode ) + && ( parameters == rhs.parameters ); + } + + bool operator!=( DisplayModePropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + DisplayModeKHR displayMode; + DisplayModeParametersKHR parameters; + }; + static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" ); + + struct RectLayerKHR + { + RectLayerKHR( Offset2D offset_ = Offset2D(), + Extent2D extent_ = Extent2D(), + uint32_t layer_ = 0 ) + : offset( offset_ ) + , extent( extent_ ) + , layer( layer_ ) + { + } + + explicit RectLayerKHR( Rect2D const& rect2D, + uint32_t layer_ = 0 ) + : offset( rect2D.offset ) + , extent( rect2D.extent ) + , layer( layer_ ) + {} + + RectLayerKHR( VkRectLayerKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( RectLayerKHR ) ); + } + + RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( RectLayerKHR ) ); + return *this; + } + RectLayerKHR& setOffset( Offset2D offset_ ) + { + offset = offset_; + return *this; + } + + RectLayerKHR& setExtent( Extent2D extent_ ) + { + extent = extent_; + return *this; + } + + RectLayerKHR& setLayer( uint32_t layer_ ) + { + layer = layer_; + return *this; + } + + operator const VkRectLayerKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( RectLayerKHR const& rhs ) const + { + return ( offset == rhs.offset ) + && ( extent == rhs.extent ) + && ( layer == rhs.layer ); + } + + bool operator!=( RectLayerKHR const& rhs ) const + { + return !operator==( rhs ); + } + + Offset2D offset; + Extent2D extent; + uint32_t layer; + }; + static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" ); + + struct PresentRegionKHR + { + PresentRegionKHR( uint32_t rectangleCount_ = 0, + const RectLayerKHR* pRectangles_ = nullptr ) + : rectangleCount( rectangleCount_ ) + , pRectangles( pRectangles_ ) + { + } + + PresentRegionKHR( VkPresentRegionKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); + } + + PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); + return *this; + } + PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ ) + { + rectangleCount = rectangleCount_; + return *this; + } + + PresentRegionKHR& setPRectangles( const RectLayerKHR* pRectangles_ ) + { + pRectangles = pRectangles_; + return *this; + } + + operator const VkPresentRegionKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PresentRegionKHR const& rhs ) const + { + return ( rectangleCount == rhs.rectangleCount ) + && ( pRectangles == rhs.pRectangles ); + } + + bool operator!=( PresentRegionKHR const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t rectangleCount; + const RectLayerKHR* pRectangles; + }; + static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); + + struct XYColorEXT + { + XYColorEXT( float x_ = 0, + float y_ = 0 ) + : x( x_ ) + , y( y_ ) + { + } + + XYColorEXT( VkXYColorEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( XYColorEXT ) ); + } + + XYColorEXT& operator=( VkXYColorEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( XYColorEXT ) ); + return *this; + } + XYColorEXT& setX( float x_ ) + { + x = x_; + return *this; + } + + XYColorEXT& setY( float y_ ) + { + y = y_; + return *this; + } + + operator const VkXYColorEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( XYColorEXT const& rhs ) const + { + return ( x == rhs.x ) + && ( y == rhs.y ); + } + + bool operator!=( XYColorEXT const& rhs ) const + { + return !operator==( rhs ); + } + + float x; + float y; + }; + static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); + + struct RefreshCycleDurationGOOGLE + { + RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = 0 ) + : refreshDuration( refreshDuration_ ) + { + } + + RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); + } + + RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); + return *this; + } + RefreshCycleDurationGOOGLE& setRefreshDuration( uint64_t refreshDuration_ ) + { + refreshDuration = refreshDuration_; + return *this; + } + + operator const VkRefreshCycleDurationGOOGLE&() const + { + return *reinterpret_cast(this); + } + + bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const + { + return ( refreshDuration == rhs.refreshDuration ); + } + + bool operator!=( RefreshCycleDurationGOOGLE const& rhs ) const + { + return !operator==( rhs ); + } + + uint64_t refreshDuration; + }; + static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" ); + + struct PastPresentationTimingGOOGLE + { + PastPresentationTimingGOOGLE( uint32_t presentID_ = 0, + uint64_t desiredPresentTime_ = 0, + uint64_t actualPresentTime_ = 0, + uint64_t earliestPresentTime_ = 0, + uint64_t presentMargin_ = 0 ) + : presentID( presentID_ ) + , desiredPresentTime( desiredPresentTime_ ) + , actualPresentTime( actualPresentTime_ ) + , earliestPresentTime( earliestPresentTime_ ) + , presentMargin( presentMargin_ ) + { + } + + PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); + } + + PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); + return *this; + } + PastPresentationTimingGOOGLE& setPresentID( uint32_t presentID_ ) + { + presentID = presentID_; + return *this; + } + + PastPresentationTimingGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ ) + { + desiredPresentTime = desiredPresentTime_; + return *this; + } + + PastPresentationTimingGOOGLE& setActualPresentTime( uint64_t actualPresentTime_ ) + { + actualPresentTime = actualPresentTime_; + return *this; + } + + PastPresentationTimingGOOGLE& setEarliestPresentTime( uint64_t earliestPresentTime_ ) + { + earliestPresentTime = earliestPresentTime_; + return *this; + } + + PastPresentationTimingGOOGLE& setPresentMargin( uint64_t presentMargin_ ) + { + presentMargin = presentMargin_; + return *this; + } + + operator const VkPastPresentationTimingGOOGLE&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PastPresentationTimingGOOGLE const& rhs ) const + { + return ( presentID == rhs.presentID ) + && ( desiredPresentTime == rhs.desiredPresentTime ) + && ( actualPresentTime == rhs.actualPresentTime ) + && ( earliestPresentTime == rhs.earliestPresentTime ) + && ( presentMargin == rhs.presentMargin ); + } + + bool operator!=( PastPresentationTimingGOOGLE const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; + }; + static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" ); + + struct PresentTimeGOOGLE + { + PresentTimeGOOGLE( uint32_t presentID_ = 0, + uint64_t desiredPresentTime_ = 0 ) + : presentID( presentID_ ) + , desiredPresentTime( desiredPresentTime_ ) + { + } + + PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); + } + + PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); + return *this; + } + PresentTimeGOOGLE& setPresentID( uint32_t presentID_ ) + { + presentID = presentID_; + return *this; + } + + PresentTimeGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ ) + { + desiredPresentTime = desiredPresentTime_; + return *this; + } + + operator const VkPresentTimeGOOGLE&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PresentTimeGOOGLE const& rhs ) const + { + return ( presentID == rhs.presentID ) + && ( desiredPresentTime == rhs.desiredPresentTime ); + } + + bool operator!=( PresentTimeGOOGLE const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t presentID; + uint64_t desiredPresentTime; + }; + static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); + + struct ViewportWScalingNV + { + ViewportWScalingNV( float xcoeff_ = 0, + float ycoeff_ = 0 ) + : xcoeff( xcoeff_ ) + , ycoeff( ycoeff_ ) + { + } + + ViewportWScalingNV( VkViewportWScalingNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); + } + + ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); + return *this; + } + ViewportWScalingNV& setXcoeff( float xcoeff_ ) + { + xcoeff = xcoeff_; + return *this; + } + + ViewportWScalingNV& setYcoeff( float ycoeff_ ) + { + ycoeff = ycoeff_; + return *this; + } + + operator const VkViewportWScalingNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ViewportWScalingNV const& rhs ) const + { + return ( xcoeff == rhs.xcoeff ) + && ( ycoeff == rhs.ycoeff ); + } + + bool operator!=( ViewportWScalingNV const& rhs ) const + { + return !operator==( rhs ); + } + + float xcoeff; + float ycoeff; + }; + static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); + + struct SampleLocationEXT + { + SampleLocationEXT( float x_ = 0, + float y_ = 0 ) + : x( x_ ) + , y( y_ ) + { + } + + SampleLocationEXT( VkSampleLocationEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SampleLocationEXT ) ); + } + + SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SampleLocationEXT ) ); + return *this; + } + SampleLocationEXT& setX( float x_ ) + { + x = x_; + return *this; + } + + SampleLocationEXT& setY( float y_ ) + { + y = y_; + return *this; + } + + operator const VkSampleLocationEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SampleLocationEXT const& rhs ) const + { + return ( x == rhs.x ) + && ( y == rhs.y ); + } + + bool operator!=( SampleLocationEXT const& rhs ) const + { + return !operator==( rhs ); + } + + float x; + float y; + }; + static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); + + struct ShaderResourceUsageAMD + { + operator const VkShaderResourceUsageAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ShaderResourceUsageAMD const& rhs ) const + { + return ( numUsedVgprs == rhs.numUsedVgprs ) + && ( numUsedSgprs == rhs.numUsedSgprs ) + && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) + && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) + && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); + } + + bool operator!=( ShaderResourceUsageAMD const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; + }; + static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" ); + + struct VertexInputBindingDivisorDescriptionEXT + { + VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0, + uint32_t divisor_ = 0 ) + : binding( binding_ ) + , divisor( divisor_ ) + { + } + + VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) ); + } + + VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) ); + return *this; + } + VertexInputBindingDivisorDescriptionEXT& setBinding( uint32_t binding_ ) + { + binding = binding_; + return *this; + } + + VertexInputBindingDivisorDescriptionEXT& setDivisor( uint32_t divisor_ ) + { + divisor = divisor_; + return *this; + } + + operator const VkVertexInputBindingDivisorDescriptionEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( VertexInputBindingDivisorDescriptionEXT const& rhs ) const + { + return ( binding == rhs.binding ) + && ( divisor == rhs.divisor ); + } + + bool operator!=( VertexInputBindingDivisorDescriptionEXT const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t binding; + uint32_t divisor; + }; + static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" ); + + enum class ImageLayout + { + eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, + eGeneral = VK_IMAGE_LAYOUT_GENERAL, + eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, + eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED, + eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR + }; + + struct DescriptorImageInfo + { + DescriptorImageInfo( Sampler sampler_ = Sampler(), + ImageView imageView_ = ImageView(), + ImageLayout imageLayout_ = ImageLayout::eUndefined ) + : sampler( sampler_ ) + , imageView( imageView_ ) + , imageLayout( imageLayout_ ) + { + } + + DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); + } + + DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); + return *this; + } + DescriptorImageInfo& setSampler( Sampler sampler_ ) + { + sampler = sampler_; + return *this; + } + + DescriptorImageInfo& setImageView( ImageView imageView_ ) + { + imageView = imageView_; + return *this; + } + + DescriptorImageInfo& setImageLayout( ImageLayout imageLayout_ ) + { + imageLayout = imageLayout_; + return *this; + } + + operator const VkDescriptorImageInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorImageInfo const& rhs ) const + { + return ( sampler == rhs.sampler ) + && ( imageView == rhs.imageView ) + && ( imageLayout == rhs.imageLayout ); + } + + bool operator!=( DescriptorImageInfo const& rhs ) const + { + return !operator==( rhs ); + } + + Sampler sampler; + ImageView imageView; + ImageLayout imageLayout; + }; + static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" ); + + struct AttachmentReference + { + AttachmentReference( uint32_t attachment_ = 0, + ImageLayout layout_ = ImageLayout::eUndefined ) + : attachment( attachment_ ) + , layout( layout_ ) + { + } + + AttachmentReference( VkAttachmentReference const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentReference ) ); + } + + AttachmentReference& operator=( VkAttachmentReference const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentReference ) ); + return *this; + } + AttachmentReference& setAttachment( uint32_t attachment_ ) + { + attachment = attachment_; + return *this; + } + + AttachmentReference& setLayout( ImageLayout layout_ ) + { + layout = layout_; + return *this; + } + + operator const VkAttachmentReference&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AttachmentReference const& rhs ) const + { + return ( attachment == rhs.attachment ) + && ( layout == rhs.layout ); + } + + bool operator!=( AttachmentReference const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t attachment; + ImageLayout layout; + }; + static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); + + enum class AttachmentLoadOp + { + eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, + eClear = VK_ATTACHMENT_LOAD_OP_CLEAR, + eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE + }; + + enum class AttachmentStoreOp + { + eStore = VK_ATTACHMENT_STORE_OP_STORE, + eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE + }; + + enum class ImageType + { + e1D = VK_IMAGE_TYPE_1D, + e2D = VK_IMAGE_TYPE_2D, + e3D = VK_IMAGE_TYPE_3D + }; + + enum class ImageTiling + { + eOptimal = VK_IMAGE_TILING_OPTIMAL, + eLinear = VK_IMAGE_TILING_LINEAR + }; + + enum class ImageViewType + { + e1D = VK_IMAGE_VIEW_TYPE_1D, + e2D = VK_IMAGE_VIEW_TYPE_2D, + e3D = VK_IMAGE_VIEW_TYPE_3D, + eCube = VK_IMAGE_VIEW_TYPE_CUBE, + e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY, + e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY, + eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY + }; + + enum class CommandBufferLevel + { + ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY + }; + + enum class ComponentSwizzle + { + eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY, + eZero = VK_COMPONENT_SWIZZLE_ZERO, + eOne = VK_COMPONENT_SWIZZLE_ONE, + eR = VK_COMPONENT_SWIZZLE_R, + eG = VK_COMPONENT_SWIZZLE_G, + eB = VK_COMPONENT_SWIZZLE_B, + eA = VK_COMPONENT_SWIZZLE_A + }; + + struct ComponentMapping + { + ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity, + ComponentSwizzle g_ = ComponentSwizzle::eIdentity, + ComponentSwizzle b_ = ComponentSwizzle::eIdentity, + ComponentSwizzle a_ = ComponentSwizzle::eIdentity ) + : r( r_ ) + , g( g_ ) + , b( b_ ) + , a( a_ ) + { + } + + ComponentMapping( VkComponentMapping const & rhs ) + { + memcpy( this, &rhs, sizeof( ComponentMapping ) ); + } + + ComponentMapping& operator=( VkComponentMapping const & rhs ) + { + memcpy( this, &rhs, sizeof( ComponentMapping ) ); + return *this; + } + ComponentMapping& setR( ComponentSwizzle r_ ) + { + r = r_; + return *this; + } + + ComponentMapping& setG( ComponentSwizzle g_ ) + { + g = g_; + return *this; + } + + ComponentMapping& setB( ComponentSwizzle b_ ) + { + b = b_; + return *this; + } + + ComponentMapping& setA( ComponentSwizzle a_ ) + { + a = a_; + return *this; + } + + operator const VkComponentMapping&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ComponentMapping const& rhs ) const + { + return ( r == rhs.r ) + && ( g == rhs.g ) + && ( b == rhs.b ) + && ( a == rhs.a ); + } + + bool operator!=( ComponentMapping const& rhs ) const + { + return !operator==( rhs ); + } + + ComponentSwizzle r; + ComponentSwizzle g; + ComponentSwizzle b; + ComponentSwizzle a; + }; + static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" ); + + enum class DescriptorType + { + eSampler = VK_DESCRIPTOR_TYPE_SAMPLER, + eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, + eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, + eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, + eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, + eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, + eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, + eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, + eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, + eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT + }; + + struct DescriptorPoolSize + { + DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, + uint32_t descriptorCount_ = 0 ) + : type( type_ ) + , descriptorCount( descriptorCount_ ) + { + } + + DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); + } + + DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); + return *this; + } + DescriptorPoolSize& setType( DescriptorType type_ ) + { + type = type_; + return *this; + } + + DescriptorPoolSize& setDescriptorCount( uint32_t descriptorCount_ ) + { + descriptorCount = descriptorCount_; + return *this; + } + + operator const VkDescriptorPoolSize&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorPoolSize const& rhs ) const + { + return ( type == rhs.type ) + && ( descriptorCount == rhs.descriptorCount ); + } + + bool operator!=( DescriptorPoolSize const& rhs ) const + { + return !operator==( rhs ); + } + + DescriptorType type; + uint32_t descriptorCount; + }; + static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); + + struct DescriptorUpdateTemplateEntry + { + DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0, + uint32_t dstArrayElement_ = 0, + uint32_t descriptorCount_ = 0, + DescriptorType descriptorType_ = DescriptorType::eSampler, + size_t offset_ = 0, + size_t stride_ = 0 ) + : dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( descriptorCount_ ) + , descriptorType( descriptorType_ ) + , offset( offset_ ) + , stride( stride_ ) + { + } + + DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) ); + } + + DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) ); + return *this; + } + DescriptorUpdateTemplateEntry& setDstBinding( uint32_t dstBinding_ ) + { + dstBinding = dstBinding_; + return *this; + } + + DescriptorUpdateTemplateEntry& setDstArrayElement( uint32_t dstArrayElement_ ) + { + dstArrayElement = dstArrayElement_; + return *this; + } + + DescriptorUpdateTemplateEntry& setDescriptorCount( uint32_t descriptorCount_ ) + { + descriptorCount = descriptorCount_; + return *this; + } + + DescriptorUpdateTemplateEntry& setDescriptorType( DescriptorType descriptorType_ ) + { + descriptorType = descriptorType_; + return *this; + } + + DescriptorUpdateTemplateEntry& setOffset( size_t offset_ ) + { + offset = offset_; + return *this; + } + + DescriptorUpdateTemplateEntry& setStride( size_t stride_ ) + { + stride = stride_; + return *this; + } + + operator const VkDescriptorUpdateTemplateEntry&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const + { + return ( dstBinding == rhs.dstBinding ) + && ( dstArrayElement == rhs.dstArrayElement ) + && ( descriptorCount == rhs.descriptorCount ) + && ( descriptorType == rhs.descriptorType ) + && ( offset == rhs.offset ) + && ( stride == rhs.stride ); + } + + bool operator!=( DescriptorUpdateTemplateEntry const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + DescriptorType descriptorType; + size_t offset; + size_t stride; + }; + static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" ); + + using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; + + enum class QueryType + { + eOcclusion = VK_QUERY_TYPE_OCCLUSION, + ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, + eTimestamp = VK_QUERY_TYPE_TIMESTAMP + }; + + enum class BorderColor + { + eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, + eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, + eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK, + eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, + eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE + }; + + enum class PipelineBindPoint + { + eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, + eCompute = VK_PIPELINE_BIND_POINT_COMPUTE + }; + + enum class PipelineCacheHeaderVersion + { + eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE + }; + + enum class PrimitiveTopology + { + ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, + eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, + eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, + eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, + eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, + eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, + eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, + eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, + ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST + }; + + enum class SharingMode + { + eExclusive = VK_SHARING_MODE_EXCLUSIVE, + eConcurrent = VK_SHARING_MODE_CONCURRENT + }; + + enum class IndexType + { + eUint16 = VK_INDEX_TYPE_UINT16, + eUint32 = VK_INDEX_TYPE_UINT32 + }; + + enum class Filter + { + eNearest = VK_FILTER_NEAREST, + eLinear = VK_FILTER_LINEAR, + eCubicIMG = VK_FILTER_CUBIC_IMG + }; + + enum class SamplerMipmapMode + { + eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, + eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR + }; + + enum class SamplerAddressMode + { + eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT, + eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, + eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, + eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE + }; + + enum class CompareOp + { + eNever = VK_COMPARE_OP_NEVER, + eLess = VK_COMPARE_OP_LESS, + eEqual = VK_COMPARE_OP_EQUAL, + eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL, + eGreater = VK_COMPARE_OP_GREATER, + eNotEqual = VK_COMPARE_OP_NOT_EQUAL, + eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL, + eAlways = VK_COMPARE_OP_ALWAYS + }; + + enum class PolygonMode + { + eFill = VK_POLYGON_MODE_FILL, + eLine = VK_POLYGON_MODE_LINE, + ePoint = VK_POLYGON_MODE_POINT, + eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV + }; + + enum class CullModeFlagBits + { + eNone = VK_CULL_MODE_NONE, + eFront = VK_CULL_MODE_FRONT_BIT, + eBack = VK_CULL_MODE_BACK_BIT, + eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK + }; + + using CullModeFlags = Flags; + + VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 ) + { + return CullModeFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits ) + { + return ~( CullModeFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CullModeFlagBits::eNone) | VkFlags(CullModeFlagBits::eFront) | VkFlags(CullModeFlagBits::eBack) | VkFlags(CullModeFlagBits::eFrontAndBack) + }; + }; + + enum class FrontFace + { + eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE, + eClockwise = VK_FRONT_FACE_CLOCKWISE + }; + + enum class BlendFactor + { + eZero = VK_BLEND_FACTOR_ZERO, + eOne = VK_BLEND_FACTOR_ONE, + eSrcColor = VK_BLEND_FACTOR_SRC_COLOR, + eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, + eDstColor = VK_BLEND_FACTOR_DST_COLOR, + eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, + eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA, + eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA, + eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, + eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR, + eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, + eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA, + eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, + eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, + eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR, + eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, + eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA, + eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA + }; + + enum class BlendOp + { + eAdd = VK_BLEND_OP_ADD, + eSubtract = VK_BLEND_OP_SUBTRACT, + eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT, + eMin = VK_BLEND_OP_MIN, + eMax = VK_BLEND_OP_MAX, + eZeroEXT = VK_BLEND_OP_ZERO_EXT, + eSrcEXT = VK_BLEND_OP_SRC_EXT, + eDstEXT = VK_BLEND_OP_DST_EXT, + eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT, + eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT, + eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT, + eDstInEXT = VK_BLEND_OP_DST_IN_EXT, + eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT, + eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT, + eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT, + eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT, + eXorEXT = VK_BLEND_OP_XOR_EXT, + eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT, + eScreenEXT = VK_BLEND_OP_SCREEN_EXT, + eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT, + eDarkenEXT = VK_BLEND_OP_DARKEN_EXT, + eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT, + eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT, + eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT, + eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT, + eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT, + eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT, + eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT, + eInvertEXT = VK_BLEND_OP_INVERT_EXT, + eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT, + eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT, + eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT, + eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT, + eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT, + ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT, + eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT, + eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT, + eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT, + eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT, + eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT, + ePlusEXT = VK_BLEND_OP_PLUS_EXT, + ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT, + ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, + ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT, + eMinusEXT = VK_BLEND_OP_MINUS_EXT, + eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT, + eContrastEXT = VK_BLEND_OP_CONTRAST_EXT, + eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT, + eRedEXT = VK_BLEND_OP_RED_EXT, + eGreenEXT = VK_BLEND_OP_GREEN_EXT, + eBlueEXT = VK_BLEND_OP_BLUE_EXT + }; + + enum class StencilOp + { + eKeep = VK_STENCIL_OP_KEEP, + eZero = VK_STENCIL_OP_ZERO, + eReplace = VK_STENCIL_OP_REPLACE, + eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP, + eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP, + eInvert = VK_STENCIL_OP_INVERT, + eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP, + eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP + }; + + struct StencilOpState + { + StencilOpState( StencilOp failOp_ = StencilOp::eKeep, + StencilOp passOp_ = StencilOp::eKeep, + StencilOp depthFailOp_ = StencilOp::eKeep, + CompareOp compareOp_ = CompareOp::eNever, + uint32_t compareMask_ = 0, + uint32_t writeMask_ = 0, + uint32_t reference_ = 0 ) + : failOp( failOp_ ) + , passOp( passOp_ ) + , depthFailOp( depthFailOp_ ) + , compareOp( compareOp_ ) + , compareMask( compareMask_ ) + , writeMask( writeMask_ ) + , reference( reference_ ) + { + } + + StencilOpState( VkStencilOpState const & rhs ) + { + memcpy( this, &rhs, sizeof( StencilOpState ) ); + } + + StencilOpState& operator=( VkStencilOpState const & rhs ) + { + memcpy( this, &rhs, sizeof( StencilOpState ) ); + return *this; + } + StencilOpState& setFailOp( StencilOp failOp_ ) + { + failOp = failOp_; + return *this; + } + + StencilOpState& setPassOp( StencilOp passOp_ ) + { + passOp = passOp_; + return *this; + } + + StencilOpState& setDepthFailOp( StencilOp depthFailOp_ ) + { + depthFailOp = depthFailOp_; + return *this; + } + + StencilOpState& setCompareOp( CompareOp compareOp_ ) + { + compareOp = compareOp_; + return *this; + } + + StencilOpState& setCompareMask( uint32_t compareMask_ ) + { + compareMask = compareMask_; + return *this; + } + + StencilOpState& setWriteMask( uint32_t writeMask_ ) + { + writeMask = writeMask_; + return *this; + } + + StencilOpState& setReference( uint32_t reference_ ) + { + reference = reference_; + return *this; + } + + operator const VkStencilOpState&() const + { + return *reinterpret_cast(this); + } + + bool operator==( StencilOpState const& rhs ) const + { + return ( failOp == rhs.failOp ) + && ( passOp == rhs.passOp ) + && ( depthFailOp == rhs.depthFailOp ) + && ( compareOp == rhs.compareOp ) + && ( compareMask == rhs.compareMask ) + && ( writeMask == rhs.writeMask ) + && ( reference == rhs.reference ); + } + + bool operator!=( StencilOpState const& rhs ) const + { + return !operator==( rhs ); + } + + StencilOp failOp; + StencilOp passOp; + StencilOp depthFailOp; + CompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; + }; + static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); + + enum class LogicOp + { + eClear = VK_LOGIC_OP_CLEAR, + eAnd = VK_LOGIC_OP_AND, + eAndReverse = VK_LOGIC_OP_AND_REVERSE, + eCopy = VK_LOGIC_OP_COPY, + eAndInverted = VK_LOGIC_OP_AND_INVERTED, + eNoOp = VK_LOGIC_OP_NO_OP, + eXor = VK_LOGIC_OP_XOR, + eOr = VK_LOGIC_OP_OR, + eNor = VK_LOGIC_OP_NOR, + eEquivalent = VK_LOGIC_OP_EQUIVALENT, + eInvert = VK_LOGIC_OP_INVERT, + eOrReverse = VK_LOGIC_OP_OR_REVERSE, + eCopyInverted = VK_LOGIC_OP_COPY_INVERTED, + eOrInverted = VK_LOGIC_OP_OR_INVERTED, + eNand = VK_LOGIC_OP_NAND, + eSet = VK_LOGIC_OP_SET + }; + + enum class InternalAllocationType + { + eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + }; + + enum class SystemAllocationScope + { + eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, + eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, + eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE, + eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, + eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE + }; + + enum class PhysicalDeviceType + { + eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER, + eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, + eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, + eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, + eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU + }; + + enum class VertexInputRate + { + eVertex = VK_VERTEX_INPUT_RATE_VERTEX, + eInstance = VK_VERTEX_INPUT_RATE_INSTANCE + }; + + struct VertexInputBindingDescription + { + VertexInputBindingDescription( uint32_t binding_ = 0, + uint32_t stride_ = 0, + VertexInputRate inputRate_ = VertexInputRate::eVertex ) + : binding( binding_ ) + , stride( stride_ ) + , inputRate( inputRate_ ) + { + } + + VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); + } + + VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); + return *this; + } + VertexInputBindingDescription& setBinding( uint32_t binding_ ) + { + binding = binding_; + return *this; + } + + VertexInputBindingDescription& setStride( uint32_t stride_ ) + { + stride = stride_; + return *this; + } + + VertexInputBindingDescription& setInputRate( VertexInputRate inputRate_ ) + { + inputRate = inputRate_; + return *this; + } + + operator const VkVertexInputBindingDescription&() const + { + return *reinterpret_cast(this); + } + + bool operator==( VertexInputBindingDescription const& rhs ) const + { + return ( binding == rhs.binding ) + && ( stride == rhs.stride ) + && ( inputRate == rhs.inputRate ); + } + + bool operator!=( VertexInputBindingDescription const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t binding; + uint32_t stride; + VertexInputRate inputRate; + }; + static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" ); + + enum class Format + { + eUndefined = VK_FORMAT_UNDEFINED, + eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8, + eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, + eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, + eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16, + eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16, + eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, + eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, + eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, + eR8Unorm = VK_FORMAT_R8_UNORM, + eR8Snorm = VK_FORMAT_R8_SNORM, + eR8Uscaled = VK_FORMAT_R8_USCALED, + eR8Sscaled = VK_FORMAT_R8_SSCALED, + eR8Uint = VK_FORMAT_R8_UINT, + eR8Sint = VK_FORMAT_R8_SINT, + eR8Srgb = VK_FORMAT_R8_SRGB, + eR8G8Unorm = VK_FORMAT_R8G8_UNORM, + eR8G8Snorm = VK_FORMAT_R8G8_SNORM, + eR8G8Uscaled = VK_FORMAT_R8G8_USCALED, + eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED, + eR8G8Uint = VK_FORMAT_R8G8_UINT, + eR8G8Sint = VK_FORMAT_R8G8_SINT, + eR8G8Srgb = VK_FORMAT_R8G8_SRGB, + eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM, + eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM, + eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED, + eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED, + eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT, + eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT, + eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB, + eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM, + eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM, + eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED, + eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED, + eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT, + eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT, + eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB, + eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM, + eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM, + eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED, + eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED, + eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT, + eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT, + eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB, + eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM, + eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM, + eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED, + eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED, + eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT, + eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT, + eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB, + eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, + eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, + eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, + eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, + eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, + eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, + eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, + eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, + eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32, + eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32, + eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, + eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, + eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, + eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, + eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32, + eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32, + eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, + eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, + eR16Unorm = VK_FORMAT_R16_UNORM, + eR16Snorm = VK_FORMAT_R16_SNORM, + eR16Uscaled = VK_FORMAT_R16_USCALED, + eR16Sscaled = VK_FORMAT_R16_SSCALED, + eR16Uint = VK_FORMAT_R16_UINT, + eR16Sint = VK_FORMAT_R16_SINT, + eR16Sfloat = VK_FORMAT_R16_SFLOAT, + eR16G16Unorm = VK_FORMAT_R16G16_UNORM, + eR16G16Snorm = VK_FORMAT_R16G16_SNORM, + eR16G16Uscaled = VK_FORMAT_R16G16_USCALED, + eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED, + eR16G16Uint = VK_FORMAT_R16G16_UINT, + eR16G16Sint = VK_FORMAT_R16G16_SINT, + eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT, + eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM, + eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM, + eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED, + eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED, + eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT, + eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT, + eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT, + eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM, + eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM, + eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED, + eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED, + eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT, + eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT, + eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT, + eR32Uint = VK_FORMAT_R32_UINT, + eR32Sint = VK_FORMAT_R32_SINT, + eR32Sfloat = VK_FORMAT_R32_SFLOAT, + eR32G32Uint = VK_FORMAT_R32G32_UINT, + eR32G32Sint = VK_FORMAT_R32G32_SINT, + eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT, + eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT, + eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT, + eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT, + eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT, + eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT, + eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT, + eR64Uint = VK_FORMAT_R64_UINT, + eR64Sint = VK_FORMAT_R64_SINT, + eR64Sfloat = VK_FORMAT_R64_SFLOAT, + eR64G64Uint = VK_FORMAT_R64G64_UINT, + eR64G64Sint = VK_FORMAT_R64G64_SINT, + eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT, + eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT, + eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT, + eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT, + eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT, + eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT, + eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT, + eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, + eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + eD16Unorm = VK_FORMAT_D16_UNORM, + eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32, + eD32Sfloat = VK_FORMAT_D32_SFLOAT, + eS8Uint = VK_FORMAT_S8_UINT, + eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT, + eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT, + eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT, + eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK, + eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK, + eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK, + eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK, + eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK, + eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK, + eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK, + eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK, + eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK, + eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK, + eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK, + eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK, + eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK, + eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK, + eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK, + eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK, + eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM, + eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM, + eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM, + eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM, + eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16, + eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16, + eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16, + eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16, + eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM, + eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM, + eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM, + eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM, + eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, + ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, + ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, + ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, + ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, + ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, + ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, + ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG + }; + + struct VertexInputAttributeDescription + { + VertexInputAttributeDescription( uint32_t location_ = 0, + uint32_t binding_ = 0, + Format format_ = Format::eUndefined, + uint32_t offset_ = 0 ) + : location( location_ ) + , binding( binding_ ) + , format( format_ ) + , offset( offset_ ) + { + } + + VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); + } + + VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); + return *this; + } + VertexInputAttributeDescription& setLocation( uint32_t location_ ) + { + location = location_; + return *this; + } + + VertexInputAttributeDescription& setBinding( uint32_t binding_ ) + { + binding = binding_; + return *this; + } + + VertexInputAttributeDescription& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + VertexInputAttributeDescription& setOffset( uint32_t offset_ ) + { + offset = offset_; + return *this; + } + + operator const VkVertexInputAttributeDescription&() const + { + return *reinterpret_cast(this); + } + + bool operator==( VertexInputAttributeDescription const& rhs ) const + { + return ( location == rhs.location ) + && ( binding == rhs.binding ) + && ( format == rhs.format ) + && ( offset == rhs.offset ); + } + + bool operator!=( VertexInputAttributeDescription const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t location; + uint32_t binding; + Format format; + uint32_t offset; + }; + static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" ); + + enum class StructureType + { + eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO, + eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO, + eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, + eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, + eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, + eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, + eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, + eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, + eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, + ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, + ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, + ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, + ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, + ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, + eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, + eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, + eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, + eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, + eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, + eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, + eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, + eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, + eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER, + eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, + eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, + ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, + eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, + ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, + ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, + eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, + eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, + eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, + ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, + eDeviceGroupPresentCapabilitiesKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, + eImageSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, + eBindImageMemorySwapchainInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, + eAcquireNextImageInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, + eDeviceGroupPresentInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, + eDeviceGroupSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, + eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, + eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, + eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, + eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, + eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, + eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, + eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR, + eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, + eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, + eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, + eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, + eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, + eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, + eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, + eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, + eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, + eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, + eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, + eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, + eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, + eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, + eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, + eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, + eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, + eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, + eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, + eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, + eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, + eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, + eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, + eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, + eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, + eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, + eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, + ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, + ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, + eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, + eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, + eCmdProcessCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX, + eCmdReserveSpaceForCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX, + eDeviceGeneratedCommandsLimitsNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX, + eDeviceGeneratedCommandsFeaturesNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX, + ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, + eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, + eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, + eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, + eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, + ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, + ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, + ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, + ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, + ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, + ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, + ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, + eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, + eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, + eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, + eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, + eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, + ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, + eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, + eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, + eDisplayProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, + eDisplayPlaneProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR, + eDisplayModeProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, + eDisplayPlaneInfo2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, + eDisplayPlaneCapabilities2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, + eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, + eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, + eDebugUtilsObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, + eDebugUtilsObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT, + eDebugUtilsLabelEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, + eDebugUtilsMessengerCallbackDataEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, + eDebugUtilsMessengerCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, + eAndroidHardwareBufferUsageANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, + eAndroidHardwareBufferPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, + eAndroidHardwareBufferFormatPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, + eImportAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + eMemoryGetAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, + ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, + eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, + eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, + eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, + ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, + ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, + eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, + eImageFormatListCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR, + ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, + ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, + ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, + ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, + ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, + eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, + eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, + eDescriptorSetLayoutBindingFlagsCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, + ePhysicalDeviceDescriptorIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, + ePhysicalDeviceDescriptorIndexingPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, + eDescriptorSetVariableDescriptorCountAllocateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, + eDescriptorSetVariableDescriptorCountLayoutSupportEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, + eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, + eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, + eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, + ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, + ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, + ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, + ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT + }; + + struct ApplicationInfo + { + ApplicationInfo( const char* pApplicationName_ = nullptr, + uint32_t applicationVersion_ = 0, + const char* pEngineName_ = nullptr, + uint32_t engineVersion_ = 0, + uint32_t apiVersion_ = 0 ) + : pApplicationName( pApplicationName_ ) + , applicationVersion( applicationVersion_ ) + , pEngineName( pEngineName_ ) + , engineVersion( engineVersion_ ) + , apiVersion( apiVersion_ ) + { + } + + ApplicationInfo( VkApplicationInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ApplicationInfo ) ); + } + + ApplicationInfo& operator=( VkApplicationInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ApplicationInfo ) ); + return *this; + } + ApplicationInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ApplicationInfo& setPApplicationName( const char* pApplicationName_ ) + { + pApplicationName = pApplicationName_; + return *this; + } + + ApplicationInfo& setApplicationVersion( uint32_t applicationVersion_ ) + { + applicationVersion = applicationVersion_; + return *this; + } + + ApplicationInfo& setPEngineName( const char* pEngineName_ ) + { + pEngineName = pEngineName_; + return *this; + } + + ApplicationInfo& setEngineVersion( uint32_t engineVersion_ ) + { + engineVersion = engineVersion_; + return *this; + } + + ApplicationInfo& setApiVersion( uint32_t apiVersion_ ) + { + apiVersion = apiVersion_; + return *this; + } + + operator const VkApplicationInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ApplicationInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pApplicationName == rhs.pApplicationName ) + && ( applicationVersion == rhs.applicationVersion ) + && ( pEngineName == rhs.pEngineName ) + && ( engineVersion == rhs.engineVersion ) + && ( apiVersion == rhs.apiVersion ); + } + + bool operator!=( ApplicationInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eApplicationInfo; + + public: + const void* pNext = nullptr; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; + }; + static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); + + struct InstanceCreateInfo + { + InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(), + const ApplicationInfo* pApplicationInfo_ = nullptr, + uint32_t enabledLayerCount_ = 0, + const char* const* ppEnabledLayerNames_ = nullptr, + uint32_t enabledExtensionCount_ = 0, + const char* const* ppEnabledExtensionNames_ = nullptr ) + : flags( flags_ ) + , pApplicationInfo( pApplicationInfo_ ) + , enabledLayerCount( enabledLayerCount_ ) + , ppEnabledLayerNames( ppEnabledLayerNames_ ) + , enabledExtensionCount( enabledExtensionCount_ ) + , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) + { + } + + InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); + } + + InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); + return *this; + } + InstanceCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + InstanceCreateInfo& setFlags( InstanceCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + InstanceCreateInfo& setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ ) + { + pApplicationInfo = pApplicationInfo_; + return *this; + } + + InstanceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ ) + { + enabledLayerCount = enabledLayerCount_; + return *this; + } + + InstanceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ ) + { + ppEnabledLayerNames = ppEnabledLayerNames_; + return *this; + } + + InstanceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) + { + enabledExtensionCount = enabledExtensionCount_; + return *this; + } + + InstanceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ ) + { + ppEnabledExtensionNames = ppEnabledExtensionNames_; + return *this; + } + + operator const VkInstanceCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( InstanceCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( pApplicationInfo == rhs.pApplicationInfo ) + && ( enabledLayerCount == rhs.enabledLayerCount ) + && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) + && ( enabledExtensionCount == rhs.enabledExtensionCount ) + && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ); + } + + bool operator!=( InstanceCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eInstanceCreateInfo; + + public: + const void* pNext = nullptr; + InstanceCreateFlags flags; + const ApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + }; + static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" ); + + struct MemoryAllocateInfo + { + MemoryAllocateInfo( DeviceSize allocationSize_ = 0, + uint32_t memoryTypeIndex_ = 0 ) + : allocationSize( allocationSize_ ) + , memoryTypeIndex( memoryTypeIndex_ ) + { + } + + MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); + } + + MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); + return *this; + } + MemoryAllocateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryAllocateInfo& setAllocationSize( DeviceSize allocationSize_ ) + { + allocationSize = allocationSize_; + return *this; + } + + MemoryAllocateInfo& setMemoryTypeIndex( uint32_t memoryTypeIndex_ ) + { + memoryTypeIndex = memoryTypeIndex_; + return *this; + } + + operator const VkMemoryAllocateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryAllocateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( allocationSize == rhs.allocationSize ) + && ( memoryTypeIndex == rhs.memoryTypeIndex ); + } + + bool operator!=( MemoryAllocateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryAllocateInfo; + + public: + const void* pNext = nullptr; + DeviceSize allocationSize; + uint32_t memoryTypeIndex; + }; + static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); + + struct MappedMemoryRange + { + MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), + DeviceSize offset_ = 0, + DeviceSize size_ = 0 ) + : memory( memory_ ) + , offset( offset_ ) + , size( size_ ) + { + } + + MappedMemoryRange( VkMappedMemoryRange const & rhs ) + { + memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); + } + + MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) + { + memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); + return *this; + } + MappedMemoryRange& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MappedMemoryRange& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + MappedMemoryRange& setOffset( DeviceSize offset_ ) + { + offset = offset_; + return *this; + } + + MappedMemoryRange& setSize( DeviceSize size_ ) + { + size = size_; + return *this; + } + + operator const VkMappedMemoryRange&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MappedMemoryRange const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ) + && ( offset == rhs.offset ) + && ( size == rhs.size ); + } + + bool operator!=( MappedMemoryRange const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMappedMemoryRange; + + public: + const void* pNext = nullptr; + DeviceMemory memory; + DeviceSize offset; + DeviceSize size; + }; + static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); + + struct WriteDescriptorSet + { + WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(), + uint32_t dstBinding_ = 0, + uint32_t dstArrayElement_ = 0, + uint32_t descriptorCount_ = 0, + DescriptorType descriptorType_ = DescriptorType::eSampler, + const DescriptorImageInfo* pImageInfo_ = nullptr, + const DescriptorBufferInfo* pBufferInfo_ = nullptr, + const BufferView* pTexelBufferView_ = nullptr ) + : dstSet( dstSet_ ) + , dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( descriptorCount_ ) + , descriptorType( descriptorType_ ) + , pImageInfo( pImageInfo_ ) + , pBufferInfo( pBufferInfo_ ) + , pTexelBufferView( pTexelBufferView_ ) + { + } + + WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) + { + memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); + } + + WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) + { + memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); + return *this; + } + WriteDescriptorSet& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + WriteDescriptorSet& setDstSet( DescriptorSet dstSet_ ) + { + dstSet = dstSet_; + return *this; + } + + WriteDescriptorSet& setDstBinding( uint32_t dstBinding_ ) + { + dstBinding = dstBinding_; + return *this; + } + + WriteDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ ) + { + dstArrayElement = dstArrayElement_; + return *this; + } + + WriteDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ ) + { + descriptorCount = descriptorCount_; + return *this; + } + + WriteDescriptorSet& setDescriptorType( DescriptorType descriptorType_ ) + { + descriptorType = descriptorType_; + return *this; + } + + WriteDescriptorSet& setPImageInfo( const DescriptorImageInfo* pImageInfo_ ) + { + pImageInfo = pImageInfo_; + return *this; + } + + WriteDescriptorSet& setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ ) + { + pBufferInfo = pBufferInfo_; + return *this; + } + + WriteDescriptorSet& setPTexelBufferView( const BufferView* pTexelBufferView_ ) + { + pTexelBufferView = pTexelBufferView_; + return *this; + } + + operator const VkWriteDescriptorSet&() const + { + return *reinterpret_cast(this); + } + + bool operator==( WriteDescriptorSet const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( dstSet == rhs.dstSet ) + && ( dstBinding == rhs.dstBinding ) + && ( dstArrayElement == rhs.dstArrayElement ) + && ( descriptorCount == rhs.descriptorCount ) + && ( descriptorType == rhs.descriptorType ) + && ( pImageInfo == rhs.pImageInfo ) + && ( pBufferInfo == rhs.pBufferInfo ) + && ( pTexelBufferView == rhs.pTexelBufferView ); + } + + bool operator!=( WriteDescriptorSet const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eWriteDescriptorSet; + + public: + const void* pNext = nullptr; + DescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + DescriptorType descriptorType; + const DescriptorImageInfo* pImageInfo; + const DescriptorBufferInfo* pBufferInfo; + const BufferView* pTexelBufferView; + }; + static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); + + struct CopyDescriptorSet + { + CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(), + uint32_t srcBinding_ = 0, + uint32_t srcArrayElement_ = 0, + DescriptorSet dstSet_ = DescriptorSet(), + uint32_t dstBinding_ = 0, + uint32_t dstArrayElement_ = 0, + uint32_t descriptorCount_ = 0 ) + : srcSet( srcSet_ ) + , srcBinding( srcBinding_ ) + , srcArrayElement( srcArrayElement_ ) + , dstSet( dstSet_ ) + , dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( descriptorCount_ ) + { + } + + CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) + { + memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); + } + + CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) + { + memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); + return *this; + } + CopyDescriptorSet& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CopyDescriptorSet& setSrcSet( DescriptorSet srcSet_ ) + { + srcSet = srcSet_; + return *this; + } + + CopyDescriptorSet& setSrcBinding( uint32_t srcBinding_ ) + { + srcBinding = srcBinding_; + return *this; + } + + CopyDescriptorSet& setSrcArrayElement( uint32_t srcArrayElement_ ) + { + srcArrayElement = srcArrayElement_; + return *this; + } + + CopyDescriptorSet& setDstSet( DescriptorSet dstSet_ ) + { + dstSet = dstSet_; + return *this; + } + + CopyDescriptorSet& setDstBinding( uint32_t dstBinding_ ) + { + dstBinding = dstBinding_; + return *this; + } + + CopyDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ ) + { + dstArrayElement = dstArrayElement_; + return *this; + } + + CopyDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ ) + { + descriptorCount = descriptorCount_; + return *this; + } + + operator const VkCopyDescriptorSet&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CopyDescriptorSet const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcSet == rhs.srcSet ) + && ( srcBinding == rhs.srcBinding ) + && ( srcArrayElement == rhs.srcArrayElement ) + && ( dstSet == rhs.dstSet ) + && ( dstBinding == rhs.dstBinding ) + && ( dstArrayElement == rhs.dstArrayElement ) + && ( descriptorCount == rhs.descriptorCount ); + } + + bool operator!=( CopyDescriptorSet const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCopyDescriptorSet; + + public: + const void* pNext = nullptr; + DescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + DescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + }; + static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" ); + + struct BufferViewCreateInfo + { + BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), + Buffer buffer_ = Buffer(), + Format format_ = Format::eUndefined, + DeviceSize offset_ = 0, + DeviceSize range_ = 0 ) + : flags( flags_ ) + , buffer( buffer_ ) + , format( format_ ) + , offset( offset_ ) + , range( range_ ) + { + } + + BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); + } + + BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); + return *this; + } + BufferViewCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BufferViewCreateInfo& setFlags( BufferViewCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + BufferViewCreateInfo& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + BufferViewCreateInfo& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + BufferViewCreateInfo& setOffset( DeviceSize offset_ ) + { + offset = offset_; + return *this; + } + + BufferViewCreateInfo& setRange( DeviceSize range_ ) + { + range = range_; + return *this; + } + + operator const VkBufferViewCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferViewCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( buffer == rhs.buffer ) + && ( format == rhs.format ) + && ( offset == rhs.offset ) + && ( range == rhs.range ); + } + + bool operator!=( BufferViewCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBufferViewCreateInfo; + + public: + const void* pNext = nullptr; + BufferViewCreateFlags flags; + Buffer buffer; + Format format; + DeviceSize offset; + DeviceSize range; + }; + static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); + + struct ShaderModuleCreateInfo + { + ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), + size_t codeSize_ = 0, + const uint32_t* pCode_ = nullptr ) + : flags( flags_ ) + , codeSize( codeSize_ ) + , pCode( pCode_ ) + { + } + + ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); + } + + ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); + return *this; + } + ShaderModuleCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ShaderModuleCreateInfo& setFlags( ShaderModuleCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + ShaderModuleCreateInfo& setCodeSize( size_t codeSize_ ) + { + codeSize = codeSize_; + return *this; + } + + ShaderModuleCreateInfo& setPCode( const uint32_t* pCode_ ) + { + pCode = pCode_; + return *this; + } + + operator const VkShaderModuleCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ShaderModuleCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( codeSize == rhs.codeSize ) + && ( pCode == rhs.pCode ); + } + + bool operator!=( ShaderModuleCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eShaderModuleCreateInfo; + + public: + const void* pNext = nullptr; + ShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; + }; + static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" ); + + struct DescriptorSetAllocateInfo + { + DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), + uint32_t descriptorSetCount_ = 0, + const DescriptorSetLayout* pSetLayouts_ = nullptr ) + : descriptorPool( descriptorPool_ ) + , descriptorSetCount( descriptorSetCount_ ) + , pSetLayouts( pSetLayouts_ ) + { + } + + DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); + } + + DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); + return *this; + } + DescriptorSetAllocateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorSetAllocateInfo& setDescriptorPool( DescriptorPool descriptorPool_ ) + { + descriptorPool = descriptorPool_; + return *this; + } + + DescriptorSetAllocateInfo& setDescriptorSetCount( uint32_t descriptorSetCount_ ) + { + descriptorSetCount = descriptorSetCount_; + return *this; + } + + DescriptorSetAllocateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) + { + pSetLayouts = pSetLayouts_; + return *this; + } + + operator const VkDescriptorSetAllocateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetAllocateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( descriptorPool == rhs.descriptorPool ) + && ( descriptorSetCount == rhs.descriptorSetCount ) + && ( pSetLayouts == rhs.pSetLayouts ); + } + + bool operator!=( DescriptorSetAllocateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorSetAllocateInfo; + + public: + const void* pNext = nullptr; + DescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const DescriptorSetLayout* pSetLayouts; + }; + static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" ); + + struct PipelineVertexInputStateCreateInfo + { + PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), + uint32_t vertexBindingDescriptionCount_ = 0, + const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, + uint32_t vertexAttributeDescriptionCount_ = 0, + const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) + : flags( flags_ ) + , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) + , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) + , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) + , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ ) + { + } + + PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); + } + + PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); + return *this; + } + PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineVertexInputStateCreateInfo& setFlags( PipelineVertexInputStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineVertexInputStateCreateInfo& setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) + { + vertexBindingDescriptionCount = vertexBindingDescriptionCount_; + return *this; + } + + PipelineVertexInputStateCreateInfo& setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ ) + { + pVertexBindingDescriptions = pVertexBindingDescriptions_; + return *this; + } + + PipelineVertexInputStateCreateInfo& setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) + { + vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_; + return *this; + } + + PipelineVertexInputStateCreateInfo& setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ ) + { + pVertexAttributeDescriptions = pVertexAttributeDescriptions_; + return *this; + } + + operator const VkPipelineVertexInputStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) + && ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) + && ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) + && ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); + } + + bool operator!=( PipelineVertexInputStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VertexInputAttributeDescription* pVertexAttributeDescriptions; + }; + static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineInputAssemblyStateCreateInfo + { + PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), + PrimitiveTopology topology_ = PrimitiveTopology::ePointList, + Bool32 primitiveRestartEnable_ = 0 ) + : flags( flags_ ) + , topology( topology_ ) + , primitiveRestartEnable( primitiveRestartEnable_ ) + { + } + + PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); + } + + PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); + return *this; + } + PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineInputAssemblyStateCreateInfo& setFlags( PipelineInputAssemblyStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineInputAssemblyStateCreateInfo& setTopology( PrimitiveTopology topology_ ) + { + topology = topology_; + return *this; + } + + PipelineInputAssemblyStateCreateInfo& setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ ) + { + primitiveRestartEnable = primitiveRestartEnable_; + return *this; + } + + operator const VkPipelineInputAssemblyStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( topology == rhs.topology ) + && ( primitiveRestartEnable == rhs.primitiveRestartEnable ); + } + + bool operator!=( PipelineInputAssemblyStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineInputAssemblyStateCreateFlags flags; + PrimitiveTopology topology; + Bool32 primitiveRestartEnable; + }; + static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineTessellationStateCreateInfo + { + PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), + uint32_t patchControlPoints_ = 0 ) + : flags( flags_ ) + , patchControlPoints( patchControlPoints_ ) + { + } + + PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); + } + + PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); + return *this; + } + PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineTessellationStateCreateInfo& setFlags( PipelineTessellationStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineTessellationStateCreateInfo& setPatchControlPoints( uint32_t patchControlPoints_ ) + { + patchControlPoints = patchControlPoints_; + return *this; + } + + operator const VkPipelineTessellationStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( patchControlPoints == rhs.patchControlPoints ); + } + + bool operator!=( PipelineTessellationStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; + }; + static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineViewportStateCreateInfo + { + PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), + uint32_t viewportCount_ = 0, + const Viewport* pViewports_ = nullptr, + uint32_t scissorCount_ = 0, + const Rect2D* pScissors_ = nullptr ) + : flags( flags_ ) + , viewportCount( viewportCount_ ) + , pViewports( pViewports_ ) + , scissorCount( scissorCount_ ) + , pScissors( pScissors_ ) + { + } + + PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); + } + + PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); + return *this; + } + PipelineViewportStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineViewportStateCreateInfo& setFlags( PipelineViewportStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineViewportStateCreateInfo& setViewportCount( uint32_t viewportCount_ ) + { + viewportCount = viewportCount_; + return *this; + } + + PipelineViewportStateCreateInfo& setPViewports( const Viewport* pViewports_ ) + { + pViewports = pViewports_; + return *this; + } + + PipelineViewportStateCreateInfo& setScissorCount( uint32_t scissorCount_ ) + { + scissorCount = scissorCount_; + return *this; + } + + PipelineViewportStateCreateInfo& setPScissors( const Rect2D* pScissors_ ) + { + pScissors = pScissors_; + return *this; + } + + operator const VkPipelineViewportStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineViewportStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( viewportCount == rhs.viewportCount ) + && ( pViewports == rhs.pViewports ) + && ( scissorCount == rhs.scissorCount ) + && ( pScissors == rhs.pScissors ); + } + + bool operator!=( PipelineViewportStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineViewportStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const Viewport* pViewports; + uint32_t scissorCount; + const Rect2D* pScissors; + }; + static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineRasterizationStateCreateInfo + { + PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(), + Bool32 depthClampEnable_ = 0, + Bool32 rasterizerDiscardEnable_ = 0, + PolygonMode polygonMode_ = PolygonMode::eFill, + CullModeFlags cullMode_ = CullModeFlags(), + FrontFace frontFace_ = FrontFace::eCounterClockwise, + Bool32 depthBiasEnable_ = 0, + float depthBiasConstantFactor_ = 0, + float depthBiasClamp_ = 0, + float depthBiasSlopeFactor_ = 0, + float lineWidth_ = 0 ) + : flags( flags_ ) + , depthClampEnable( depthClampEnable_ ) + , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) + , polygonMode( polygonMode_ ) + , cullMode( cullMode_ ) + , frontFace( frontFace_ ) + , depthBiasEnable( depthBiasEnable_ ) + , depthBiasConstantFactor( depthBiasConstantFactor_ ) + , depthBiasClamp( depthBiasClamp_ ) + , depthBiasSlopeFactor( depthBiasSlopeFactor_ ) + , lineWidth( lineWidth_ ) + { + } + + PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); + } + + PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); + return *this; + } + PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setFlags( PipelineRasterizationStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setDepthClampEnable( Bool32 depthClampEnable_ ) + { + depthClampEnable = depthClampEnable_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ ) + { + rasterizerDiscardEnable = rasterizerDiscardEnable_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setPolygonMode( PolygonMode polygonMode_ ) + { + polygonMode = polygonMode_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setCullMode( CullModeFlags cullMode_ ) + { + cullMode = cullMode_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setFrontFace( FrontFace frontFace_ ) + { + frontFace = frontFace_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setDepthBiasEnable( Bool32 depthBiasEnable_ ) + { + depthBiasEnable = depthBiasEnable_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) + { + depthBiasConstantFactor = depthBiasConstantFactor_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setDepthBiasClamp( float depthBiasClamp_ ) + { + depthBiasClamp = depthBiasClamp_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) + { + depthBiasSlopeFactor = depthBiasSlopeFactor_; + return *this; + } + + PipelineRasterizationStateCreateInfo& setLineWidth( float lineWidth_ ) + { + lineWidth = lineWidth_; + return *this; + } + + operator const VkPipelineRasterizationStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( depthClampEnable == rhs.depthClampEnable ) + && ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) + && ( polygonMode == rhs.polygonMode ) + && ( cullMode == rhs.cullMode ) + && ( frontFace == rhs.frontFace ) + && ( depthBiasEnable == rhs.depthBiasEnable ) + && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) + && ( depthBiasClamp == rhs.depthBiasClamp ) + && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) + && ( lineWidth == rhs.lineWidth ); + } + + bool operator!=( PipelineRasterizationStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineRasterizationStateCreateFlags flags; + Bool32 depthClampEnable; + Bool32 rasterizerDiscardEnable; + PolygonMode polygonMode; + CullModeFlags cullMode; + FrontFace frontFace; + Bool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; + }; + static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineDepthStencilStateCreateInfo + { + PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(), + Bool32 depthTestEnable_ = 0, + Bool32 depthWriteEnable_ = 0, + CompareOp depthCompareOp_ = CompareOp::eNever, + Bool32 depthBoundsTestEnable_ = 0, + Bool32 stencilTestEnable_ = 0, + StencilOpState front_ = StencilOpState(), + StencilOpState back_ = StencilOpState(), + float minDepthBounds_ = 0, + float maxDepthBounds_ = 0 ) + : flags( flags_ ) + , depthTestEnable( depthTestEnable_ ) + , depthWriteEnable( depthWriteEnable_ ) + , depthCompareOp( depthCompareOp_ ) + , depthBoundsTestEnable( depthBoundsTestEnable_ ) + , stencilTestEnable( stencilTestEnable_ ) + , front( front_ ) + , back( back_ ) + , minDepthBounds( minDepthBounds_ ) + , maxDepthBounds( maxDepthBounds_ ) + { + } + + PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); + } + + PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); + return *this; + } + PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setFlags( PipelineDepthStencilStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setDepthTestEnable( Bool32 depthTestEnable_ ) + { + depthTestEnable = depthTestEnable_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setDepthWriteEnable( Bool32 depthWriteEnable_ ) + { + depthWriteEnable = depthWriteEnable_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setDepthCompareOp( CompareOp depthCompareOp_ ) + { + depthCompareOp = depthCompareOp_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ ) + { + depthBoundsTestEnable = depthBoundsTestEnable_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setStencilTestEnable( Bool32 stencilTestEnable_ ) + { + stencilTestEnable = stencilTestEnable_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setFront( StencilOpState front_ ) + { + front = front_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setBack( StencilOpState back_ ) + { + back = back_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setMinDepthBounds( float minDepthBounds_ ) + { + minDepthBounds = minDepthBounds_; + return *this; + } + + PipelineDepthStencilStateCreateInfo& setMaxDepthBounds( float maxDepthBounds_ ) + { + maxDepthBounds = maxDepthBounds_; + return *this; + } + + operator const VkPipelineDepthStencilStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( depthTestEnable == rhs.depthTestEnable ) + && ( depthWriteEnable == rhs.depthWriteEnable ) + && ( depthCompareOp == rhs.depthCompareOp ) + && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) + && ( stencilTestEnable == rhs.stencilTestEnable ) + && ( front == rhs.front ) + && ( back == rhs.back ) + && ( minDepthBounds == rhs.minDepthBounds ) + && ( maxDepthBounds == rhs.maxDepthBounds ); + } + + bool operator!=( PipelineDepthStencilStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineDepthStencilStateCreateFlags flags; + Bool32 depthTestEnable; + Bool32 depthWriteEnable; + CompareOp depthCompareOp; + Bool32 depthBoundsTestEnable; + Bool32 stencilTestEnable; + StencilOpState front; + StencilOpState back; + float minDepthBounds; + float maxDepthBounds; + }; + static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineCacheCreateInfo + { + PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), + size_t initialDataSize_ = 0, + const void* pInitialData_ = nullptr ) + : flags( flags_ ) + , initialDataSize( initialDataSize_ ) + , pInitialData( pInitialData_ ) + { + } + + PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); + } + + PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); + return *this; + } + PipelineCacheCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCacheCreateInfo& setFlags( PipelineCacheCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineCacheCreateInfo& setInitialDataSize( size_t initialDataSize_ ) + { + initialDataSize = initialDataSize_; + return *this; + } + + PipelineCacheCreateInfo& setPInitialData( const void* pInitialData_ ) + { + pInitialData = pInitialData_; + return *this; + } + + operator const VkPipelineCacheCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineCacheCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( initialDataSize == rhs.initialDataSize ) + && ( pInitialData == rhs.pInitialData ); + } + + bool operator!=( PipelineCacheCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineCacheCreateInfo; + + public: + const void* pNext = nullptr; + PipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; + }; + static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" ); + + struct SamplerCreateInfo + { + SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), + Filter magFilter_ = Filter::eNearest, + Filter minFilter_ = Filter::eNearest, + SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, + SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, + SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, + SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, + float mipLodBias_ = 0, + Bool32 anisotropyEnable_ = 0, + float maxAnisotropy_ = 0, + Bool32 compareEnable_ = 0, + CompareOp compareOp_ = CompareOp::eNever, + float minLod_ = 0, + float maxLod_ = 0, + BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, + Bool32 unnormalizedCoordinates_ = 0 ) + : flags( flags_ ) + , magFilter( magFilter_ ) + , minFilter( minFilter_ ) + , mipmapMode( mipmapMode_ ) + , addressModeU( addressModeU_ ) + , addressModeV( addressModeV_ ) + , addressModeW( addressModeW_ ) + , mipLodBias( mipLodBias_ ) + , anisotropyEnable( anisotropyEnable_ ) + , maxAnisotropy( maxAnisotropy_ ) + , compareEnable( compareEnable_ ) + , compareOp( compareOp_ ) + , minLod( minLod_ ) + , maxLod( maxLod_ ) + , borderColor( borderColor_ ) + , unnormalizedCoordinates( unnormalizedCoordinates_ ) + { + } + + SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); + } + + SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); + return *this; + } + SamplerCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + SamplerCreateInfo& setMagFilter( Filter magFilter_ ) + { + magFilter = magFilter_; + return *this; + } + + SamplerCreateInfo& setMinFilter( Filter minFilter_ ) + { + minFilter = minFilter_; + return *this; + } + + SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ ) + { + mipmapMode = mipmapMode_; + return *this; + } + + SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ ) + { + addressModeU = addressModeU_; + return *this; + } + + SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ ) + { + addressModeV = addressModeV_; + return *this; + } + + SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ ) + { + addressModeW = addressModeW_; + return *this; + } + + SamplerCreateInfo& setMipLodBias( float mipLodBias_ ) + { + mipLodBias = mipLodBias_; + return *this; + } + + SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ ) + { + anisotropyEnable = anisotropyEnable_; + return *this; + } + + SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ ) + { + maxAnisotropy = maxAnisotropy_; + return *this; + } + + SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ ) + { + compareEnable = compareEnable_; + return *this; + } + + SamplerCreateInfo& setCompareOp( CompareOp compareOp_ ) + { + compareOp = compareOp_; + return *this; + } + + SamplerCreateInfo& setMinLod( float minLod_ ) + { + minLod = minLod_; + return *this; + } + + SamplerCreateInfo& setMaxLod( float maxLod_ ) + { + maxLod = maxLod_; + return *this; + } + + SamplerCreateInfo& setBorderColor( BorderColor borderColor_ ) + { + borderColor = borderColor_; + return *this; + } + + SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) + { + unnormalizedCoordinates = unnormalizedCoordinates_; + return *this; + } + + operator const VkSamplerCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SamplerCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( magFilter == rhs.magFilter ) + && ( minFilter == rhs.minFilter ) + && ( mipmapMode == rhs.mipmapMode ) + && ( addressModeU == rhs.addressModeU ) + && ( addressModeV == rhs.addressModeV ) + && ( addressModeW == rhs.addressModeW ) + && ( mipLodBias == rhs.mipLodBias ) + && ( anisotropyEnable == rhs.anisotropyEnable ) + && ( maxAnisotropy == rhs.maxAnisotropy ) + && ( compareEnable == rhs.compareEnable ) + && ( compareOp == rhs.compareOp ) + && ( minLod == rhs.minLod ) + && ( maxLod == rhs.maxLod ) + && ( borderColor == rhs.borderColor ) + && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); + } + + bool operator!=( SamplerCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSamplerCreateInfo; + + public: + const void* pNext = nullptr; + SamplerCreateFlags flags; + Filter magFilter; + Filter minFilter; + SamplerMipmapMode mipmapMode; + SamplerAddressMode addressModeU; + SamplerAddressMode addressModeV; + SamplerAddressMode addressModeW; + float mipLodBias; + Bool32 anisotropyEnable; + float maxAnisotropy; + Bool32 compareEnable; + CompareOp compareOp; + float minLod; + float maxLod; + BorderColor borderColor; + Bool32 unnormalizedCoordinates; + }; + static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); + + struct CommandBufferAllocateInfo + { + CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), + CommandBufferLevel level_ = CommandBufferLevel::ePrimary, + uint32_t commandBufferCount_ = 0 ) + : commandPool( commandPool_ ) + , level( level_ ) + , commandBufferCount( commandBufferCount_ ) + { + } + + CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); + } + + CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); + return *this; + } + CommandBufferAllocateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CommandBufferAllocateInfo& setCommandPool( CommandPool commandPool_ ) + { + commandPool = commandPool_; + return *this; + } + + CommandBufferAllocateInfo& setLevel( CommandBufferLevel level_ ) + { + level = level_; + return *this; + } + + CommandBufferAllocateInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) + { + commandBufferCount = commandBufferCount_; + return *this; + } + + operator const VkCommandBufferAllocateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CommandBufferAllocateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( commandPool == rhs.commandPool ) + && ( level == rhs.level ) + && ( commandBufferCount == rhs.commandBufferCount ); + } + + bool operator!=( CommandBufferAllocateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCommandBufferAllocateInfo; + + public: + const void* pNext = nullptr; + CommandPool commandPool; + CommandBufferLevel level; + uint32_t commandBufferCount; + }; + static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" ); + + struct RenderPassBeginInfo + { + RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), + Framebuffer framebuffer_ = Framebuffer(), + Rect2D renderArea_ = Rect2D(), + uint32_t clearValueCount_ = 0, + const ClearValue* pClearValues_ = nullptr ) + : renderPass( renderPass_ ) + , framebuffer( framebuffer_ ) + , renderArea( renderArea_ ) + , clearValueCount( clearValueCount_ ) + , pClearValues( pClearValues_ ) + { + } + + RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); + } + + RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); + return *this; + } + RenderPassBeginInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassBeginInfo& setRenderPass( RenderPass renderPass_ ) + { + renderPass = renderPass_; + return *this; + } + + RenderPassBeginInfo& setFramebuffer( Framebuffer framebuffer_ ) + { + framebuffer = framebuffer_; + return *this; + } + + RenderPassBeginInfo& setRenderArea( Rect2D renderArea_ ) + { + renderArea = renderArea_; + return *this; + } + + RenderPassBeginInfo& setClearValueCount( uint32_t clearValueCount_ ) + { + clearValueCount = clearValueCount_; + return *this; + } + + RenderPassBeginInfo& setPClearValues( const ClearValue* pClearValues_ ) + { + pClearValues = pClearValues_; + return *this; + } + + operator const VkRenderPassBeginInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( RenderPassBeginInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( renderPass == rhs.renderPass ) + && ( framebuffer == rhs.framebuffer ) + && ( renderArea == rhs.renderArea ) + && ( clearValueCount == rhs.clearValueCount ) + && ( pClearValues == rhs.pClearValues ); + } + + bool operator!=( RenderPassBeginInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassBeginInfo; + + public: + const void* pNext = nullptr; + RenderPass renderPass; + Framebuffer framebuffer; + Rect2D renderArea; + uint32_t clearValueCount; + const ClearValue* pClearValues; + }; + static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); + + struct EventCreateInfo + { + EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() ) + : flags( flags_ ) + { + } + + EventCreateInfo( VkEventCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( EventCreateInfo ) ); + } + + EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( EventCreateInfo ) ); + return *this; + } + EventCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + EventCreateInfo& setFlags( EventCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkEventCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( EventCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ); + } + + bool operator!=( EventCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eEventCreateInfo; + + public: + const void* pNext = nullptr; + EventCreateFlags flags; + }; + static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); + + struct SemaphoreCreateInfo + { + SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() ) + : flags( flags_ ) + { + } + + SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); + } + + SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); + return *this; + } + SemaphoreCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SemaphoreCreateInfo& setFlags( SemaphoreCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkSemaphoreCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SemaphoreCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ); + } + + bool operator!=( SemaphoreCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSemaphoreCreateInfo; + + public: + const void* pNext = nullptr; + SemaphoreCreateFlags flags; + }; + static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); + + struct FramebufferCreateInfo + { + FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(), + RenderPass renderPass_ = RenderPass(), + uint32_t attachmentCount_ = 0, + const ImageView* pAttachments_ = nullptr, + uint32_t width_ = 0, + uint32_t height_ = 0, + uint32_t layers_ = 0 ) + : flags( flags_ ) + , renderPass( renderPass_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , width( width_ ) + , height( height_ ) + , layers( layers_ ) + { + } + + FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); + } + + FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); + return *this; + } + FramebufferCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + FramebufferCreateInfo& setFlags( FramebufferCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + FramebufferCreateInfo& setRenderPass( RenderPass renderPass_ ) + { + renderPass = renderPass_; + return *this; + } + + FramebufferCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) + { + attachmentCount = attachmentCount_; + return *this; + } + + FramebufferCreateInfo& setPAttachments( const ImageView* pAttachments_ ) + { + pAttachments = pAttachments_; + return *this; + } + + FramebufferCreateInfo& setWidth( uint32_t width_ ) + { + width = width_; + return *this; + } + + FramebufferCreateInfo& setHeight( uint32_t height_ ) + { + height = height_; + return *this; + } + + FramebufferCreateInfo& setLayers( uint32_t layers_ ) + { + layers = layers_; + return *this; + } + + operator const VkFramebufferCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FramebufferCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( renderPass == rhs.renderPass ) + && ( attachmentCount == rhs.attachmentCount ) + && ( pAttachments == rhs.pAttachments ) + && ( width == rhs.width ) + && ( height == rhs.height ) + && ( layers == rhs.layers ); + } + + bool operator!=( FramebufferCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eFramebufferCreateInfo; + + public: + const void* pNext = nullptr; + FramebufferCreateFlags flags; + RenderPass renderPass; + uint32_t attachmentCount; + const ImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; + }; + static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" ); + + struct DisplayModeCreateInfoKHR + { + DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), + DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() ) + : flags( flags_ ) + , parameters( parameters_ ) + { + } + + DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); + } + + DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); + return *this; + } + DisplayModeCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DisplayModeCreateInfoKHR& setFlags( DisplayModeCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + DisplayModeCreateInfoKHR& setParameters( DisplayModeParametersKHR parameters_ ) + { + parameters = parameters_; + return *this; + } + + operator const VkDisplayModeCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayModeCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( parameters == rhs.parameters ); + } + + bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayModeCreateInfoKHR; + + public: + const void* pNext = nullptr; + DisplayModeCreateFlagsKHR flags; + DisplayModeParametersKHR parameters; + }; + static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" ); + + struct DisplayPresentInfoKHR + { + DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), + Rect2D dstRect_ = Rect2D(), + Bool32 persistent_ = 0 ) + : srcRect( srcRect_ ) + , dstRect( dstRect_ ) + , persistent( persistent_ ) + { + } + + DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); + } + + DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); + return *this; + } + DisplayPresentInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DisplayPresentInfoKHR& setSrcRect( Rect2D srcRect_ ) + { + srcRect = srcRect_; + return *this; + } + + DisplayPresentInfoKHR& setDstRect( Rect2D dstRect_ ) + { + dstRect = dstRect_; + return *this; + } + + DisplayPresentInfoKHR& setPersistent( Bool32 persistent_ ) + { + persistent = persistent_; + return *this; + } + + operator const VkDisplayPresentInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPresentInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcRect == rhs.srcRect ) + && ( dstRect == rhs.dstRect ) + && ( persistent == rhs.persistent ); + } + + bool operator!=( DisplayPresentInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayPresentInfoKHR; + + public: + const void* pNext = nullptr; + Rect2D srcRect; + Rect2D dstRect; + Bool32 persistent; + }; + static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidSurfaceCreateInfoKHR + { + AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), + struct ANativeWindow* window_ = nullptr ) + : flags( flags_ ) + , window( window_ ) + { + } + + AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); + } + + AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); + return *this; + } + AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AndroidSurfaceCreateInfoKHR& setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + AndroidSurfaceCreateInfoKHR& setWindow( struct ANativeWindow* window_ ) + { + window = window_; + return *this; + } + + operator const VkAndroidSurfaceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( window == rhs.window ); + } + + bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; + + public: + const void* pNext = nullptr; + AndroidSurfaceCreateFlagsKHR flags; + struct ANativeWindow* window; + }; + static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + struct MirSurfaceCreateInfoKHR + { + MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), + MirConnection* connection_ = nullptr, + MirSurface* mirSurface_ = nullptr ) + : flags( flags_ ) + , connection( connection_ ) + , mirSurface( mirSurface_ ) + { + } + + MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); + } + + MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); + return *this; + } + MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MirSurfaceCreateInfoKHR& setFlags( MirSurfaceCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + MirSurfaceCreateInfoKHR& setConnection( MirConnection* connection_ ) + { + connection = connection_; + return *this; + } + + MirSurfaceCreateInfoKHR& setMirSurface( MirSurface* mirSurface_ ) + { + mirSurface = mirSurface_; + return *this; + } + + operator const VkMirSurfaceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( connection == rhs.connection ) + && ( mirSurface == rhs.mirSurface ); + } + + bool operator!=( MirSurfaceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMirSurfaceCreateInfoKHR; + + public: + const void* pNext = nullptr; + MirSurfaceCreateFlagsKHR flags; + MirConnection* connection; + MirSurface* mirSurface; + }; + static_assert( sizeof( MirSurfaceCreateInfoKHR ) == sizeof( VkMirSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + +#ifdef VK_USE_PLATFORM_VI_NN + struct ViSurfaceCreateInfoNN + { + ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(), + void* window_ = nullptr ) + : flags( flags_ ) + , window( window_ ) + { + } + + ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) + { + memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); + } + + ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) + { + memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); + return *this; + } + ViSurfaceCreateInfoNN& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ViSurfaceCreateInfoNN& setFlags( ViSurfaceCreateFlagsNN flags_ ) + { + flags = flags_; + return *this; + } + + ViSurfaceCreateInfoNN& setWindow( void* window_ ) + { + window = window_; + return *this; + } + + operator const VkViSurfaceCreateInfoNN&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ViSurfaceCreateInfoNN const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( window == rhs.window ); + } + + bool operator!=( ViSurfaceCreateInfoNN const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eViSurfaceCreateInfoNN; + + public: + const void* pNext = nullptr; + ViSurfaceCreateFlagsNN flags; + void* window; + }; + static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + struct WaylandSurfaceCreateInfoKHR + { + WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), + struct wl_display* display_ = nullptr, + struct wl_surface* surface_ = nullptr ) + : flags( flags_ ) + , display( display_ ) + , surface( surface_ ) + { + } + + WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); + } + + WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); + return *this; + } + WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + WaylandSurfaceCreateInfoKHR& setFlags( WaylandSurfaceCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + WaylandSurfaceCreateInfoKHR& setDisplay( struct wl_display* display_ ) + { + display = display_; + return *this; + } + + WaylandSurfaceCreateInfoKHR& setSurface( struct wl_surface* surface_ ) + { + surface = surface_; + return *this; + } + + operator const VkWaylandSurfaceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( display == rhs.display ) + && ( surface == rhs.surface ); + } + + bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; + + public: + const void* pNext = nullptr; + WaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; + }; + static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct Win32SurfaceCreateInfoKHR + { + Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), + HINSTANCE hinstance_ = 0, + HWND hwnd_ = 0 ) + : flags( flags_ ) + , hinstance( hinstance_ ) + , hwnd( hwnd_ ) + { + } + + Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); + } + + Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); + return *this; + } + Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + Win32SurfaceCreateInfoKHR& setFlags( Win32SurfaceCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + Win32SurfaceCreateInfoKHR& setHinstance( HINSTANCE hinstance_ ) + { + hinstance = hinstance_; + return *this; + } + + Win32SurfaceCreateInfoKHR& setHwnd( HWND hwnd_ ) + { + hwnd = hwnd_; + return *this; + } + + operator const VkWin32SurfaceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( hinstance == rhs.hinstance ) + && ( hwnd == rhs.hwnd ); + } + + bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; + + public: + const void* pNext = nullptr; + Win32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; + }; + static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + struct XlibSurfaceCreateInfoKHR + { + XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), + Display* dpy_ = nullptr, + Window window_ = 0 ) + : flags( flags_ ) + , dpy( dpy_ ) + , window( window_ ) + { + } + + XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); + } + + XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); + return *this; + } + XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + XlibSurfaceCreateInfoKHR& setFlags( XlibSurfaceCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + XlibSurfaceCreateInfoKHR& setDpy( Display* dpy_ ) + { + dpy = dpy_; + return *this; + } + + XlibSurfaceCreateInfoKHR& setWindow( Window window_ ) + { + window = window_; + return *this; + } + + operator const VkXlibSurfaceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( dpy == rhs.dpy ) + && ( window == rhs.window ); + } + + bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; + + public: + const void* pNext = nullptr; + XlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; + }; + static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + struct XcbSurfaceCreateInfoKHR + { + XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), + xcb_connection_t* connection_ = nullptr, + xcb_window_t window_ = 0 ) + : flags( flags_ ) + , connection( connection_ ) + , window( window_ ) + { + } + + XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); + } + + XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); + return *this; + } + XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + XcbSurfaceCreateInfoKHR& setFlags( XcbSurfaceCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + XcbSurfaceCreateInfoKHR& setConnection( xcb_connection_t* connection_ ) + { + connection = connection_; + return *this; + } + + XcbSurfaceCreateInfoKHR& setWindow( xcb_window_t window_ ) + { + window = window_; + return *this; + } + + operator const VkXcbSurfaceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( connection == rhs.connection ) + && ( window == rhs.window ); + } + + bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; + + public: + const void* pNext = nullptr; + XcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; + }; + static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + + struct DebugMarkerMarkerInfoEXT + { + DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, + std::array const& color_ = { { 0, 0, 0, 0 } } ) + : pMarkerName( pMarkerName_ ) + { + memcpy( &color, color_.data(), 4 * sizeof( float ) ); + } + + DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); + } + + DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); + return *this; + } + DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugMarkerMarkerInfoEXT& setPMarkerName( const char* pMarkerName_ ) + { + pMarkerName = pMarkerName_; + return *this; + } + + DebugMarkerMarkerInfoEXT& setColor( std::array color_ ) + { + memcpy( &color, color_.data(), 4 * sizeof( float ) ); + return *this; + } + + operator const VkDebugMarkerMarkerInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pMarkerName == rhs.pMarkerName ) + && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 ); + } + + bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; + + public: + const void* pNext = nullptr; + const char* pMarkerName; + float color[4]; + }; + static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" ); + + struct DedicatedAllocationImageCreateInfoNV + { + DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) + : dedicatedAllocation( dedicatedAllocation_ ) + { + } + + DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); + } + + DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); + return *this; + } + DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DedicatedAllocationImageCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ ) + { + dedicatedAllocation = dedicatedAllocation_; + return *this; + } + + operator const VkDedicatedAllocationImageCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( dedicatedAllocation == rhs.dedicatedAllocation ); + } + + bool operator!=( DedicatedAllocationImageCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; + + public: + const void* pNext = nullptr; + Bool32 dedicatedAllocation; + }; + static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" ); + + struct DedicatedAllocationBufferCreateInfoNV + { + DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) + : dedicatedAllocation( dedicatedAllocation_ ) + { + } + + DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); + } + + DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); + return *this; + } + DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DedicatedAllocationBufferCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ ) + { + dedicatedAllocation = dedicatedAllocation_; + return *this; + } + + operator const VkDedicatedAllocationBufferCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( dedicatedAllocation == rhs.dedicatedAllocation ); + } + + bool operator!=( DedicatedAllocationBufferCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; + + public: + const void* pNext = nullptr; + Bool32 dedicatedAllocation; + }; + static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" ); + + struct DedicatedAllocationMemoryAllocateInfoNV + { + DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), + Buffer buffer_ = Buffer() ) + : image( image_ ) + , buffer( buffer_ ) + { + } + + DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); + } + + DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); + return *this; + } + DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DedicatedAllocationMemoryAllocateInfoNV& setImage( Image image_ ) + { + image = image_; + return *this; + } + + DedicatedAllocationMemoryAllocateInfoNV& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator const VkDedicatedAllocationMemoryAllocateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; + + public: + const void* pNext = nullptr; + Image image; + Buffer buffer; + }; + static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_WIN32_NV + struct ExportMemoryWin32HandleInfoNV + { + ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, + DWORD dwAccess_ = 0 ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + { + } + + ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); + } + + ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); + return *this; + } + ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + { + pAttributes = pAttributes_; + return *this; + } + + ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ ) + { + dwAccess = dwAccess_; + return *this; + } + + operator const VkExportMemoryWin32HandleInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pAttributes == rhs.pAttributes ) + && ( dwAccess == rhs.dwAccess ); + } + + bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; + + public: + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + }; + static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_NV*/ + +#ifdef VK_USE_PLATFORM_WIN32_NV + struct Win32KeyedMutexAcquireReleaseInfoNV + { + Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, + const DeviceMemory* pAcquireSyncs_ = nullptr, + const uint64_t* pAcquireKeys_ = nullptr, + const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, + uint32_t releaseCount_ = 0, + const DeviceMemory* pReleaseSyncs_ = nullptr, + const uint64_t* pReleaseKeys_ = nullptr ) + : acquireCount( acquireCount_ ) + , pAcquireSyncs( pAcquireSyncs_ ) + , pAcquireKeys( pAcquireKeys_ ) + , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) + , releaseCount( releaseCount_ ) + , pReleaseSyncs( pReleaseSyncs_ ) + , pReleaseKeys( pReleaseKeys_ ) + { + } + + Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); + } + + Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); + return *this; + } + Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ ) + { + acquireCount = acquireCount_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) + { + pAcquireSyncs = pAcquireSyncs_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) + { + pAcquireKeys = pAcquireKeys_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ ) + { + pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ ) + { + releaseCount = releaseCount_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) + { + pReleaseSyncs = pReleaseSyncs_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) + { + pReleaseKeys = pReleaseKeys_; + return *this; + } + + operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( acquireCount == rhs.acquireCount ) + && ( pAcquireSyncs == rhs.pAcquireSyncs ) + && ( pAcquireKeys == rhs.pAcquireKeys ) + && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) + && ( releaseCount == rhs.releaseCount ) + && ( pReleaseSyncs == rhs.pReleaseSyncs ) + && ( pReleaseKeys == rhs.pReleaseKeys ); + } + + bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; + + public: + const void* pNext = nullptr; + uint32_t acquireCount; + const DeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const DeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; + }; + static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_NV*/ + + struct DeviceGeneratedCommandsFeaturesNVX + { + DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 ) + : computeBindingPointSupport( computeBindingPointSupport_ ) + { + } + + DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); + } + + DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); + return *this; + } + DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGeneratedCommandsFeaturesNVX& setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ ) + { + computeBindingPointSupport = computeBindingPointSupport_; + return *this; + } + + operator const VkDeviceGeneratedCommandsFeaturesNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( computeBindingPointSupport == rhs.computeBindingPointSupport ); + } + + bool operator!=( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; + + public: + const void* pNext = nullptr; + Bool32 computeBindingPointSupport; + }; + static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" ); + + struct DeviceGeneratedCommandsLimitsNVX + { + DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, + uint32_t maxObjectEntryCounts_ = 0, + uint32_t minSequenceCountBufferOffsetAlignment_ = 0, + uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, + uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) + : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) + , maxObjectEntryCounts( maxObjectEntryCounts_ ) + , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) + , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) + , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ ) + { + } + + DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); + } + + DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); + return *this; + } + DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGeneratedCommandsLimitsNVX& setMaxIndirectCommandsLayoutTokenCount( uint32_t maxIndirectCommandsLayoutTokenCount_ ) + { + maxIndirectCommandsLayoutTokenCount = maxIndirectCommandsLayoutTokenCount_; + return *this; + } + + DeviceGeneratedCommandsLimitsNVX& setMaxObjectEntryCounts( uint32_t maxObjectEntryCounts_ ) + { + maxObjectEntryCounts = maxObjectEntryCounts_; + return *this; + } + + DeviceGeneratedCommandsLimitsNVX& setMinSequenceCountBufferOffsetAlignment( uint32_t minSequenceCountBufferOffsetAlignment_ ) + { + minSequenceCountBufferOffsetAlignment = minSequenceCountBufferOffsetAlignment_; + return *this; + } + + DeviceGeneratedCommandsLimitsNVX& setMinSequenceIndexBufferOffsetAlignment( uint32_t minSequenceIndexBufferOffsetAlignment_ ) + { + minSequenceIndexBufferOffsetAlignment = minSequenceIndexBufferOffsetAlignment_; + return *this; + } + + DeviceGeneratedCommandsLimitsNVX& setMinCommandsTokenBufferOffsetAlignment( uint32_t minCommandsTokenBufferOffsetAlignment_ ) + { + minCommandsTokenBufferOffsetAlignment = minCommandsTokenBufferOffsetAlignment_; + return *this; + } + + operator const VkDeviceGeneratedCommandsLimitsNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxIndirectCommandsLayoutTokenCount == rhs.maxIndirectCommandsLayoutTokenCount ) + && ( maxObjectEntryCounts == rhs.maxObjectEntryCounts ) + && ( minSequenceCountBufferOffsetAlignment == rhs.minSequenceCountBufferOffsetAlignment ) + && ( minSequenceIndexBufferOffsetAlignment == rhs.minSequenceIndexBufferOffsetAlignment ) + && ( minCommandsTokenBufferOffsetAlignment == rhs.minCommandsTokenBufferOffsetAlignment ); + } + + bool operator!=( DeviceGeneratedCommandsLimitsNVX const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; + + public: + const void* pNext = nullptr; + uint32_t maxIndirectCommandsLayoutTokenCount; + uint32_t maxObjectEntryCounts; + uint32_t minSequenceCountBufferOffsetAlignment; + uint32_t minSequenceIndexBufferOffsetAlignment; + uint32_t minCommandsTokenBufferOffsetAlignment; + }; + static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" ); + + struct CmdReserveSpaceForCommandsInfoNVX + { + CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), + IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), + uint32_t maxSequencesCount_ = 0 ) + : objectTable( objectTable_ ) + , indirectCommandsLayout( indirectCommandsLayout_ ) + , maxSequencesCount( maxSequencesCount_ ) + { + } + + CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); + } + + CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); + return *this; + } + CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CmdReserveSpaceForCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ ) + { + objectTable = objectTable_; + return *this; + } + + CmdReserveSpaceForCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ ) + { + indirectCommandsLayout = indirectCommandsLayout_; + return *this; + } + + CmdReserveSpaceForCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ ) + { + maxSequencesCount = maxSequencesCount_; + return *this; + } + + operator const VkCmdReserveSpaceForCommandsInfoNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectTable == rhs.objectTable ) + && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) + && ( maxSequencesCount == rhs.maxSequencesCount ); + } + + bool operator!=( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; + + public: + const void* pNext = nullptr; + ObjectTableNVX objectTable; + IndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t maxSequencesCount; + }; + static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceFeatures2 + { + PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() ) + : features( features_ ) + { + } + + PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) ); + } + + PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) ); + return *this; + } + PhysicalDeviceFeatures2& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceFeatures2& setFeatures( PhysicalDeviceFeatures features_ ) + { + features = features_; + return *this; + } + + operator const VkPhysicalDeviceFeatures2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceFeatures2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( features == rhs.features ); + } + + bool operator!=( PhysicalDeviceFeatures2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFeatures2; + + public: + void* pNext = nullptr; + PhysicalDeviceFeatures features; + }; + static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" ); + + using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; + + struct PhysicalDevicePushDescriptorPropertiesKHR + { + PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 ) + : maxPushDescriptors( maxPushDescriptors_ ) + { + } + + PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); + } + + PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); + return *this; + } + PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDevicePushDescriptorPropertiesKHR& setMaxPushDescriptors( uint32_t maxPushDescriptors_ ) + { + maxPushDescriptors = maxPushDescriptors_; + return *this; + } + + operator const VkPhysicalDevicePushDescriptorPropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxPushDescriptors == rhs.maxPushDescriptors ); + } + + bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; + + public: + void* pNext = nullptr; + uint32_t maxPushDescriptors; + }; + static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" ); + + struct PresentRegionsKHR + { + PresentRegionsKHR( uint32_t swapchainCount_ = 0, + const PresentRegionKHR* pRegions_ = nullptr ) + : swapchainCount( swapchainCount_ ) + , pRegions( pRegions_ ) + { + } + + PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); + } + + PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); + return *this; + } + PresentRegionsKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PresentRegionsKHR& setSwapchainCount( uint32_t swapchainCount_ ) + { + swapchainCount = swapchainCount_; + return *this; + } + + PresentRegionsKHR& setPRegions( const PresentRegionKHR* pRegions_ ) + { + pRegions = pRegions_; + return *this; + } + + operator const VkPresentRegionsKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PresentRegionsKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( swapchainCount == rhs.swapchainCount ) + && ( pRegions == rhs.pRegions ); + } + + bool operator!=( PresentRegionsKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePresentRegionsKHR; + + public: + const void* pNext = nullptr; + uint32_t swapchainCount; + const PresentRegionKHR* pRegions; + }; + static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceVariablePointerFeatures + { + PhysicalDeviceVariablePointerFeatures( Bool32 variablePointersStorageBuffer_ = 0, + Bool32 variablePointers_ = 0 ) + : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) + , variablePointers( variablePointers_ ) + { + } + + PhysicalDeviceVariablePointerFeatures( VkPhysicalDeviceVariablePointerFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) ); + } + + PhysicalDeviceVariablePointerFeatures& operator=( VkPhysicalDeviceVariablePointerFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) ); + return *this; + } + PhysicalDeviceVariablePointerFeatures& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceVariablePointerFeatures& setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) + { + variablePointersStorageBuffer = variablePointersStorageBuffer_; + return *this; + } + + PhysicalDeviceVariablePointerFeatures& setVariablePointers( Bool32 variablePointers_ ) + { + variablePointers = variablePointers_; + return *this; + } + + operator const VkPhysicalDeviceVariablePointerFeatures&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceVariablePointerFeatures const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) + && ( variablePointers == rhs.variablePointers ); + } + + bool operator!=( PhysicalDeviceVariablePointerFeatures const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeatures; + + public: + void* pNext = nullptr; + Bool32 variablePointersStorageBuffer; + Bool32 variablePointers; + }; + static_assert( sizeof( PhysicalDeviceVariablePointerFeatures ) == sizeof( VkPhysicalDeviceVariablePointerFeatures ), "struct and wrapper have different size!" ); + + using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointerFeatures; + + struct PhysicalDeviceIDProperties + { + operator const VkPhysicalDeviceIDProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceIDProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) + && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) + && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE * sizeof( uint8_t ) ) == 0 ) + && ( deviceNodeMask == rhs.deviceNodeMask ) + && ( deviceLUIDValid == rhs.deviceLUIDValid ); + } + + bool operator!=( PhysicalDeviceIDProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceIdProperties; + + public: + void* pNext = nullptr; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + Bool32 deviceLUIDValid; + }; + static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" ); + + using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportMemoryWin32HandleInfoKHR + { + ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, + DWORD dwAccess_ = 0, + LPCWSTR name_ = 0 ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) + { + } + + ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); + } + + ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); + return *this; + } + ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + { + pAttributes = pAttributes_; + return *this; + } + + ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) + { + dwAccess = dwAccess_; + return *this; + } + + ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkExportMemoryWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pAttributes == rhs.pAttributes ) + && ( dwAccess == rhs.dwAccess ) + && ( name == rhs.name ); + } + + bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; + }; + static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryWin32HandlePropertiesKHR + { + operator const VkMemoryWin32HandlePropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryTypeBits == rhs.memoryTypeBits ); + } + + bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; + + public: + void* pNext = nullptr; + uint32_t memoryTypeBits; + }; + static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct MemoryFdPropertiesKHR + { + operator const VkMemoryFdPropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryFdPropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryTypeBits == rhs.memoryTypeBits ); + } + + bool operator!=( MemoryFdPropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryFdPropertiesKHR; + + public: + void* pNext = nullptr; + uint32_t memoryTypeBits; + }; + static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct Win32KeyedMutexAcquireReleaseInfoKHR + { + Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, + const DeviceMemory* pAcquireSyncs_ = nullptr, + const uint64_t* pAcquireKeys_ = nullptr, + const uint32_t* pAcquireTimeouts_ = nullptr, + uint32_t releaseCount_ = 0, + const DeviceMemory* pReleaseSyncs_ = nullptr, + const uint64_t* pReleaseKeys_ = nullptr ) + : acquireCount( acquireCount_ ) + , pAcquireSyncs( pAcquireSyncs_ ) + , pAcquireKeys( pAcquireKeys_ ) + , pAcquireTimeouts( pAcquireTimeouts_ ) + , releaseCount( releaseCount_ ) + , pReleaseSyncs( pReleaseSyncs_ ) + , pReleaseKeys( pReleaseKeys_ ) + { + } + + Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); + } + + Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); + return *this; + } + Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ ) + { + acquireCount = acquireCount_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) + { + pAcquireSyncs = pAcquireSyncs_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) + { + pAcquireKeys = pAcquireKeys_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ ) + { + pAcquireTimeouts = pAcquireTimeouts_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ ) + { + releaseCount = releaseCount_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) + { + pReleaseSyncs = pReleaseSyncs_; + return *this; + } + + Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) + { + pReleaseKeys = pReleaseKeys_; + return *this; + } + + operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( acquireCount == rhs.acquireCount ) + && ( pAcquireSyncs == rhs.pAcquireSyncs ) + && ( pAcquireKeys == rhs.pAcquireKeys ) + && ( pAcquireTimeouts == rhs.pAcquireTimeouts ) + && ( releaseCount == rhs.releaseCount ) + && ( pReleaseSyncs == rhs.pReleaseSyncs ) + && ( pReleaseKeys == rhs.pReleaseKeys ); + } + + bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; + + public: + const void* pNext = nullptr; + uint32_t acquireCount; + const DeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const DeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; + }; + static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportSemaphoreWin32HandleInfoKHR + { + ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, + DWORD dwAccess_ = 0, + LPCWSTR name_ = 0 ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) + { + } + + ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); + } + + ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); + return *this; + } + ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + { + pAttributes = pAttributes_; + return *this; + } + + ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) + { + dwAccess = dwAccess_; + return *this; + } + + ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkExportSemaphoreWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pAttributes == rhs.pAttributes ) + && ( dwAccess == rhs.dwAccess ) + && ( name == rhs.name ); + } + + bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; + }; + static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct D3D12FenceSubmitInfoKHR + { + D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, + const uint64_t* pWaitSemaphoreValues_ = nullptr, + uint32_t signalSemaphoreValuesCount_ = 0, + const uint64_t* pSignalSemaphoreValues_ = nullptr ) + : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) + , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) + , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) + , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) + { + } + + D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); + } + + D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); + return *this; + } + D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) + { + waitSemaphoreValuesCount = waitSemaphoreValuesCount_; + return *this; + } + + D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ ) + { + pWaitSemaphoreValues = pWaitSemaphoreValues_; + return *this; + } + + D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) + { + signalSemaphoreValuesCount = signalSemaphoreValuesCount_; + return *this; + } + + D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ ) + { + pSignalSemaphoreValues = pSignalSemaphoreValues_; + return *this; + } + + operator const VkD3D12FenceSubmitInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) + && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) + && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) + && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); + } + + bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; + + public: + const void* pNext = nullptr; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; + }; + static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportFenceWin32HandleInfoKHR + { + ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, + DWORD dwAccess_ = 0, + LPCWSTR name_ = 0 ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) + { + } + + ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); + } + + ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); + return *this; + } + ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + { + pAttributes = pAttributes_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) + { + dwAccess = dwAccess_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkExportFenceWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pAttributes == rhs.pAttributes ) + && ( dwAccess == rhs.dwAccess ) + && ( name == rhs.name ); + } + + bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; + }; + static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct PhysicalDeviceMultiviewFeatures + { + PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = 0, + Bool32 multiviewGeometryShader_ = 0, + Bool32 multiviewTessellationShader_ = 0 ) + : multiview( multiview_ ) + , multiviewGeometryShader( multiviewGeometryShader_ ) + , multiviewTessellationShader( multiviewTessellationShader_ ) + { + } + + PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) ); + } + + PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) ); + return *this; + } + PhysicalDeviceMultiviewFeatures& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceMultiviewFeatures& setMultiview( Bool32 multiview_ ) + { + multiview = multiview_; + return *this; + } + + PhysicalDeviceMultiviewFeatures& setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) + { + multiviewGeometryShader = multiviewGeometryShader_; + return *this; + } + + PhysicalDeviceMultiviewFeatures& setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) + { + multiviewTessellationShader = multiviewTessellationShader_; + return *this; + } + + operator const VkPhysicalDeviceMultiviewFeatures&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceMultiviewFeatures const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( multiview == rhs.multiview ) + && ( multiviewGeometryShader == rhs.multiviewGeometryShader ) + && ( multiviewTessellationShader == rhs.multiviewTessellationShader ); + } + + bool operator!=( PhysicalDeviceMultiviewFeatures const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; + + public: + void* pNext = nullptr; + Bool32 multiview; + Bool32 multiviewGeometryShader; + Bool32 multiviewTessellationShader; + }; + static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" ); + + using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; + + struct PhysicalDeviceMultiviewProperties + { + operator const VkPhysicalDeviceMultiviewProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceMultiviewProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) + && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); + } + + bool operator!=( PhysicalDeviceMultiviewProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; + + public: + void* pNext = nullptr; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + }; + static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" ); + + using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; + + struct RenderPassMultiviewCreateInfo + { + RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0, + const uint32_t* pViewMasks_ = nullptr, + uint32_t dependencyCount_ = 0, + const int32_t* pViewOffsets_ = nullptr, + uint32_t correlationMaskCount_ = 0, + const uint32_t* pCorrelationMasks_ = nullptr ) + : subpassCount( subpassCount_ ) + , pViewMasks( pViewMasks_ ) + , dependencyCount( dependencyCount_ ) + , pViewOffsets( pViewOffsets_ ) + , correlationMaskCount( correlationMaskCount_ ) + , pCorrelationMasks( pCorrelationMasks_ ) + { + } + + RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) ); + } + + RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) ); + return *this; + } + RenderPassMultiviewCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassMultiviewCreateInfo& setSubpassCount( uint32_t subpassCount_ ) + { + subpassCount = subpassCount_; + return *this; + } + + RenderPassMultiviewCreateInfo& setPViewMasks( const uint32_t* pViewMasks_ ) + { + pViewMasks = pViewMasks_; + return *this; + } + + RenderPassMultiviewCreateInfo& setDependencyCount( uint32_t dependencyCount_ ) + { + dependencyCount = dependencyCount_; + return *this; + } + + RenderPassMultiviewCreateInfo& setPViewOffsets( const int32_t* pViewOffsets_ ) + { + pViewOffsets = pViewOffsets_; + return *this; + } + + RenderPassMultiviewCreateInfo& setCorrelationMaskCount( uint32_t correlationMaskCount_ ) + { + correlationMaskCount = correlationMaskCount_; + return *this; + } + + RenderPassMultiviewCreateInfo& setPCorrelationMasks( const uint32_t* pCorrelationMasks_ ) + { + pCorrelationMasks = pCorrelationMasks_; + return *this; + } + + operator const VkRenderPassMultiviewCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( RenderPassMultiviewCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( subpassCount == rhs.subpassCount ) + && ( pViewMasks == rhs.pViewMasks ) + && ( dependencyCount == rhs.dependencyCount ) + && ( pViewOffsets == rhs.pViewOffsets ) + && ( correlationMaskCount == rhs.correlationMaskCount ) + && ( pCorrelationMasks == rhs.pCorrelationMasks ); + } + + bool operator!=( RenderPassMultiviewCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; + + public: + const void* pNext = nullptr; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; + }; + static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" ); + + using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; + + struct BindBufferMemoryInfo + { + BindBufferMemoryInfo( Buffer buffer_ = Buffer(), + DeviceMemory memory_ = DeviceMemory(), + DeviceSize memoryOffset_ = 0 ) + : buffer( buffer_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + { + } + + BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) ); + } + + BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) ); + return *this; + } + BindBufferMemoryInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindBufferMemoryInfo& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + BindBufferMemoryInfo& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + BindBufferMemoryInfo& setMemoryOffset( DeviceSize memoryOffset_ ) + { + memoryOffset = memoryOffset_; + return *this; + } + + operator const VkBindBufferMemoryInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BindBufferMemoryInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( buffer == rhs.buffer ) + && ( memory == rhs.memory ) + && ( memoryOffset == rhs.memoryOffset ); + } + + bool operator!=( BindBufferMemoryInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindBufferMemoryInfo; + + public: + const void* pNext = nullptr; + Buffer buffer; + DeviceMemory memory; + DeviceSize memoryOffset; + }; + static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" ); + + using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; + + struct BindBufferMemoryDeviceGroupInfo + { + BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, + const uint32_t* pDeviceIndices_ = nullptr ) + : deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) + { + } + + BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) ); + } + + BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) ); + return *this; + } + BindBufferMemoryDeviceGroupInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindBufferMemoryDeviceGroupInfo& setDeviceIndexCount( uint32_t deviceIndexCount_ ) + { + deviceIndexCount = deviceIndexCount_; + return *this; + } + + BindBufferMemoryDeviceGroupInfo& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) + { + pDeviceIndices = pDeviceIndices_; + return *this; + } + + operator const VkBindBufferMemoryDeviceGroupInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BindBufferMemoryDeviceGroupInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( deviceIndexCount == rhs.deviceIndexCount ) + && ( pDeviceIndices == rhs.pDeviceIndices ); + } + + bool operator!=( BindBufferMemoryDeviceGroupInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; + + public: + const void* pNext = nullptr; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + }; + static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); + + using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; + + struct BindImageMemoryInfo + { + BindImageMemoryInfo( Image image_ = Image(), + DeviceMemory memory_ = DeviceMemory(), + DeviceSize memoryOffset_ = 0 ) + : image( image_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + { + } + + BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) ); + } + + BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) ); + return *this; + } + BindImageMemoryInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindImageMemoryInfo& setImage( Image image_ ) + { + image = image_; + return *this; + } + + BindImageMemoryInfo& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + BindImageMemoryInfo& setMemoryOffset( DeviceSize memoryOffset_ ) + { + memoryOffset = memoryOffset_; + return *this; + } + + operator const VkBindImageMemoryInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BindImageMemoryInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ) + && ( memory == rhs.memory ) + && ( memoryOffset == rhs.memoryOffset ); + } + + bool operator!=( BindImageMemoryInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindImageMemoryInfo; + + public: + const void* pNext = nullptr; + Image image; + DeviceMemory memory; + DeviceSize memoryOffset; + }; + static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" ); + + using BindImageMemoryInfoKHR = BindImageMemoryInfo; + + struct BindImageMemoryDeviceGroupInfo + { + BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, + const uint32_t* pDeviceIndices_ = nullptr, + uint32_t splitInstanceBindRegionCount_ = 0, + const Rect2D* pSplitInstanceBindRegions_ = nullptr ) + : deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) + , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ ) + , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ ) + { + } + + BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) ); + } + + BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) ); + return *this; + } + BindImageMemoryDeviceGroupInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindImageMemoryDeviceGroupInfo& setDeviceIndexCount( uint32_t deviceIndexCount_ ) + { + deviceIndexCount = deviceIndexCount_; + return *this; + } + + BindImageMemoryDeviceGroupInfo& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) + { + pDeviceIndices = pDeviceIndices_; + return *this; + } + + BindImageMemoryDeviceGroupInfo& setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) + { + splitInstanceBindRegionCount = splitInstanceBindRegionCount_; + return *this; + } + + BindImageMemoryDeviceGroupInfo& setPSplitInstanceBindRegions( const Rect2D* pSplitInstanceBindRegions_ ) + { + pSplitInstanceBindRegions = pSplitInstanceBindRegions_; + return *this; + } + + operator const VkBindImageMemoryDeviceGroupInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BindImageMemoryDeviceGroupInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( deviceIndexCount == rhs.deviceIndexCount ) + && ( pDeviceIndices == rhs.pDeviceIndices ) + && ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) + && ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions ); + } + + bool operator!=( BindImageMemoryDeviceGroupInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; + + public: + const void* pNext = nullptr; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const Rect2D* pSplitInstanceBindRegions; + }; + static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); + + using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; + + struct DeviceGroupRenderPassBeginInfo + { + DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0, + uint32_t deviceRenderAreaCount_ = 0, + const Rect2D* pDeviceRenderAreas_ = nullptr ) + : deviceMask( deviceMask_ ) + , deviceRenderAreaCount( deviceRenderAreaCount_ ) + , pDeviceRenderAreas( pDeviceRenderAreas_ ) + { + } + + DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) ); + } + + DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) ); + return *this; + } + DeviceGroupRenderPassBeginInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGroupRenderPassBeginInfo& setDeviceMask( uint32_t deviceMask_ ) + { + deviceMask = deviceMask_; + return *this; + } + + DeviceGroupRenderPassBeginInfo& setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ ) + { + deviceRenderAreaCount = deviceRenderAreaCount_; + return *this; + } + + DeviceGroupRenderPassBeginInfo& setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ ) + { + pDeviceRenderAreas = pDeviceRenderAreas_; + return *this; + } + + operator const VkDeviceGroupRenderPassBeginInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupRenderPassBeginInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( deviceMask == rhs.deviceMask ) + && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) + && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); + } + + bool operator!=( DeviceGroupRenderPassBeginInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; + + public: + const void* pNext = nullptr; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const Rect2D* pDeviceRenderAreas; + }; + static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" ); + + using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; + + struct DeviceGroupCommandBufferBeginInfo + { + DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) + : deviceMask( deviceMask_ ) + { + } + + DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) ); + } + + DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) ); + return *this; + } + DeviceGroupCommandBufferBeginInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGroupCommandBufferBeginInfo& setDeviceMask( uint32_t deviceMask_ ) + { + deviceMask = deviceMask_; + return *this; + } + + operator const VkDeviceGroupCommandBufferBeginInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupCommandBufferBeginInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( deviceMask == rhs.deviceMask ); + } + + bool operator!=( DeviceGroupCommandBufferBeginInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; + + public: + const void* pNext = nullptr; + uint32_t deviceMask; + }; + static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" ); + + using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; + + struct DeviceGroupSubmitInfo + { + DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0, + const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, + uint32_t commandBufferCount_ = 0, + const uint32_t* pCommandBufferDeviceMasks_ = nullptr, + uint32_t signalSemaphoreCount_ = 0, + const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) + , commandBufferCount( commandBufferCount_ ) + , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ ) + { + } + + DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) ); + } + + DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) ); + return *this; + } + DeviceGroupSubmitInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGroupSubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + DeviceGroupSubmitInfo& setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ ) + { + pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_; + return *this; + } + + DeviceGroupSubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) + { + commandBufferCount = commandBufferCount_; + return *this; + } + + DeviceGroupSubmitInfo& setPCommandBufferDeviceMasks( const uint32_t* pCommandBufferDeviceMasks_ ) + { + pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_; + return *this; + } + + DeviceGroupSubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) + { + signalSemaphoreCount = signalSemaphoreCount_; + return *this; + } + + DeviceGroupSubmitInfo& setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ ) + { + pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_; + return *this; + } + + operator const VkDeviceGroupSubmitInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupSubmitInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) + && ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) + && ( commandBufferCount == rhs.commandBufferCount ) + && ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) + && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) + && ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices ); + } + + bool operator!=( DeviceGroupSubmitInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupSubmitInfo; + + public: + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; + }; + static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" ); + + using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; + + struct DeviceGroupBindSparseInfo + { + DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0, + uint32_t memoryDeviceIndex_ = 0 ) + : resourceDeviceIndex( resourceDeviceIndex_ ) + , memoryDeviceIndex( memoryDeviceIndex_ ) + { + } + + DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) ); + } + + DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) ); + return *this; + } + DeviceGroupBindSparseInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGroupBindSparseInfo& setResourceDeviceIndex( uint32_t resourceDeviceIndex_ ) + { + resourceDeviceIndex = resourceDeviceIndex_; + return *this; + } + + DeviceGroupBindSparseInfo& setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ ) + { + memoryDeviceIndex = memoryDeviceIndex_; + return *this; + } + + operator const VkDeviceGroupBindSparseInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupBindSparseInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) + && ( memoryDeviceIndex == rhs.memoryDeviceIndex ); + } + + bool operator!=( DeviceGroupBindSparseInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupBindSparseInfo; + + public: + const void* pNext = nullptr; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; + }; + static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" ); + + using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; + + struct ImageSwapchainCreateInfoKHR + { + ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR() ) + : swapchain( swapchain_ ) + { + } + + ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) ); + } + + ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) ); + return *this; + } + ImageSwapchainCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageSwapchainCreateInfoKHR& setSwapchain( SwapchainKHR swapchain_ ) + { + swapchain = swapchain_; + return *this; + } + + operator const VkImageSwapchainCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageSwapchainCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( swapchain == rhs.swapchain ); + } + + bool operator!=( ImageSwapchainCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; + + public: + const void* pNext = nullptr; + SwapchainKHR swapchain; + }; + static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); + + struct BindImageMemorySwapchainInfoKHR + { + BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(), + uint32_t imageIndex_ = 0 ) + : swapchain( swapchain_ ) + , imageIndex( imageIndex_ ) + { + } + + BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) ); + } + + BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) ); + return *this; + } + BindImageMemorySwapchainInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindImageMemorySwapchainInfoKHR& setSwapchain( SwapchainKHR swapchain_ ) + { + swapchain = swapchain_; + return *this; + } + + BindImageMemorySwapchainInfoKHR& setImageIndex( uint32_t imageIndex_ ) + { + imageIndex = imageIndex_; + return *this; + } + + operator const VkBindImageMemorySwapchainInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BindImageMemorySwapchainInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( swapchain == rhs.swapchain ) + && ( imageIndex == rhs.imageIndex ); + } + + bool operator!=( BindImageMemorySwapchainInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; + + public: + const void* pNext = nullptr; + SwapchainKHR swapchain; + uint32_t imageIndex; + }; + static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" ); + + struct AcquireNextImageInfoKHR + { + AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(), + uint64_t timeout_ = 0, + Semaphore semaphore_ = Semaphore(), + Fence fence_ = Fence(), + uint32_t deviceMask_ = 0 ) + : swapchain( swapchain_ ) + , timeout( timeout_ ) + , semaphore( semaphore_ ) + , fence( fence_ ) + , deviceMask( deviceMask_ ) + { + } + + AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) ); + } + + AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) ); + return *this; + } + AcquireNextImageInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AcquireNextImageInfoKHR& setSwapchain( SwapchainKHR swapchain_ ) + { + swapchain = swapchain_; + return *this; + } + + AcquireNextImageInfoKHR& setTimeout( uint64_t timeout_ ) + { + timeout = timeout_; + return *this; + } + + AcquireNextImageInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + AcquireNextImageInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + AcquireNextImageInfoKHR& setDeviceMask( uint32_t deviceMask_ ) + { + deviceMask = deviceMask_; + return *this; + } + + operator const VkAcquireNextImageInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AcquireNextImageInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( swapchain == rhs.swapchain ) + && ( timeout == rhs.timeout ) + && ( semaphore == rhs.semaphore ) + && ( fence == rhs.fence ) + && ( deviceMask == rhs.deviceMask ); + } + + bool operator!=( AcquireNextImageInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAcquireNextImageInfoKHR; + + public: + const void* pNext = nullptr; + SwapchainKHR swapchain; + uint64_t timeout; + Semaphore semaphore; + Fence fence; + uint32_t deviceMask; + }; + static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" ); + + struct HdrMetadataEXT + { + HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(), + XYColorEXT displayPrimaryGreen_ = XYColorEXT(), + XYColorEXT displayPrimaryBlue_ = XYColorEXT(), + XYColorEXT whitePoint_ = XYColorEXT(), + float maxLuminance_ = 0, + float minLuminance_ = 0, + float maxContentLightLevel_ = 0, + float maxFrameAverageLightLevel_ = 0 ) + : displayPrimaryRed( displayPrimaryRed_ ) + , displayPrimaryGreen( displayPrimaryGreen_ ) + , displayPrimaryBlue( displayPrimaryBlue_ ) + , whitePoint( whitePoint_ ) + , maxLuminance( maxLuminance_ ) + , minLuminance( minLuminance_ ) + , maxContentLightLevel( maxContentLightLevel_ ) + , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ ) + { + } + + HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); + } + + HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); + return *this; + } + HdrMetadataEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + HdrMetadataEXT& setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ ) + { + displayPrimaryRed = displayPrimaryRed_; + return *this; + } + + HdrMetadataEXT& setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ ) + { + displayPrimaryGreen = displayPrimaryGreen_; + return *this; + } + + HdrMetadataEXT& setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ ) + { + displayPrimaryBlue = displayPrimaryBlue_; + return *this; + } + + HdrMetadataEXT& setWhitePoint( XYColorEXT whitePoint_ ) + { + whitePoint = whitePoint_; + return *this; + } + + HdrMetadataEXT& setMaxLuminance( float maxLuminance_ ) + { + maxLuminance = maxLuminance_; + return *this; + } + + HdrMetadataEXT& setMinLuminance( float minLuminance_ ) + { + minLuminance = minLuminance_; + return *this; + } + + HdrMetadataEXT& setMaxContentLightLevel( float maxContentLightLevel_ ) + { + maxContentLightLevel = maxContentLightLevel_; + return *this; + } + + HdrMetadataEXT& setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) + { + maxFrameAverageLightLevel = maxFrameAverageLightLevel_; + return *this; + } + + operator const VkHdrMetadataEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( HdrMetadataEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( displayPrimaryRed == rhs.displayPrimaryRed ) + && ( displayPrimaryGreen == rhs.displayPrimaryGreen ) + && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) + && ( whitePoint == rhs.whitePoint ) + && ( maxLuminance == rhs.maxLuminance ) + && ( minLuminance == rhs.minLuminance ) + && ( maxContentLightLevel == rhs.maxContentLightLevel ) + && ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel ); + } + + bool operator!=( HdrMetadataEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eHdrMetadataEXT; + + public: + const void* pNext = nullptr; + XYColorEXT displayPrimaryRed; + XYColorEXT displayPrimaryGreen; + XYColorEXT displayPrimaryBlue; + XYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; + }; + static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); + + struct PresentTimesInfoGOOGLE + { + PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, + const PresentTimeGOOGLE* pTimes_ = nullptr ) + : swapchainCount( swapchainCount_ ) + , pTimes( pTimes_ ) + { + } + + PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); + } + + PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); + return *this; + } + PresentTimesInfoGOOGLE& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PresentTimesInfoGOOGLE& setSwapchainCount( uint32_t swapchainCount_ ) + { + swapchainCount = swapchainCount_; + return *this; + } + + PresentTimesInfoGOOGLE& setPTimes( const PresentTimeGOOGLE* pTimes_ ) + { + pTimes = pTimes_; + return *this; + } + + operator const VkPresentTimesInfoGOOGLE&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PresentTimesInfoGOOGLE const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( swapchainCount == rhs.swapchainCount ) + && ( pTimes == rhs.pTimes ); + } + + bool operator!=( PresentTimesInfoGOOGLE const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePresentTimesInfoGOOGLE; + + public: + const void* pNext = nullptr; + uint32_t swapchainCount; + const PresentTimeGOOGLE* pTimes; + }; + static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_IOS_MVK + struct IOSSurfaceCreateInfoMVK + { + IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), + const void* pView_ = nullptr ) + : flags( flags_ ) + , pView( pView_ ) + { + } + + IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) + { + memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); + } + + IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) + { + memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); + return *this; + } + IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + IOSSurfaceCreateInfoMVK& setFlags( IOSSurfaceCreateFlagsMVK flags_ ) + { + flags = flags_; + return *this; + } + + IOSSurfaceCreateInfoMVK& setPView( const void* pView_ ) + { + pView = pView_; + return *this; + } + + operator const VkIOSSurfaceCreateInfoMVK&() const + { + return *reinterpret_cast(this); + } + + bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( pView == rhs.pView ); + } + + bool operator!=( IOSSurfaceCreateInfoMVK const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; + + public: + const void* pNext = nullptr; + IOSSurfaceCreateFlagsMVK flags; + const void* pView; + }; + static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + struct MacOSSurfaceCreateInfoMVK + { + MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), + const void* pView_ = nullptr ) + : flags( flags_ ) + , pView( pView_ ) + { + } + + MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) + { + memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); + } + + MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) + { + memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); + return *this; + } + MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MacOSSurfaceCreateInfoMVK& setFlags( MacOSSurfaceCreateFlagsMVK flags_ ) + { + flags = flags_; + return *this; + } + + MacOSSurfaceCreateInfoMVK& setPView( const void* pView_ ) + { + pView = pView_; + return *this; + } + + operator const VkMacOSSurfaceCreateInfoMVK&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( pView == rhs.pView ); + } + + bool operator!=( MacOSSurfaceCreateInfoMVK const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; + + public: + const void* pNext = nullptr; + MacOSSurfaceCreateFlagsMVK flags; + const void* pView; + }; + static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + struct PipelineViewportWScalingStateCreateInfoNV + { + PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, + uint32_t viewportCount_ = 0, + const ViewportWScalingNV* pViewportWScalings_ = nullptr ) + : viewportWScalingEnable( viewportWScalingEnable_ ) + , viewportCount( viewportCount_ ) + , pViewportWScalings( pViewportWScalings_ ) + { + } + + PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); + } + + PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); + return *this; + } + PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineViewportWScalingStateCreateInfoNV& setViewportWScalingEnable( Bool32 viewportWScalingEnable_ ) + { + viewportWScalingEnable = viewportWScalingEnable_; + return *this; + } + + PipelineViewportWScalingStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ ) + { + viewportCount = viewportCount_; + return *this; + } + + PipelineViewportWScalingStateCreateInfoNV& setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ ) + { + pViewportWScalings = pViewportWScalings_; + return *this; + } + + operator const VkPipelineViewportWScalingStateCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( viewportWScalingEnable == rhs.viewportWScalingEnable ) + && ( viewportCount == rhs.viewportCount ) + && ( pViewportWScalings == rhs.pViewportWScalings ); + } + + bool operator!=( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; + + public: + const void* pNext = nullptr; + Bool32 viewportWScalingEnable; + uint32_t viewportCount; + const ViewportWScalingNV* pViewportWScalings; + }; + static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceDiscardRectanglePropertiesEXT + { + PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 ) + : maxDiscardRectangles( maxDiscardRectangles_ ) + { + } + + PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); + } + + PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); + return *this; + } + PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceDiscardRectanglePropertiesEXT& setMaxDiscardRectangles( uint32_t maxDiscardRectangles_ ) + { + maxDiscardRectangles = maxDiscardRectangles_; + return *this; + } + + operator const VkPhysicalDeviceDiscardRectanglePropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); + } + + bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t maxDiscardRectangles; + }; + static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + { + operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); + } + + bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + public: + void* pNext = nullptr; + Bool32 perViewPositionAllComponents; + }; + static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceSurfaceInfo2KHR + { + PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() ) + : surface( surface_ ) + { + } + + PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); + } + + PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); + return *this; + } + PhysicalDeviceSurfaceInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceSurfaceInfo2KHR& setSurface( SurfaceKHR surface_ ) + { + surface = surface_; + return *this; + } + + operator const VkPhysicalDeviceSurfaceInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surface == rhs.surface ); + } + + bool operator!=( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; + + public: + const void* pNext = nullptr; + SurfaceKHR surface; + }; + static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); + + struct DisplayPlaneProperties2KHR + { + operator const VkDisplayPlaneProperties2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPlaneProperties2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( displayPlaneProperties == rhs.displayPlaneProperties ); + } + + bool operator!=( DisplayPlaneProperties2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayPlaneProperties2KHR; + + public: + void* pNext = nullptr; + DisplayPlanePropertiesKHR displayPlaneProperties; + }; + static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" ); + + struct DisplayModeProperties2KHR + { + operator const VkDisplayModeProperties2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayModeProperties2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( displayModeProperties == rhs.displayModeProperties ); + } + + bool operator!=( DisplayModeProperties2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayModeProperties2KHR; + + public: + void* pNext = nullptr; + DisplayModePropertiesKHR displayModeProperties; + }; + static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" ); + + struct DisplayPlaneInfo2KHR + { + DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = DisplayModeKHR(), + uint32_t planeIndex_ = 0 ) + : mode( mode_ ) + , planeIndex( planeIndex_ ) + { + } + + DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) ); + } + + DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) ); + return *this; + } + DisplayPlaneInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DisplayPlaneInfo2KHR& setMode( DisplayModeKHR mode_ ) + { + mode = mode_; + return *this; + } + + DisplayPlaneInfo2KHR& setPlaneIndex( uint32_t planeIndex_ ) + { + planeIndex = planeIndex_; + return *this; + } + + operator const VkDisplayPlaneInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPlaneInfo2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( mode == rhs.mode ) + && ( planeIndex == rhs.planeIndex ); + } + + bool operator!=( DisplayPlaneInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayPlaneInfo2KHR; + + public: + const void* pNext = nullptr; + DisplayModeKHR mode; + uint32_t planeIndex; + }; + static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" ); + + struct PhysicalDevice16BitStorageFeatures + { + PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = 0, + Bool32 uniformAndStorageBuffer16BitAccess_ = 0, + Bool32 storagePushConstant16_ = 0, + Bool32 storageInputOutput16_ = 0 ) + : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) + , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) + , storagePushConstant16( storagePushConstant16_ ) + , storageInputOutput16( storageInputOutput16_ ) + { + } + + PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) ); + } + + PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) ); + return *this; + } + PhysicalDevice16BitStorageFeatures& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDevice16BitStorageFeatures& setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) + { + storageBuffer16BitAccess = storageBuffer16BitAccess_; + return *this; + } + + PhysicalDevice16BitStorageFeatures& setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) + { + uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; + return *this; + } + + PhysicalDevice16BitStorageFeatures& setStoragePushConstant16( Bool32 storagePushConstant16_ ) + { + storagePushConstant16 = storagePushConstant16_; + return *this; + } + + PhysicalDevice16BitStorageFeatures& setStorageInputOutput16( Bool32 storageInputOutput16_ ) + { + storageInputOutput16 = storageInputOutput16_; + return *this; + } + + operator const VkPhysicalDevice16BitStorageFeatures&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDevice16BitStorageFeatures const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) + && ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) + && ( storagePushConstant16 == rhs.storagePushConstant16 ) + && ( storageInputOutput16 == rhs.storageInputOutput16 ); + } + + bool operator!=( PhysicalDevice16BitStorageFeatures const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; + + public: + void* pNext = nullptr; + Bool32 storageBuffer16BitAccess; + Bool32 uniformAndStorageBuffer16BitAccess; + Bool32 storagePushConstant16; + Bool32 storageInputOutput16; + }; + static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" ); + + using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; + + struct BufferMemoryRequirementsInfo2 + { + BufferMemoryRequirementsInfo2( Buffer buffer_ = Buffer() ) + : buffer( buffer_ ) + { + } + + BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) ); + } + + BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) ); + return *this; + } + BufferMemoryRequirementsInfo2& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BufferMemoryRequirementsInfo2& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator const VkBufferMemoryRequirementsInfo2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferMemoryRequirementsInfo2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( BufferMemoryRequirementsInfo2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; + + public: + const void* pNext = nullptr; + Buffer buffer; + }; + static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); + + using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; + + struct ImageMemoryRequirementsInfo2 + { + ImageMemoryRequirementsInfo2( Image image_ = Image() ) + : image( image_ ) + { + } + + ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) ); + } + + ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) ); + return *this; + } + ImageMemoryRequirementsInfo2& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageMemoryRequirementsInfo2& setImage( Image image_ ) + { + image = image_; + return *this; + } + + operator const VkImageMemoryRequirementsInfo2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageMemoryRequirementsInfo2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ); + } + + bool operator!=( ImageMemoryRequirementsInfo2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageMemoryRequirementsInfo2; + + public: + const void* pNext = nullptr; + Image image; + }; + static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); + + using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; + + struct ImageSparseMemoryRequirementsInfo2 + { + ImageSparseMemoryRequirementsInfo2( Image image_ = Image() ) + : image( image_ ) + { + } + + ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) ); + } + + ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) ); + return *this; + } + ImageSparseMemoryRequirementsInfo2& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageSparseMemoryRequirementsInfo2& setImage( Image image_ ) + { + image = image_; + return *this; + } + + operator const VkImageSparseMemoryRequirementsInfo2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageSparseMemoryRequirementsInfo2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ); + } + + bool operator!=( ImageSparseMemoryRequirementsInfo2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; + + public: + const void* pNext = nullptr; + Image image; + }; + static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); + + using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; + + struct MemoryRequirements2 + { + operator const VkMemoryRequirements2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryRequirements2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryRequirements == rhs.memoryRequirements ); + } + + bool operator!=( MemoryRequirements2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryRequirements2; + + public: + void* pNext = nullptr; + MemoryRequirements memoryRequirements; + }; + static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" ); + + using MemoryRequirements2KHR = MemoryRequirements2; + + struct MemoryDedicatedRequirements + { + operator const VkMemoryDedicatedRequirements&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryDedicatedRequirements const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) + && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); + } + + bool operator!=( MemoryDedicatedRequirements const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryDedicatedRequirements; + + public: + void* pNext = nullptr; + Bool32 prefersDedicatedAllocation; + Bool32 requiresDedicatedAllocation; + }; + static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" ); + + using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; + + struct MemoryDedicatedAllocateInfo + { + MemoryDedicatedAllocateInfo( Image image_ = Image(), + Buffer buffer_ = Buffer() ) + : image( image_ ) + , buffer( buffer_ ) + { + } + + MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) ); + } + + MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) ); + return *this; + } + MemoryDedicatedAllocateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryDedicatedAllocateInfo& setImage( Image image_ ) + { + image = image_; + return *this; + } + + MemoryDedicatedAllocateInfo& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator const VkMemoryDedicatedAllocateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryDedicatedAllocateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( MemoryDedicatedAllocateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; + + public: + const void* pNext = nullptr; + Image image; + Buffer buffer; + }; + static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" ); + + using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; + + struct SamplerYcbcrConversionInfo + { + SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = SamplerYcbcrConversion() ) + : conversion( conversion_ ) + { + } + + SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) ); + } + + SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) ); + return *this; + } + SamplerYcbcrConversionInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SamplerYcbcrConversionInfo& setConversion( SamplerYcbcrConversion conversion_ ) + { + conversion = conversion_; + return *this; + } + + operator const VkSamplerYcbcrConversionInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SamplerYcbcrConversionInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( conversion == rhs.conversion ); + } + + bool operator!=( SamplerYcbcrConversionInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSamplerYcbcrConversionInfo; + + public: + const void* pNext = nullptr; + SamplerYcbcrConversion conversion; + }; + static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" ); + + using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; + + struct PhysicalDeviceSamplerYcbcrConversionFeatures + { + PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = 0 ) + : samplerYcbcrConversion( samplerYcbcrConversion_ ) + { + } + + PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) ); + } + + PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) ); + return *this; + } + PhysicalDeviceSamplerYcbcrConversionFeatures& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceSamplerYcbcrConversionFeatures& setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) + { + samplerYcbcrConversion = samplerYcbcrConversion_; + return *this; + } + + operator const VkPhysicalDeviceSamplerYcbcrConversionFeatures&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); + } + + bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; + + public: + void* pNext = nullptr; + Bool32 samplerYcbcrConversion; + }; + static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" ); + + using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; + + struct SamplerYcbcrConversionImageFormatProperties + { + operator const VkSamplerYcbcrConversionImageFormatProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SamplerYcbcrConversionImageFormatProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); + } + + bool operator!=( SamplerYcbcrConversionImageFormatProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; + + public: + void* pNext = nullptr; + uint32_t combinedImageSamplerDescriptorCount; + }; + static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" ); + + using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; + + struct TextureLODGatherFormatPropertiesAMD + { + operator const VkTextureLODGatherFormatPropertiesAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); + } + + bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; + + public: + void* pNext = nullptr; + Bool32 supportsTextureGatherLODBiasAMD; + }; + static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); + + struct ProtectedSubmitInfo + { + ProtectedSubmitInfo( Bool32 protectedSubmit_ = 0 ) + : protectedSubmit( protectedSubmit_ ) + { + } + + ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) ); + } + + ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) ); + return *this; + } + ProtectedSubmitInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ProtectedSubmitInfo& setProtectedSubmit( Bool32 protectedSubmit_ ) + { + protectedSubmit = protectedSubmit_; + return *this; + } + + operator const VkProtectedSubmitInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ProtectedSubmitInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( protectedSubmit == rhs.protectedSubmit ); + } + + bool operator!=( ProtectedSubmitInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eProtectedSubmitInfo; + + public: + const void* pNext = nullptr; + Bool32 protectedSubmit; + }; + static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceProtectedMemoryFeatures + { + PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = 0 ) + : protectedMemory( protectedMemory_ ) + { + } + + PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) ); + } + + PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) ); + return *this; + } + PhysicalDeviceProtectedMemoryFeatures& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceProtectedMemoryFeatures& setProtectedMemory( Bool32 protectedMemory_ ) + { + protectedMemory = protectedMemory_; + return *this; + } + + operator const VkPhysicalDeviceProtectedMemoryFeatures&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( protectedMemory == rhs.protectedMemory ); + } + + bool operator!=( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; + + public: + void* pNext = nullptr; + Bool32 protectedMemory; + }; + static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceProtectedMemoryProperties + { + PhysicalDeviceProtectedMemoryProperties( Bool32 protectedNoFault_ = 0 ) + : protectedNoFault( protectedNoFault_ ) + { + } + + PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) ); + } + + PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) ); + return *this; + } + PhysicalDeviceProtectedMemoryProperties& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceProtectedMemoryProperties& setProtectedNoFault( Bool32 protectedNoFault_ ) + { + protectedNoFault = protectedNoFault_; + return *this; + } + + operator const VkPhysicalDeviceProtectedMemoryProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceProtectedMemoryProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( protectedNoFault == rhs.protectedNoFault ); + } + + bool operator!=( PhysicalDeviceProtectedMemoryProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; + + public: + void* pNext = nullptr; + Bool32 protectedNoFault; + }; + static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" ); + + struct PipelineCoverageToColorStateCreateInfoNV + { + PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), + Bool32 coverageToColorEnable_ = 0, + uint32_t coverageToColorLocation_ = 0 ) + : flags( flags_ ) + , coverageToColorEnable( coverageToColorEnable_ ) + , coverageToColorLocation( coverageToColorLocation_ ) + { + } + + PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); + } + + PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); + return *this; + } + PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) + { + coverageToColorEnable = coverageToColorEnable_; + return *this; + } + + PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) + { + coverageToColorLocation = coverageToColorLocation_; + return *this; + } + + operator const VkPipelineCoverageToColorStateCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( coverageToColorEnable == rhs.coverageToColorEnable ) + && ( coverageToColorLocation == rhs.coverageToColorLocation ); + } + + bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; + + public: + const void* pNext = nullptr; + PipelineCoverageToColorStateCreateFlagsNV flags; + Bool32 coverageToColorEnable; + uint32_t coverageToColorLocation; + }; + static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT + { + operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) + && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); + } + + bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + public: + void* pNext = nullptr; + Bool32 filterMinmaxSingleComponentFormats; + Bool32 filterMinmaxImageComponentMapping; + }; + static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); + + struct MultisamplePropertiesEXT + { + operator const VkMultisamplePropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MultisamplePropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); + } + + bool operator!=( MultisamplePropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMultisamplePropertiesEXT; + + public: + void* pNext = nullptr; + Extent2D maxSampleLocationGridSize; + }; + static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT + { + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 ) + : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) + { + } + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); + } + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); + return *this; + } + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) + { + advancedBlendCoherentOperations = advancedBlendCoherentOperations_; + return *this; + } + + operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); + } + + bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 advancedBlendCoherentOperations; + }; + static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT + { + operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) + && ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) + && ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) + && ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) + && ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) + && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); + } + + bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t advancedBlendMaxColorAttachments; + Bool32 advancedBlendIndependentBlend; + Bool32 advancedBlendNonPremultipliedSrcColor; + Bool32 advancedBlendNonPremultipliedDstColor; + Bool32 advancedBlendCorrelatedOverlap; + Bool32 advancedBlendAllOperations; + }; + static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); + + struct ImageFormatListCreateInfoKHR + { + ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, + const Format* pViewFormats_ = nullptr ) + : viewFormatCount( viewFormatCount_ ) + , pViewFormats( pViewFormats_ ) + { + } + + ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) ); + } + + ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) ); + return *this; + } + ImageFormatListCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageFormatListCreateInfoKHR& setViewFormatCount( uint32_t viewFormatCount_ ) + { + viewFormatCount = viewFormatCount_; + return *this; + } + + ImageFormatListCreateInfoKHR& setPViewFormats( const Format* pViewFormats_ ) + { + pViewFormats = pViewFormats_; + return *this; + } + + operator const VkImageFormatListCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( viewFormatCount == rhs.viewFormatCount ) + && ( pViewFormats == rhs.pViewFormats ); + } + + bool operator!=( ImageFormatListCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageFormatListCreateInfoKHR; + + public: + const void* pNext = nullptr; + uint32_t viewFormatCount; + const Format* pViewFormats; + }; + static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" ); + + struct ValidationCacheCreateInfoEXT + { + ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(), + size_t initialDataSize_ = 0, + const void* pInitialData_ = nullptr ) + : flags( flags_ ) + , initialDataSize( initialDataSize_ ) + , pInitialData( pInitialData_ ) + { + } + + ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) ); + } + + ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) ); + return *this; + } + ValidationCacheCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ValidationCacheCreateInfoEXT& setFlags( ValidationCacheCreateFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + ValidationCacheCreateInfoEXT& setInitialDataSize( size_t initialDataSize_ ) + { + initialDataSize = initialDataSize_; + return *this; + } + + ValidationCacheCreateInfoEXT& setPInitialData( const void* pInitialData_ ) + { + pInitialData = pInitialData_; + return *this; + } + + operator const VkValidationCacheCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( initialDataSize == rhs.initialDataSize ) + && ( pInitialData == rhs.pInitialData ); + } + + bool operator!=( ValidationCacheCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eValidationCacheCreateInfoEXT; + + public: + const void* pNext = nullptr; + ValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; + }; + static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct ShaderModuleValidationCacheCreateInfoEXT + { + ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() ) + : validationCache( validationCache_ ) + { + } + + ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) ); + } + + ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) ); + return *this; + } + ShaderModuleValidationCacheCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ShaderModuleValidationCacheCreateInfoEXT& setValidationCache( ValidationCacheEXT validationCache_ ) + { + validationCache = validationCache_; + return *this; + } + + operator const VkShaderModuleValidationCacheCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( validationCache == rhs.validationCache ); + } + + bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; + + public: + const void* pNext = nullptr; + ValidationCacheEXT validationCache; + }; + static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceMaintenance3Properties + { + operator const VkPhysicalDeviceMaintenance3Properties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceMaintenance3Properties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) + && ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); + } + + bool operator!=( PhysicalDeviceMaintenance3Properties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; + + public: + void* pNext = nullptr; + uint32_t maxPerSetDescriptors; + DeviceSize maxMemoryAllocationSize; + }; + static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" ); + + using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; + + struct DescriptorSetLayoutSupport + { + operator const VkDescriptorSetLayoutSupport&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetLayoutSupport const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( supported == rhs.supported ); + } + + bool operator!=( DescriptorSetLayoutSupport const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorSetLayoutSupport; + + public: + void* pNext = nullptr; + Bool32 supported; + }; + static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" ); + + using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; + + struct PhysicalDeviceShaderDrawParameterFeatures + { + PhysicalDeviceShaderDrawParameterFeatures( Bool32 shaderDrawParameters_ = 0 ) + : shaderDrawParameters( shaderDrawParameters_ ) + { + } + + PhysicalDeviceShaderDrawParameterFeatures( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) ); + } + + PhysicalDeviceShaderDrawParameterFeatures& operator=( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) ); + return *this; + } + PhysicalDeviceShaderDrawParameterFeatures& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceShaderDrawParameterFeatures& setShaderDrawParameters( Bool32 shaderDrawParameters_ ) + { + shaderDrawParameters = shaderDrawParameters_; + return *this; + } + + operator const VkPhysicalDeviceShaderDrawParameterFeatures&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderDrawParameters == rhs.shaderDrawParameters ); + } + + bool operator!=( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShaderDrawParameterFeatures; + + public: + void* pNext = nullptr; + Bool32 shaderDrawParameters; + }; + static_assert( sizeof( PhysicalDeviceShaderDrawParameterFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParameterFeatures ), "struct and wrapper have different size!" ); + + struct DebugUtilsLabelEXT + { + DebugUtilsLabelEXT( const char* pLabelName_ = nullptr, + std::array const& color_ = { { 0, 0, 0, 0 } } ) + : pLabelName( pLabelName_ ) + { + memcpy( &color, color_.data(), 4 * sizeof( float ) ); + } + + DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) ); + } + + DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) ); + return *this; + } + DebugUtilsLabelEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugUtilsLabelEXT& setPLabelName( const char* pLabelName_ ) + { + pLabelName = pLabelName_; + return *this; + } + + DebugUtilsLabelEXT& setColor( std::array color_ ) + { + memcpy( &color, color_.data(), 4 * sizeof( float ) ); + return *this; + } + + operator const VkDebugUtilsLabelEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugUtilsLabelEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pLabelName == rhs.pLabelName ) + && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 ); + } + + bool operator!=( DebugUtilsLabelEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugUtilsLabelEXT; + + public: + const void* pNext = nullptr; + const char* pLabelName; + float color[4]; + }; + static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" ); + + struct MemoryHostPointerPropertiesEXT + { + MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 ) + : memoryTypeBits( memoryTypeBits_ ) + { + } + + MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) ); + } + + MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) ); + return *this; + } + MemoryHostPointerPropertiesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryHostPointerPropertiesEXT& setMemoryTypeBits( uint32_t memoryTypeBits_ ) + { + memoryTypeBits = memoryTypeBits_; + return *this; + } + + operator const VkMemoryHostPointerPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryTypeBits == rhs.memoryTypeBits ); + } + + bool operator!=( MemoryHostPointerPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t memoryTypeBits; + }; + static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceExternalMemoryHostPropertiesEXT + { + PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 ) + : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) + { + } + + PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) ); + } + + PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) ); + return *this; + } + PhysicalDeviceExternalMemoryHostPropertiesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExternalMemoryHostPropertiesEXT& setMinImportedHostPointerAlignment( DeviceSize minImportedHostPointerAlignment_ ) + { + minImportedHostPointerAlignment = minImportedHostPointerAlignment_; + return *this; + } + + operator const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); + } + + bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; + + public: + void* pNext = nullptr; + DeviceSize minImportedHostPointerAlignment; + }; + static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceConservativeRasterizationPropertiesEXT + { + PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0, + float maxExtraPrimitiveOverestimationSize_ = 0, + float extraPrimitiveOverestimationSizeGranularity_ = 0, + Bool32 primitiveUnderestimation_ = 0, + Bool32 conservativePointAndLineRasterization_ = 0, + Bool32 degenerateTrianglesRasterized_ = 0, + Bool32 degenerateLinesRasterized_ = 0, + Bool32 fullyCoveredFragmentShaderInputVariable_ = 0, + Bool32 conservativeRasterizationPostDepthCoverage_ = 0 ) + : primitiveOverestimationSize( primitiveOverestimationSize_ ) + , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ ) + , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ ) + , primitiveUnderestimation( primitiveUnderestimation_ ) + , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ ) + , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ ) + , degenerateLinesRasterized( degenerateLinesRasterized_ ) + , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ ) + , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ ) + { + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) ); + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) ); + return *this; + } + PhysicalDeviceConservativeRasterizationPropertiesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveOverestimationSize( float primitiveOverestimationSize_ ) + { + primitiveOverestimationSize = primitiveOverestimationSize_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setMaxExtraPrimitiveOverestimationSize( float maxExtraPrimitiveOverestimationSize_ ) + { + maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setExtraPrimitiveOverestimationSizeGranularity( float extraPrimitiveOverestimationSizeGranularity_ ) + { + extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveUnderestimation( Bool32 primitiveUnderestimation_ ) + { + primitiveUnderestimation = primitiveUnderestimation_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativePointAndLineRasterization( Bool32 conservativePointAndLineRasterization_ ) + { + conservativePointAndLineRasterization = conservativePointAndLineRasterization_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateTrianglesRasterized( Bool32 degenerateTrianglesRasterized_ ) + { + degenerateTrianglesRasterized = degenerateTrianglesRasterized_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateLinesRasterized( Bool32 degenerateLinesRasterized_ ) + { + degenerateLinesRasterized = degenerateLinesRasterized_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setFullyCoveredFragmentShaderInputVariable( Bool32 fullyCoveredFragmentShaderInputVariable_ ) + { + fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable_; + return *this; + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativeRasterizationPostDepthCoverage( Bool32 conservativeRasterizationPostDepthCoverage_ ) + { + conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage_; + return *this; + } + + operator const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) + && ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) + && ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) + && ( primitiveUnderestimation == rhs.primitiveUnderestimation ) + && ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) + && ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) + && ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) + && ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) + && ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage ); + } + + bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; + + public: + void* pNext = nullptr; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + Bool32 primitiveUnderestimation; + Bool32 conservativePointAndLineRasterization; + Bool32 degenerateTrianglesRasterized; + Bool32 degenerateLinesRasterized; + Bool32 fullyCoveredFragmentShaderInputVariable; + Bool32 conservativeRasterizationPostDepthCoverage; + }; + static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceShaderCorePropertiesAMD + { + operator const VkPhysicalDeviceShaderCorePropertiesAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderEngineCount == rhs.shaderEngineCount ) + && ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) + && ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) + && ( simdPerComputeUnit == rhs.simdPerComputeUnit ) + && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) + && ( wavefrontSize == rhs.wavefrontSize ) + && ( sgprsPerSimd == rhs.sgprsPerSimd ) + && ( minSgprAllocation == rhs.minSgprAllocation ) + && ( maxSgprAllocation == rhs.maxSgprAllocation ) + && ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) + && ( vgprsPerSimd == rhs.vgprsPerSimd ) + && ( minVgprAllocation == rhs.minVgprAllocation ) + && ( maxVgprAllocation == rhs.maxVgprAllocation ) + && ( vgprAllocationGranularity == rhs.vgprAllocationGranularity ); + } + + bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; + + public: + void* pNext = nullptr; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; + }; + static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceDescriptorIndexingFeaturesEXT + { + PhysicalDeviceDescriptorIndexingFeaturesEXT( Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0, + Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0, + Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0, + Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0, + Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0, + Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0, + Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0, + Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0, + Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0, + Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0, + Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0, + Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0, + Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0, + Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0, + Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0, + Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0, + Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0, + Bool32 descriptorBindingPartiallyBound_ = 0, + Bool32 descriptorBindingVariableDescriptorCount_ = 0, + Bool32 runtimeDescriptorArray_ = 0 ) + : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ ) + , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ ) + , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ ) + , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ ) + , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ ) + , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ ) + , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ ) + , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ ) + , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ ) + , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ ) + , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ ) + , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ ) + , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ ) + , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ ) + , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ ) + , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ ) + , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ ) + , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ ) + , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ ) + , runtimeDescriptorArray( runtimeDescriptorArray_ ) + { + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) ); + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) ); + return *this; + } + PhysicalDeviceDescriptorIndexingFeaturesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) + { + shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) + { + shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) + { + shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) + { + shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) + { + shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) + { + shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) + { + shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) + { + shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) + { + shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) + { + shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) + { + descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) + { + descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) + { + descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) + { + descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) + { + descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) + { + descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) + { + descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) + { + descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) + { + descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; + return *this; + } + + PhysicalDeviceDescriptorIndexingFeaturesEXT& setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) + { + runtimeDescriptorArray = runtimeDescriptorArray_; + return *this; + } + + operator const VkPhysicalDeviceDescriptorIndexingFeaturesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceDescriptorIndexingFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) + && ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) + && ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) + && ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) + && ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) + && ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) + && ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) + && ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) + && ( shaderUniformTexelBufferArrayNonUniformIndexing == rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) + && ( shaderStorageTexelBufferArrayNonUniformIndexing == rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) + && ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) + && ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) + && ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) + && ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) + && ( descriptorBindingUniformTexelBufferUpdateAfterBind == rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) + && ( descriptorBindingStorageTexelBufferUpdateAfterBind == rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) + && ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) + && ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) + && ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) + && ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ); + } + + bool operator!=( PhysicalDeviceDescriptorIndexingFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 shaderInputAttachmentArrayDynamicIndexing; + Bool32 shaderUniformTexelBufferArrayDynamicIndexing; + Bool32 shaderStorageTexelBufferArrayDynamicIndexing; + Bool32 shaderUniformBufferArrayNonUniformIndexing; + Bool32 shaderSampledImageArrayNonUniformIndexing; + Bool32 shaderStorageBufferArrayNonUniformIndexing; + Bool32 shaderStorageImageArrayNonUniformIndexing; + Bool32 shaderInputAttachmentArrayNonUniformIndexing; + Bool32 shaderUniformTexelBufferArrayNonUniformIndexing; + Bool32 shaderStorageTexelBufferArrayNonUniformIndexing; + Bool32 descriptorBindingUniformBufferUpdateAfterBind; + Bool32 descriptorBindingSampledImageUpdateAfterBind; + Bool32 descriptorBindingStorageImageUpdateAfterBind; + Bool32 descriptorBindingStorageBufferUpdateAfterBind; + Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + Bool32 descriptorBindingUpdateUnusedWhilePending; + Bool32 descriptorBindingPartiallyBound; + Bool32 descriptorBindingVariableDescriptorCount; + Bool32 runtimeDescriptorArray; + }; + static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceDescriptorIndexingPropertiesEXT + { + operator const VkPhysicalDeviceDescriptorIndexingPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceDescriptorIndexingPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) + && ( shaderUniformBufferArrayNonUniformIndexingNative == rhs.shaderUniformBufferArrayNonUniformIndexingNative ) + && ( shaderSampledImageArrayNonUniformIndexingNative == rhs.shaderSampledImageArrayNonUniformIndexingNative ) + && ( shaderStorageBufferArrayNonUniformIndexingNative == rhs.shaderStorageBufferArrayNonUniformIndexingNative ) + && ( shaderStorageImageArrayNonUniformIndexingNative == rhs.shaderStorageImageArrayNonUniformIndexingNative ) + && ( shaderInputAttachmentArrayNonUniformIndexingNative == rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) + && ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) + && ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) + && ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) + && ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) + && ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) + && ( maxPerStageDescriptorUpdateAfterBindSampledImages == rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) + && ( maxPerStageDescriptorUpdateAfterBindStorageImages == rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) + && ( maxPerStageDescriptorUpdateAfterBindInputAttachments == rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) + && ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) + && ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) + && ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) + && ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) + && ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) + && ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) + && ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) + && ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) + && ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ); + } + + bool operator!=( PhysicalDeviceDescriptorIndexingPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + Bool32 shaderUniformBufferArrayNonUniformIndexingNative; + Bool32 shaderSampledImageArrayNonUniformIndexingNative; + Bool32 shaderStorageBufferArrayNonUniformIndexingNative; + Bool32 shaderStorageImageArrayNonUniformIndexingNative; + Bool32 shaderInputAttachmentArrayNonUniformIndexingNative; + Bool32 robustBufferAccessUpdateAfterBind; + Bool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + }; + static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" ); + + struct DescriptorSetVariableDescriptorCountAllocateInfoEXT + { + DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0, + const uint32_t* pDescriptorCounts_ = nullptr ) + : descriptorSetCount( descriptorSetCount_ ) + , pDescriptorCounts( pDescriptorCounts_ ) + { + } + + DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) ); + } + + DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) ); + return *this; + } + DescriptorSetVariableDescriptorCountAllocateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorSetVariableDescriptorCountAllocateInfoEXT& setDescriptorSetCount( uint32_t descriptorSetCount_ ) + { + descriptorSetCount = descriptorSetCount_; + return *this; + } + + DescriptorSetVariableDescriptorCountAllocateInfoEXT& setPDescriptorCounts( const uint32_t* pDescriptorCounts_ ) + { + pDescriptorCounts = pDescriptorCounts_; + return *this; + } + + operator const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( descriptorSetCount == rhs.descriptorSetCount ) + && ( pDescriptorCounts == rhs.pDescriptorCounts ); + } + + bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT; + + public: + const void* pNext = nullptr; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; + }; + static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" ); + + struct DescriptorSetVariableDescriptorCountLayoutSupportEXT + { + operator const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount ); + } + + bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT; + + public: + void* pNext = nullptr; + uint32_t maxVariableDescriptorCount; + }; + static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" ); + + struct PipelineVertexInputDivisorStateCreateInfoEXT + { + PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0, + const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) + : vertexBindingDivisorCount( vertexBindingDivisorCount_ ) + , pVertexBindingDivisors( pVertexBindingDivisors_ ) + { + } + + PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) ); + } + + PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) ); + return *this; + } + PipelineVertexInputDivisorStateCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineVertexInputDivisorStateCreateInfoEXT& setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ ) + { + vertexBindingDivisorCount = vertexBindingDivisorCount_; + return *this; + } + + PipelineVertexInputDivisorStateCreateInfoEXT& setPVertexBindingDivisors( const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ ) + { + pVertexBindingDivisors = pVertexBindingDivisors_; + return *this; + } + + operator const VkPipelineVertexInputDivisorStateCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) + && ( pVertexBindingDivisors == rhs.pVertexBindingDivisors ); + } + + bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; + + public: + const void* pNext = nullptr; + uint32_t vertexBindingDivisorCount; + const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; + }; + static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT + { + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 ) + : maxVertexAttribDivisor( maxVertexAttribDivisor_ ) + { + } + + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) ); + } + + PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) ); + return *this; + } + PhysicalDeviceVertexAttributeDivisorPropertiesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceVertexAttributeDivisorPropertiesEXT& setMaxVertexAttribDivisor( uint32_t maxVertexAttribDivisor_ ) + { + maxVertexAttribDivisor = maxVertexAttribDivisor_; + return *this; + } + + operator const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ); + } + + bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t maxVertexAttribDivisor; + }; + static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + struct ImportAndroidHardwareBufferInfoANDROID + { + ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) + : buffer( buffer_ ) + { + } + + ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) ); + } + + ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) ); + return *this; + } + ImportAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportAndroidHardwareBufferInfoANDROID& setBuffer( struct AHardwareBuffer* buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator const VkImportAndroidHardwareBufferInfoANDROID&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; + + public: + const void* pNext = nullptr; + struct AHardwareBuffer* buffer; + }; + static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + struct AndroidHardwareBufferUsageANDROID + { + operator const VkAndroidHardwareBufferUsageANDROID&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AndroidHardwareBufferUsageANDROID const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage ); + } + + bool operator!=( AndroidHardwareBufferUsageANDROID const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; + + public: + void* pNext = nullptr; + uint64_t androidHardwareBufferUsage; + }; + static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + struct AndroidHardwareBufferPropertiesANDROID + { + operator const VkAndroidHardwareBufferPropertiesANDROID&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AndroidHardwareBufferPropertiesANDROID const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( allocationSize == rhs.allocationSize ) + && ( memoryTypeBits == rhs.memoryTypeBits ); + } + + bool operator!=( AndroidHardwareBufferPropertiesANDROID const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; + + public: + void* pNext = nullptr; + DeviceSize allocationSize; + uint32_t memoryTypeBits; + }; + static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + struct MemoryGetAndroidHardwareBufferInfoANDROID + { + MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = DeviceMemory() ) + : memory( memory_ ) + { + } + + MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) ); + } + + MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) ); + return *this; + } + MemoryGetAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryGetAndroidHardwareBufferInfoANDROID& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + operator const VkMemoryGetAndroidHardwareBufferInfoANDROID&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ); + } + + bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; + + public: + const void* pNext = nullptr; + DeviceMemory memory; + }; + static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + struct ExternalFormatANDROID + { + ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) + : externalFormat( externalFormat_ ) + { + } + + ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) ); + } + + ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) ); + return *this; + } + ExternalFormatANDROID& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExternalFormatANDROID& setExternalFormat( uint64_t externalFormat_ ) + { + externalFormat = externalFormat_; + return *this; + } + + operator const VkExternalFormatANDROID&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalFormatANDROID const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( externalFormat == rhs.externalFormat ); + } + + bool operator!=( ExternalFormatANDROID const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalFormatANDROID; + + public: + void* pNext = nullptr; + uint64_t externalFormat; + }; + static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + + enum class SubpassContents + { + eInline = VK_SUBPASS_CONTENTS_INLINE, + eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS + }; + + struct PresentInfoKHR + { + PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, + const Semaphore* pWaitSemaphores_ = nullptr, + uint32_t swapchainCount_ = 0, + const SwapchainKHR* pSwapchains_ = nullptr, + const uint32_t* pImageIndices_ = nullptr, + Result* pResults_ = nullptr ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , swapchainCount( swapchainCount_ ) + , pSwapchains( pSwapchains_ ) + , pImageIndices( pImageIndices_ ) + , pResults( pResults_ ) + { + } + + PresentInfoKHR( VkPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); + } + + PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); + return *this; + } + PresentInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) + { + pWaitSemaphores = pWaitSemaphores_; + return *this; + } + + PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ ) + { + swapchainCount = swapchainCount_; + return *this; + } + + PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ ) + { + pSwapchains = pSwapchains_; + return *this; + } + + PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ ) + { + pImageIndices = pImageIndices_; + return *this; + } + + PresentInfoKHR& setPResults( Result* pResults_ ) + { + pResults = pResults_; + return *this; + } + + operator const VkPresentInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PresentInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) + && ( pWaitSemaphores == rhs.pWaitSemaphores ) + && ( swapchainCount == rhs.swapchainCount ) + && ( pSwapchains == rhs.pSwapchains ) + && ( pImageIndices == rhs.pImageIndices ) + && ( pResults == rhs.pResults ); + } + + bool operator!=( PresentInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePresentInfoKHR; + + public: + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const Semaphore* pWaitSemaphores; + uint32_t swapchainCount; + const SwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + Result* pResults; + }; + static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); + + enum class DynamicState + { + eViewport = VK_DYNAMIC_STATE_VIEWPORT, + eScissor = VK_DYNAMIC_STATE_SCISSOR, + eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, + eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, + eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, + eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, + eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, + eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, + eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, + eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, + eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT + }; + + struct PipelineDynamicStateCreateInfo + { + PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), + uint32_t dynamicStateCount_ = 0, + const DynamicState* pDynamicStates_ = nullptr ) + : flags( flags_ ) + , dynamicStateCount( dynamicStateCount_ ) + , pDynamicStates( pDynamicStates_ ) + { + } + + PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); + } + + PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); + return *this; + } + PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ ) + { + dynamicStateCount = dynamicStateCount_; + return *this; + } + + PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ ) + { + pDynamicStates = pDynamicStates_; + return *this; + } + + operator const VkPipelineDynamicStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( dynamicStateCount == rhs.dynamicStateCount ) + && ( pDynamicStates == rhs.pDynamicStates ); + } + + bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const DynamicState* pDynamicStates; + }; + static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); + + enum class DescriptorUpdateTemplateType + { + eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR + }; + + struct DescriptorUpdateTemplateCreateInfo + { + DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(), + uint32_t descriptorUpdateEntryCount_ = 0, + const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr, + DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet, + DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + PipelineLayout pipelineLayout_ = PipelineLayout(), + uint32_t set_ = 0 ) + : flags( flags_ ) + , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) + , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) + , templateType( templateType_ ) + , descriptorSetLayout( descriptorSetLayout_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , pipelineLayout( pipelineLayout_ ) + , set( set_ ) + { + } + + DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) ); + } + + DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) ); + return *this; + } + DescriptorUpdateTemplateCreateInfo& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) + { + descriptorUpdateEntryCount = descriptorUpdateEntryCount_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ ) + { + pDescriptorUpdateEntries = pDescriptorUpdateEntries_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setTemplateType( DescriptorUpdateTemplateType templateType_ ) + { + templateType = templateType_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) + { + descriptorSetLayout = descriptorSetLayout_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setPipelineLayout( PipelineLayout pipelineLayout_ ) + { + pipelineLayout = pipelineLayout_; + return *this; + } + + DescriptorUpdateTemplateCreateInfo& setSet( uint32_t set_ ) + { + set = set_; + return *this; + } + + operator const VkDescriptorUpdateTemplateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) + && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) + && ( templateType == rhs.templateType ) + && ( descriptorSetLayout == rhs.descriptorSetLayout ) + && ( pipelineBindPoint == rhs.pipelineBindPoint ) + && ( pipelineLayout == rhs.pipelineLayout ) + && ( set == rhs.set ); + } + + bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; + + public: + void* pNext = nullptr; + DescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + DescriptorUpdateTemplateType templateType; + DescriptorSetLayout descriptorSetLayout; + PipelineBindPoint pipelineBindPoint; + PipelineLayout pipelineLayout; + uint32_t set; + }; + static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" ); + + using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; + + enum class ObjectType + { + eUnknown = VK_OBJECT_TYPE_UNKNOWN, + eInstance = VK_OBJECT_TYPE_INSTANCE, + ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, + eDevice = VK_OBJECT_TYPE_DEVICE, + eQueue = VK_OBJECT_TYPE_QUEUE, + eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, + eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, + eFence = VK_OBJECT_TYPE_FENCE, + eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, + eBuffer = VK_OBJECT_TYPE_BUFFER, + eImage = VK_OBJECT_TYPE_IMAGE, + eEvent = VK_OBJECT_TYPE_EVENT, + eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, + eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, + eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, + eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, + ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, + ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, + eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, + ePipeline = VK_OBJECT_TYPE_PIPELINE, + eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, + eSampler = VK_OBJECT_TYPE_SAMPLER, + eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, + eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, + eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, + eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, + eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, + eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, + eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, + eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, + eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, + eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX, + eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX, + eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, + eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT + }; + + struct DebugUtilsObjectNameInfoEXT + { + DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, + uint64_t objectHandle_ = 0, + const char* pObjectName_ = nullptr ) + : objectType( objectType_ ) + , objectHandle( objectHandle_ ) + , pObjectName( pObjectName_ ) + { + } + + DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) ); + } + + DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) ); + return *this; + } + DebugUtilsObjectNameInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugUtilsObjectNameInfoEXT& setObjectType( ObjectType objectType_ ) + { + objectType = objectType_; + return *this; + } + + DebugUtilsObjectNameInfoEXT& setObjectHandle( uint64_t objectHandle_ ) + { + objectHandle = objectHandle_; + return *this; + } + + DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ ) + { + pObjectName = pObjectName_; + return *this; + } + + operator const VkDebugUtilsObjectNameInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectType == rhs.objectType ) + && ( objectHandle == rhs.objectHandle ) + && ( pObjectName == rhs.pObjectName ); + } + + bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; + + public: + const void* pNext = nullptr; + ObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; + }; + static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" ); + + struct DebugUtilsObjectTagInfoEXT + { + DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, + uint64_t objectHandle_ = 0, + uint64_t tagName_ = 0, + size_t tagSize_ = 0, + const void* pTag_ = nullptr ) + : objectType( objectType_ ) + , objectHandle( objectHandle_ ) + , tagName( tagName_ ) + , tagSize( tagSize_ ) + , pTag( pTag_ ) + { + } + + DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) ); + } + + DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) ); + return *this; + } + DebugUtilsObjectTagInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugUtilsObjectTagInfoEXT& setObjectType( ObjectType objectType_ ) + { + objectType = objectType_; + return *this; + } + + DebugUtilsObjectTagInfoEXT& setObjectHandle( uint64_t objectHandle_ ) + { + objectHandle = objectHandle_; + return *this; + } + + DebugUtilsObjectTagInfoEXT& setTagName( uint64_t tagName_ ) + { + tagName = tagName_; + return *this; + } + + DebugUtilsObjectTagInfoEXT& setTagSize( size_t tagSize_ ) + { + tagSize = tagSize_; + return *this; + } + + DebugUtilsObjectTagInfoEXT& setPTag( const void* pTag_ ) + { + pTag = pTag_; + return *this; + } + + operator const VkDebugUtilsObjectTagInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugUtilsObjectTagInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectType == rhs.objectType ) + && ( objectHandle == rhs.objectHandle ) + && ( tagName == rhs.tagName ) + && ( tagSize == rhs.tagSize ) + && ( pTag == rhs.pTag ); + } + + bool operator!=( DebugUtilsObjectTagInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; + + public: + const void* pNext = nullptr; + ObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; + }; + static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" ); + + struct DebugUtilsMessengerCallbackDataEXT + { + DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(), + const char* pMessageIdName_ = nullptr, + int32_t messageIdNumber_ = 0, + const char* pMessage_ = nullptr, + uint32_t queueLabelCount_ = 0, + DebugUtilsLabelEXT* pQueueLabels_ = nullptr, + uint32_t cmdBufLabelCount_ = 0, + DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr, + uint32_t objectCount_ = 0, + DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr ) + : flags( flags_ ) + , pMessageIdName( pMessageIdName_ ) + , messageIdNumber( messageIdNumber_ ) + , pMessage( pMessage_ ) + , queueLabelCount( queueLabelCount_ ) + , pQueueLabels( pQueueLabels_ ) + , cmdBufLabelCount( cmdBufLabelCount_ ) + , pCmdBufLabels( pCmdBufLabels_ ) + , objectCount( objectCount_ ) + , pObjects( pObjects_ ) + { + } + + DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) ); + } + + DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) ); + return *this; + } + DebugUtilsMessengerCallbackDataEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setPMessageIdName( const char* pMessageIdName_ ) + { + pMessageIdName = pMessageIdName_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setMessageIdNumber( int32_t messageIdNumber_ ) + { + messageIdNumber = messageIdNumber_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setPMessage( const char* pMessage_ ) + { + pMessage = pMessage_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setQueueLabelCount( uint32_t queueLabelCount_ ) + { + queueLabelCount = queueLabelCount_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setPQueueLabels( DebugUtilsLabelEXT* pQueueLabels_ ) + { + pQueueLabels = pQueueLabels_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) + { + cmdBufLabelCount = cmdBufLabelCount_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setPCmdBufLabels( DebugUtilsLabelEXT* pCmdBufLabels_ ) + { + pCmdBufLabels = pCmdBufLabels_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setObjectCount( uint32_t objectCount_ ) + { + objectCount = objectCount_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT& setPObjects( DebugUtilsObjectNameInfoEXT* pObjects_ ) + { + pObjects = pObjects_; + return *this; + } + + operator const VkDebugUtilsMessengerCallbackDataEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugUtilsMessengerCallbackDataEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( pMessageIdName == rhs.pMessageIdName ) + && ( messageIdNumber == rhs.messageIdNumber ) + && ( pMessage == rhs.pMessage ) + && ( queueLabelCount == rhs.queueLabelCount ) + && ( pQueueLabels == rhs.pQueueLabels ) + && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) + && ( pCmdBufLabels == rhs.pCmdBufLabels ) + && ( objectCount == rhs.objectCount ) + && ( pObjects == rhs.pObjects ); + } + + bool operator!=( DebugUtilsMessengerCallbackDataEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; + + public: + const void* pNext = nullptr; + DebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + DebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + DebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + DebugUtilsObjectNameInfoEXT* pObjects; + }; + static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" ); + + enum class QueueFlagBits + { + eGraphics = VK_QUEUE_GRAPHICS_BIT, + eCompute = VK_QUEUE_COMPUTE_BIT, + eTransfer = VK_QUEUE_TRANSFER_BIT, + eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT, + eProtected = VK_QUEUE_PROTECTED_BIT + }; + + using QueueFlags = Flags; + + VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 ) + { + return QueueFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits ) + { + return ~( QueueFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) | VkFlags(QueueFlagBits::eProtected) + }; + }; + + struct QueueFamilyProperties + { + operator const VkQueueFamilyProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( QueueFamilyProperties const& rhs ) const + { + return ( queueFlags == rhs.queueFlags ) + && ( queueCount == rhs.queueCount ) + && ( timestampValidBits == rhs.timestampValidBits ) + && ( minImageTransferGranularity == rhs.minImageTransferGranularity ); + } + + bool operator!=( QueueFamilyProperties const& rhs ) const + { + return !operator==( rhs ); + } + + QueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + Extent3D minImageTransferGranularity; + }; + static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); + + struct QueueFamilyProperties2 + { + operator const VkQueueFamilyProperties2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( QueueFamilyProperties2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( queueFamilyProperties == rhs.queueFamilyProperties ); + } + + bool operator!=( QueueFamilyProperties2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eQueueFamilyProperties2; + + public: + void* pNext = nullptr; + QueueFamilyProperties queueFamilyProperties; + }; + static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" ); + + using QueueFamilyProperties2KHR = QueueFamilyProperties2; + + enum class DeviceQueueCreateFlagBits + { + eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT + }; + + using DeviceQueueCreateFlags = Flags; + + VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 ) + { + return DeviceQueueCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits ) + { + return ~( DeviceQueueCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected) + }; + }; + + struct DeviceQueueCreateInfo + { + DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), + uint32_t queueFamilyIndex_ = 0, + uint32_t queueCount_ = 0, + const float* pQueuePriorities_ = nullptr ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , queueCount( queueCount_ ) + , pQueuePriorities( pQueuePriorities_ ) + { + } + + DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); + } + + DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); + return *this; + } + DeviceQueueCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ ) + { + queueCount = queueCount_; + return *this; + } + + DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ ) + { + pQueuePriorities = pQueuePriorities_; + return *this; + } + + operator const VkDeviceQueueCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceQueueCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( queueFamilyIndex == rhs.queueFamilyIndex ) + && ( queueCount == rhs.queueCount ) + && ( pQueuePriorities == rhs.pQueuePriorities ); + } + + bool operator!=( DeviceQueueCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceQueueCreateInfo; + + public: + const void* pNext = nullptr; + DeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; + }; + static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" ); + + struct DeviceCreateInfo + { + DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(), + uint32_t queueCreateInfoCount_ = 0, + const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, + uint32_t enabledLayerCount_ = 0, + const char* const* ppEnabledLayerNames_ = nullptr, + uint32_t enabledExtensionCount_ = 0, + const char* const* ppEnabledExtensionNames_ = nullptr, + const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) + : flags( flags_ ) + , queueCreateInfoCount( queueCreateInfoCount_ ) + , pQueueCreateInfos( pQueueCreateInfos_ ) + , enabledLayerCount( enabledLayerCount_ ) + , ppEnabledLayerNames( ppEnabledLayerNames_ ) + , enabledExtensionCount( enabledExtensionCount_ ) + , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) + , pEnabledFeatures( pEnabledFeatures_ ) + { + } + + DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); + } + + DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); + return *this; + } + DeviceCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ ) + { + queueCreateInfoCount = queueCreateInfoCount_; + return *this; + } + + DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ ) + { + pQueueCreateInfos = pQueueCreateInfos_; + return *this; + } + + DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ ) + { + enabledLayerCount = enabledLayerCount_; + return *this; + } + + DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ ) + { + ppEnabledLayerNames = ppEnabledLayerNames_; + return *this; + } + + DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) + { + enabledExtensionCount = enabledExtensionCount_; + return *this; + } + + DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ ) + { + ppEnabledExtensionNames = ppEnabledExtensionNames_; + return *this; + } + + DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ ) + { + pEnabledFeatures = pEnabledFeatures_; + return *this; + } + + operator const VkDeviceCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) + && ( pQueueCreateInfos == rhs.pQueueCreateInfos ) + && ( enabledLayerCount == rhs.enabledLayerCount ) + && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) + && ( enabledExtensionCount == rhs.enabledExtensionCount ) + && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ) + && ( pEnabledFeatures == rhs.pEnabledFeatures ); + } + + bool operator!=( DeviceCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceCreateInfo; + + public: + const void* pNext = nullptr; + DeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const DeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const PhysicalDeviceFeatures* pEnabledFeatures; + }; + static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); + + struct DeviceQueueInfo2 + { + DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), + uint32_t queueFamilyIndex_ = 0, + uint32_t queueIndex_ = 0 ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , queueIndex( queueIndex_ ) + { + } + + DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) ); + } + + DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) ); + return *this; + } + DeviceQueueInfo2& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceQueueInfo2& setFlags( DeviceQueueCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DeviceQueueInfo2& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + DeviceQueueInfo2& setQueueIndex( uint32_t queueIndex_ ) + { + queueIndex = queueIndex_; + return *this; + } + + operator const VkDeviceQueueInfo2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceQueueInfo2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( queueFamilyIndex == rhs.queueFamilyIndex ) + && ( queueIndex == rhs.queueIndex ); + } + + bool operator!=( DeviceQueueInfo2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceQueueInfo2; + + public: + const void* pNext = nullptr; + DeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; + }; + static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" ); + + enum class MemoryPropertyFlagBits + { + eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, + eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, + eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT + }; + + using MemoryPropertyFlags = Flags; + + VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 ) + { + return MemoryPropertyFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits ) + { + return ~( MemoryPropertyFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected) + }; + }; + + struct MemoryType + { + operator const VkMemoryType&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryType const& rhs ) const + { + return ( propertyFlags == rhs.propertyFlags ) + && ( heapIndex == rhs.heapIndex ); + } + + bool operator!=( MemoryType const& rhs ) const + { + return !operator==( rhs ); + } + + MemoryPropertyFlags propertyFlags; + uint32_t heapIndex; + }; + static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); + + enum class MemoryHeapFlagBits + { + eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, + eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT + }; + + using MemoryHeapFlags = Flags; + + VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 ) + { + return MemoryHeapFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits ) + { + return ~( MemoryHeapFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstance) + }; + }; + + struct MemoryHeap + { + operator const VkMemoryHeap&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryHeap const& rhs ) const + { + return ( size == rhs.size ) + && ( flags == rhs.flags ); + } + + bool operator!=( MemoryHeap const& rhs ) const + { + return !operator==( rhs ); + } + + DeviceSize size; + MemoryHeapFlags flags; + }; + static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceMemoryProperties + { + operator const VkPhysicalDeviceMemoryProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const + { + return ( memoryTypeCount == rhs.memoryTypeCount ) + && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 ) + && ( memoryHeapCount == rhs.memoryHeapCount ) + && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 ); + } + + bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t memoryTypeCount; + MemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; + }; + static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceMemoryProperties2 + { + operator const VkPhysicalDeviceMemoryProperties2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceMemoryProperties2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryProperties == rhs.memoryProperties ); + } + + bool operator!=( PhysicalDeviceMemoryProperties2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; + + public: + void* pNext = nullptr; + PhysicalDeviceMemoryProperties memoryProperties; + }; + static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" ); + + using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; + + enum class AccessFlagBits + { + eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, + eIndexRead = VK_ACCESS_INDEX_READ_BIT, + eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, + eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, + eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, + eShaderRead = VK_ACCESS_SHADER_READ_BIT, + eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, + eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, + eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, + eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, + eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, + eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, + eHostRead = VK_ACCESS_HOST_READ_BIT, + eHostWrite = VK_ACCESS_HOST_WRITE_BIT, + eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, + eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, + eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, + eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, + eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT + }; + + using AccessFlags = Flags; + + VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 ) + { + return AccessFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits ) + { + return ~( AccessFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) + }; + }; + + struct MemoryBarrier + { + MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), + AccessFlags dstAccessMask_ = AccessFlags() ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + { + } + + MemoryBarrier( VkMemoryBarrier const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); + } + + MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); + return *this; + } + MemoryBarrier& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) + { + srcAccessMask = srcAccessMask_; + return *this; + } + + MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) + { + dstAccessMask = dstAccessMask_; + return *this; + } + + operator const VkMemoryBarrier&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryBarrier const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ); + } + + bool operator!=( MemoryBarrier const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryBarrier; + + public: + const void* pNext = nullptr; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + }; + static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); + + struct BufferMemoryBarrier + { + BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), + AccessFlags dstAccessMask_ = AccessFlags(), + uint32_t srcQueueFamilyIndex_ = 0, + uint32_t dstQueueFamilyIndex_ = 0, + Buffer buffer_ = Buffer(), + DeviceSize offset_ = 0, + DeviceSize size_ = 0 ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , buffer( buffer_ ) + , offset( offset_ ) + , size( size_ ) + { + } + + BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); + } + + BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); + return *this; + } + BufferMemoryBarrier& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) + { + srcAccessMask = srcAccessMask_; + return *this; + } + + BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) + { + dstAccessMask = dstAccessMask_; + return *this; + } + + BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + BufferMemoryBarrier& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + BufferMemoryBarrier& setOffset( DeviceSize offset_ ) + { + offset = offset_; + return *this; + } + + BufferMemoryBarrier& setSize( DeviceSize size_ ) + { + size = size_; + return *this; + } + + operator const VkBufferMemoryBarrier&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferMemoryBarrier const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ) + && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) + && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) + && ( buffer == rhs.buffer ) + && ( offset == rhs.offset ) + && ( size == rhs.size ); + } + + bool operator!=( BufferMemoryBarrier const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBufferMemoryBarrier; + + public: + const void* pNext = nullptr; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + Buffer buffer; + DeviceSize offset; + DeviceSize size; + }; + static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); + + enum class BufferUsageFlagBits + { + eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, + eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, + eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT + }; + + using BufferUsageFlags = Flags; + + VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 ) + { + return BufferUsageFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits ) + { + return ~( BufferUsageFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) + }; + }; + + enum class BufferCreateFlagBits + { + eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, + eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, + eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, + eProtected = VK_BUFFER_CREATE_PROTECTED_BIT + }; + + using BufferCreateFlags = Flags; + + VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 ) + { + return BufferCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits ) + { + return ~( BufferCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected) + }; + }; + + struct BufferCreateInfo + { + BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), + DeviceSize size_ = 0, + BufferUsageFlags usage_ = BufferUsageFlags(), + SharingMode sharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = 0, + const uint32_t* pQueueFamilyIndices_ = nullptr ) + : flags( flags_ ) + , size( size_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + { + } + + BufferCreateInfo( VkBufferCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); + } + + BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); + return *this; + } + BufferCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BufferCreateInfo& setFlags( BufferCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + BufferCreateInfo& setSize( DeviceSize size_ ) + { + size = size_; + return *this; + } + + BufferCreateInfo& setUsage( BufferUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + BufferCreateInfo& setSharingMode( SharingMode sharingMode_ ) + { + sharingMode = sharingMode_; + return *this; + } + + BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + operator const VkBufferCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( size == rhs.size ) + && ( usage == rhs.usage ) + && ( sharingMode == rhs.sharingMode ) + && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) + && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); + } + + bool operator!=( BufferCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBufferCreateInfo; + + public: + const void* pNext = nullptr; + BufferCreateFlags flags; + DeviceSize size; + BufferUsageFlags usage; + SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + }; + static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); + + enum class ShaderStageFlagBits + { + eVertex = VK_SHADER_STAGE_VERTEX_BIT, + eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, + eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, + eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, + eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, + eCompute = VK_SHADER_STAGE_COMPUTE_BIT, + eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, + eAll = VK_SHADER_STAGE_ALL + }; + + using ShaderStageFlags = Flags; + + VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 ) + { + return ShaderStageFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits ) + { + return ~( ShaderStageFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) + }; + }; + + struct DescriptorSetLayoutBinding + { + DescriptorSetLayoutBinding( uint32_t binding_ = 0, + DescriptorType descriptorType_ = DescriptorType::eSampler, + uint32_t descriptorCount_ = 0, + ShaderStageFlags stageFlags_ = ShaderStageFlags(), + const Sampler* pImmutableSamplers_ = nullptr ) + : binding( binding_ ) + , descriptorType( descriptorType_ ) + , descriptorCount( descriptorCount_ ) + , stageFlags( stageFlags_ ) + , pImmutableSamplers( pImmutableSamplers_ ) + { + } + + DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); + } + + DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); + return *this; + } + DescriptorSetLayoutBinding& setBinding( uint32_t binding_ ) + { + binding = binding_; + return *this; + } + + DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ ) + { + descriptorType = descriptorType_; + return *this; + } + + DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ ) + { + descriptorCount = descriptorCount_; + return *this; + } + + DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ ) + { + stageFlags = stageFlags_; + return *this; + } + + DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ ) + { + pImmutableSamplers = pImmutableSamplers_; + return *this; + } + + operator const VkDescriptorSetLayoutBinding&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetLayoutBinding const& rhs ) const + { + return ( binding == rhs.binding ) + && ( descriptorType == rhs.descriptorType ) + && ( descriptorCount == rhs.descriptorCount ) + && ( stageFlags == rhs.stageFlags ) + && ( pImmutableSamplers == rhs.pImmutableSamplers ); + } + + bool operator!=( DescriptorSetLayoutBinding const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t binding; + DescriptorType descriptorType; + uint32_t descriptorCount; + ShaderStageFlags stageFlags; + const Sampler* pImmutableSamplers; + }; + static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); + + struct PipelineShaderStageCreateInfo + { + PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), + ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, + ShaderModule module_ = ShaderModule(), + const char* pName_ = nullptr, + const SpecializationInfo* pSpecializationInfo_ = nullptr ) + : flags( flags_ ) + , stage( stage_ ) + , module( module_ ) + , pName( pName_ ) + , pSpecializationInfo( pSpecializationInfo_ ) + { + } + + PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); + } + + PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); + return *this; + } + PipelineShaderStageCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ ) + { + stage = stage_; + return *this; + } + + PipelineShaderStageCreateInfo& setModule( ShaderModule module_ ) + { + module = module_; + return *this; + } + + PipelineShaderStageCreateInfo& setPName( const char* pName_ ) + { + pName = pName_; + return *this; + } + + PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ ) + { + pSpecializationInfo = pSpecializationInfo_; + return *this; + } + + operator const VkPipelineShaderStageCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineShaderStageCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( stage == rhs.stage ) + && ( module == rhs.module ) + && ( pName == rhs.pName ) + && ( pSpecializationInfo == rhs.pSpecializationInfo ); + } + + bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineShaderStageCreateInfo; + + public: + const void* pNext = nullptr; + PipelineShaderStageCreateFlags flags; + ShaderStageFlagBits stage; + ShaderModule module; + const char* pName; + const SpecializationInfo* pSpecializationInfo; + }; + static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); + + struct PushConstantRange + { + PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), + uint32_t offset_ = 0, + uint32_t size_ = 0 ) + : stageFlags( stageFlags_ ) + , offset( offset_ ) + , size( size_ ) + { + } + + PushConstantRange( VkPushConstantRange const & rhs ) + { + memcpy( this, &rhs, sizeof( PushConstantRange ) ); + } + + PushConstantRange& operator=( VkPushConstantRange const & rhs ) + { + memcpy( this, &rhs, sizeof( PushConstantRange ) ); + return *this; + } + PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ ) + { + stageFlags = stageFlags_; + return *this; + } + + PushConstantRange& setOffset( uint32_t offset_ ) + { + offset = offset_; + return *this; + } + + PushConstantRange& setSize( uint32_t size_ ) + { + size = size_; + return *this; + } + + operator const VkPushConstantRange&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PushConstantRange const& rhs ) const + { + return ( stageFlags == rhs.stageFlags ) + && ( offset == rhs.offset ) + && ( size == rhs.size ); + } + + bool operator!=( PushConstantRange const& rhs ) const + { + return !operator==( rhs ); + } + + ShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + }; + static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); + + struct PipelineLayoutCreateInfo + { + PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), + uint32_t setLayoutCount_ = 0, + const DescriptorSetLayout* pSetLayouts_ = nullptr, + uint32_t pushConstantRangeCount_ = 0, + const PushConstantRange* pPushConstantRanges_ = nullptr ) + : flags( flags_ ) + , setLayoutCount( setLayoutCount_ ) + , pSetLayouts( pSetLayouts_ ) + , pushConstantRangeCount( pushConstantRangeCount_ ) + , pPushConstantRanges( pPushConstantRanges_ ) + { + } + + PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); + } + + PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); + return *this; + } + PipelineLayoutCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ ) + { + setLayoutCount = setLayoutCount_; + return *this; + } + + PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) + { + pSetLayouts = pSetLayouts_; + return *this; + } + + PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) + { + pushConstantRangeCount = pushConstantRangeCount_; + return *this; + } + + PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ ) + { + pPushConstantRanges = pPushConstantRanges_; + return *this; + } + + operator const VkPipelineLayoutCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineLayoutCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( setLayoutCount == rhs.setLayoutCount ) + && ( pSetLayouts == rhs.pSetLayouts ) + && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) + && ( pPushConstantRanges == rhs.pPushConstantRanges ); + } + + bool operator!=( PipelineLayoutCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineLayoutCreateInfo; + + public: + const void* pNext = nullptr; + PipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const DescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const PushConstantRange* pPushConstantRanges; + }; + static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); + + struct ShaderStatisticsInfoAMD + { + operator const VkShaderStatisticsInfoAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ShaderStatisticsInfoAMD const& rhs ) const + { + return ( shaderStageMask == rhs.shaderStageMask ) + && ( resourceUsage == rhs.resourceUsage ) + && ( numPhysicalVgprs == rhs.numPhysicalVgprs ) + && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) + && ( numAvailableVgprs == rhs.numAvailableVgprs ) + && ( numAvailableSgprs == rhs.numAvailableSgprs ) + && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ); + } + + bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const + { + return !operator==( rhs ); + } + + ShaderStageFlags shaderStageMask; + ShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; + }; + static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" ); + + enum class ImageUsageFlagBits + { + eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, + eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, + eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, + eStorage = VK_IMAGE_USAGE_STORAGE_BIT, + eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT + }; + + using ImageUsageFlags = Flags; + + VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 ) + { + return ImageUsageFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits ) + { + return ~( ImageUsageFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) + }; + }; + + struct SharedPresentSurfaceCapabilitiesKHR + { + operator const VkSharedPresentSurfaceCapabilitiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); + } + + bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; + + public: + void* pNext = nullptr; + ImageUsageFlags sharedPresentSupportedUsageFlags; + }; + static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); + + struct ImageViewUsageCreateInfo + { + ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() ) + : usage( usage_ ) + { + } + + ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) ); + } + + ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) ); + return *this; + } + ImageViewUsageCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageViewUsageCreateInfo& setUsage( ImageUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + operator const VkImageViewUsageCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageViewUsageCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( usage == rhs.usage ); + } + + bool operator!=( ImageViewUsageCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageViewUsageCreateInfo; + + public: + const void* pNext = nullptr; + ImageUsageFlags usage; + }; + static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" ); + + using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; + + enum class ImageCreateFlagBits + { + eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, + eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, + eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, + eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, + eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, + eAlias = VK_IMAGE_CREATE_ALIAS_BIT, + eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT, + eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + eProtected = VK_IMAGE_CREATE_PROTECTED_BIT, + eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT, + eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT, + eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT + }; + + using ImageCreateFlags = Flags; + + VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 ) + { + return ImageCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits ) + { + return ~( ImageCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) + }; + }; + + struct PhysicalDeviceImageFormatInfo2 + { + PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined, + ImageType type_ = ImageType::e1D, + ImageTiling tiling_ = ImageTiling::eOptimal, + ImageUsageFlags usage_ = ImageUsageFlags(), + ImageCreateFlags flags_ = ImageCreateFlags() ) + : format( format_ ) + , type( type_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , flags( flags_ ) + { + } + + PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) ); + } + + PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) ); + return *this; + } + PhysicalDeviceImageFormatInfo2& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceImageFormatInfo2& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + PhysicalDeviceImageFormatInfo2& setType( ImageType type_ ) + { + type = type_; + return *this; + } + + PhysicalDeviceImageFormatInfo2& setTiling( ImageTiling tiling_ ) + { + tiling = tiling_; + return *this; + } + + PhysicalDeviceImageFormatInfo2& setUsage( ImageUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + PhysicalDeviceImageFormatInfo2& setFlags( ImageCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkPhysicalDeviceImageFormatInfo2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceImageFormatInfo2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( format == rhs.format ) + && ( type == rhs.type ) + && ( tiling == rhs.tiling ) + && ( usage == rhs.usage ) + && ( flags == rhs.flags ); + } + + bool operator!=( PhysicalDeviceImageFormatInfo2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; + + public: + const void* pNext = nullptr; + Format format; + ImageType type; + ImageTiling tiling; + ImageUsageFlags usage; + ImageCreateFlags flags; + }; + static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" ); + + using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; + + enum class PipelineCreateFlagBits + { + eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, + eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, + eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, + eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE, + eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE + }; + + using PipelineCreateFlags = Flags; + + VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 ) + { + return PipelineCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits ) + { + return ~( PipelineCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) + }; + }; + + struct ComputePipelineCreateInfo + { + ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), + PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), + PipelineLayout layout_ = PipelineLayout(), + Pipeline basePipelineHandle_ = Pipeline(), + int32_t basePipelineIndex_ = 0 ) + : flags( flags_ ) + , stage( stage_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } + + ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); + } + + ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); + return *this; + } + ComputePipelineCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ ) + { + stage = stage_; + return *this; + } + + ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ ) + { + layout = layout_; + return *this; + } + + ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + operator const VkComputePipelineCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ComputePipelineCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( stage == rhs.stage ) + && ( layout == rhs.layout ) + && ( basePipelineHandle == rhs.basePipelineHandle ) + && ( basePipelineIndex == rhs.basePipelineIndex ); + } + + bool operator!=( ComputePipelineCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eComputePipelineCreateInfo; + + public: + const void* pNext = nullptr; + PipelineCreateFlags flags; + PipelineShaderStageCreateInfo stage; + PipelineLayout layout; + Pipeline basePipelineHandle; + int32_t basePipelineIndex; + }; + static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); + + enum class ColorComponentFlagBits + { + eR = VK_COLOR_COMPONENT_R_BIT, + eG = VK_COLOR_COMPONENT_G_BIT, + eB = VK_COLOR_COMPONENT_B_BIT, + eA = VK_COLOR_COMPONENT_A_BIT + }; + + using ColorComponentFlags = Flags; + + VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 ) + { + return ColorComponentFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits ) + { + return ~( ColorComponentFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA) + }; + }; + + struct PipelineColorBlendAttachmentState + { + PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, + BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, + BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, + BlendOp colorBlendOp_ = BlendOp::eAdd, + BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, + BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, + BlendOp alphaBlendOp_ = BlendOp::eAdd, + ColorComponentFlags colorWriteMask_ = ColorComponentFlags() ) + : blendEnable( blendEnable_ ) + , srcColorBlendFactor( srcColorBlendFactor_ ) + , dstColorBlendFactor( dstColorBlendFactor_ ) + , colorBlendOp( colorBlendOp_ ) + , srcAlphaBlendFactor( srcAlphaBlendFactor_ ) + , dstAlphaBlendFactor( dstAlphaBlendFactor_ ) + , alphaBlendOp( alphaBlendOp_ ) + , colorWriteMask( colorWriteMask_ ) + { + } + + PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); + } + + PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); + return *this; + } + PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ ) + { + blendEnable = blendEnable_; + return *this; + } + + PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) + { + srcColorBlendFactor = srcColorBlendFactor_; + return *this; + } + + PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) + { + dstColorBlendFactor = dstColorBlendFactor_; + return *this; + } + + PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ ) + { + colorBlendOp = colorBlendOp_; + return *this; + } + + PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) + { + srcAlphaBlendFactor = srcAlphaBlendFactor_; + return *this; + } + + PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) + { + dstAlphaBlendFactor = dstAlphaBlendFactor_; + return *this; + } + + PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ ) + { + alphaBlendOp = alphaBlendOp_; + return *this; + } + + PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ ) + { + colorWriteMask = colorWriteMask_; + return *this; + } + + operator const VkPipelineColorBlendAttachmentState&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineColorBlendAttachmentState const& rhs ) const + { + return ( blendEnable == rhs.blendEnable ) + && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) + && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) + && ( colorBlendOp == rhs.colorBlendOp ) + && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) + && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) + && ( alphaBlendOp == rhs.alphaBlendOp ) + && ( colorWriteMask == rhs.colorWriteMask ); + } + + bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const + { + return !operator==( rhs ); + } + + Bool32 blendEnable; + BlendFactor srcColorBlendFactor; + BlendFactor dstColorBlendFactor; + BlendOp colorBlendOp; + BlendFactor srcAlphaBlendFactor; + BlendFactor dstAlphaBlendFactor; + BlendOp alphaBlendOp; + ColorComponentFlags colorWriteMask; + }; + static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); + + struct PipelineColorBlendStateCreateInfo + { + PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), + Bool32 logicOpEnable_ = 0, + LogicOp logicOp_ = LogicOp::eClear, + uint32_t attachmentCount_ = 0, + const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, + std::array const& blendConstants_ = { { 0, 0, 0, 0 } } ) + : flags( flags_ ) + , logicOpEnable( logicOpEnable_ ) + , logicOp( logicOp_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + { + memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); + } + + PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); + } + + PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); + return *this; + } + PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ ) + { + logicOpEnable = logicOpEnable_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ ) + { + logicOp = logicOp_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) + { + attachmentCount = attachmentCount_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ ) + { + pAttachments = pAttachments_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setBlendConstants( std::array blendConstants_ ) + { + memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); + return *this; + } + + operator const VkPipelineColorBlendStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( logicOpEnable == rhs.logicOpEnable ) + && ( logicOp == rhs.logicOp ) + && ( attachmentCount == rhs.attachmentCount ) + && ( pAttachments == rhs.pAttachments ) + && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 ); + } + + bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineColorBlendStateCreateFlags flags; + Bool32 logicOpEnable; + LogicOp logicOp; + uint32_t attachmentCount; + const PipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; + }; + static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); + + enum class FenceCreateFlagBits + { + eSignaled = VK_FENCE_CREATE_SIGNALED_BIT + }; + + using FenceCreateFlags = Flags; + + VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 ) + { + return FenceCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits ) + { + return ~( FenceCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(FenceCreateFlagBits::eSignaled) + }; + }; + + struct FenceCreateInfo + { + FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() ) + : flags( flags_ ) + { + } + + FenceCreateInfo( VkFenceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); + } + + FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); + return *this; + } + FenceCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + FenceCreateInfo& setFlags( FenceCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkFenceCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FenceCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ); + } + + bool operator!=( FenceCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eFenceCreateInfo; + + public: + const void* pNext = nullptr; + FenceCreateFlags flags; + }; + static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); + + enum class FormatFeatureFlagBits + { + eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, + eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, + eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, + eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, + eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, + eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, + eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, + eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, + eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, + eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, + eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, + eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, + eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT, + eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT, + eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, + eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT + }; + + using FormatFeatureFlags = Flags; + + VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 ) + { + return FormatFeatureFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits ) + { + return ~( FormatFeatureFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) + }; + }; + + struct FormatProperties + { + operator const VkFormatProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FormatProperties const& rhs ) const + { + return ( linearTilingFeatures == rhs.linearTilingFeatures ) + && ( optimalTilingFeatures == rhs.optimalTilingFeatures ) + && ( bufferFeatures == rhs.bufferFeatures ); + } + + bool operator!=( FormatProperties const& rhs ) const + { + return !operator==( rhs ); + } + + FormatFeatureFlags linearTilingFeatures; + FormatFeatureFlags optimalTilingFeatures; + FormatFeatureFlags bufferFeatures; + }; + static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); + + struct FormatProperties2 + { + operator const VkFormatProperties2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FormatProperties2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( formatProperties == rhs.formatProperties ); + } + + bool operator!=( FormatProperties2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eFormatProperties2; + + public: + void* pNext = nullptr; + FormatProperties formatProperties; + }; + static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" ); + + using FormatProperties2KHR = FormatProperties2; + + enum class QueryControlFlagBits + { + ePrecise = VK_QUERY_CONTROL_PRECISE_BIT + }; + + using QueryControlFlags = Flags; + + VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 ) + { + return QueryControlFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits ) + { + return ~( QueryControlFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(QueryControlFlagBits::ePrecise) + }; + }; + + enum class QueryResultFlagBits + { + e64 = VK_QUERY_RESULT_64_BIT, + eWait = VK_QUERY_RESULT_WAIT_BIT, + eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, + ePartial = VK_QUERY_RESULT_PARTIAL_BIT + }; + + using QueryResultFlags = Flags; + + VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 ) + { + return QueryResultFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits ) + { + return ~( QueryResultFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial) + }; + }; + + enum class CommandBufferUsageFlagBits + { + eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, + eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, + eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT + }; + + using CommandBufferUsageFlags = Flags; + + VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 ) + { + return CommandBufferUsageFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits ) + { + return ~( CommandBufferUsageFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse) + }; + }; + + enum class QueryPipelineStatisticFlagBits + { + eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, + eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, + eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, + eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, + eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, + eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, + eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, + eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, + eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, + eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, + eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT + }; + + using QueryPipelineStatisticFlags = Flags; + + VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 ) + { + return QueryPipelineStatisticFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits ) + { + return ~( QueryPipelineStatisticFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations) + }; + }; + + struct CommandBufferInheritanceInfo + { + CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), + uint32_t subpass_ = 0, + Framebuffer framebuffer_ = Framebuffer(), + Bool32 occlusionQueryEnable_ = 0, + QueryControlFlags queryFlags_ = QueryControlFlags(), + QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) + : renderPass( renderPass_ ) + , subpass( subpass_ ) + , framebuffer( framebuffer_ ) + , occlusionQueryEnable( occlusionQueryEnable_ ) + , queryFlags( queryFlags_ ) + , pipelineStatistics( pipelineStatistics_ ) + { + } + + CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); + } + + CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); + return *this; + } + CommandBufferInheritanceInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ ) + { + renderPass = renderPass_; + return *this; + } + + CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ ) + { + subpass = subpass_; + return *this; + } + + CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ ) + { + framebuffer = framebuffer_; + return *this; + } + + CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) + { + occlusionQueryEnable = occlusionQueryEnable_; + return *this; + } + + CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ ) + { + queryFlags = queryFlags_; + return *this; + } + + CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) + { + pipelineStatistics = pipelineStatistics_; + return *this; + } + + operator const VkCommandBufferInheritanceInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CommandBufferInheritanceInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( renderPass == rhs.renderPass ) + && ( subpass == rhs.subpass ) + && ( framebuffer == rhs.framebuffer ) + && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) + && ( queryFlags == rhs.queryFlags ) + && ( pipelineStatistics == rhs.pipelineStatistics ); + } + + bool operator!=( CommandBufferInheritanceInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCommandBufferInheritanceInfo; + + public: + const void* pNext = nullptr; + RenderPass renderPass; + uint32_t subpass; + Framebuffer framebuffer; + Bool32 occlusionQueryEnable; + QueryControlFlags queryFlags; + QueryPipelineStatisticFlags pipelineStatistics; + }; + static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); + + struct CommandBufferBeginInfo + { + CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), + const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) + : flags( flags_ ) + , pInheritanceInfo( pInheritanceInfo_ ) + { + } + + CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); + } + + CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); + return *this; + } + CommandBufferBeginInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ ) + { + flags = flags_; + return *this; + } + + CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ ) + { + pInheritanceInfo = pInheritanceInfo_; + return *this; + } + + operator const VkCommandBufferBeginInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CommandBufferBeginInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( pInheritanceInfo == rhs.pInheritanceInfo ); + } + + bool operator!=( CommandBufferBeginInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCommandBufferBeginInfo; + + public: + const void* pNext = nullptr; + CommandBufferUsageFlags flags; + const CommandBufferInheritanceInfo* pInheritanceInfo; + }; + static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); + + struct QueryPoolCreateInfo + { + QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), + QueryType queryType_ = QueryType::eOcclusion, + uint32_t queryCount_ = 0, + QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) + : flags( flags_ ) + , queryType( queryType_ ) + , queryCount( queryCount_ ) + , pipelineStatistics( pipelineStatistics_ ) + { + } + + QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); + } + + QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); + return *this; + } + QueryPoolCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + QueryPoolCreateInfo& setQueryType( QueryType queryType_ ) + { + queryType = queryType_; + return *this; + } + + QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ ) + { + queryCount = queryCount_; + return *this; + } + + QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) + { + pipelineStatistics = pipelineStatistics_; + return *this; + } + + operator const VkQueryPoolCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( QueryPoolCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( queryType == rhs.queryType ) + && ( queryCount == rhs.queryCount ) + && ( pipelineStatistics == rhs.pipelineStatistics ); + } + + bool operator!=( QueryPoolCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eQueryPoolCreateInfo; + + public: + const void* pNext = nullptr; + QueryPoolCreateFlags flags; + QueryType queryType; + uint32_t queryCount; + QueryPipelineStatisticFlags pipelineStatistics; + }; + static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); + + enum class ImageAspectFlagBits + { + eColor = VK_IMAGE_ASPECT_COLOR_BIT, + eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, + eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, + eMetadata = VK_IMAGE_ASPECT_METADATA_BIT, + ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT, + ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT, + ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT, + ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT + }; + + using ImageAspectFlags = Flags; + + VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 ) + { + return ImageAspectFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits ) + { + return ~( ImageAspectFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0) | VkFlags(ImageAspectFlagBits::ePlane1) | VkFlags(ImageAspectFlagBits::ePlane2) + }; + }; + + struct ImageSubresource + { + ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), + uint32_t mipLevel_ = 0, + uint32_t arrayLayer_ = 0 ) + : aspectMask( aspectMask_ ) + , mipLevel( mipLevel_ ) + , arrayLayer( arrayLayer_ ) + { + } + + ImageSubresource( VkImageSubresource const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSubresource ) ); + } + + ImageSubresource& operator=( VkImageSubresource const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSubresource ) ); + return *this; + } + ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ ) + { + aspectMask = aspectMask_; + return *this; + } + + ImageSubresource& setMipLevel( uint32_t mipLevel_ ) + { + mipLevel = mipLevel_; + return *this; + } + + ImageSubresource& setArrayLayer( uint32_t arrayLayer_ ) + { + arrayLayer = arrayLayer_; + return *this; + } + + operator const VkImageSubresource&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageSubresource const& rhs ) const + { + return ( aspectMask == rhs.aspectMask ) + && ( mipLevel == rhs.mipLevel ) + && ( arrayLayer == rhs.arrayLayer ); + } + + bool operator!=( ImageSubresource const& rhs ) const + { + return !operator==( rhs ); + } + + ImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; + }; + static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); + + struct ImageSubresourceLayers + { + ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), + uint32_t mipLevel_ = 0, + uint32_t baseArrayLayer_ = 0, + uint32_t layerCount_ = 0 ) + : aspectMask( aspectMask_ ) + , mipLevel( mipLevel_ ) + , baseArrayLayer( baseArrayLayer_ ) + , layerCount( layerCount_ ) + { + } + + ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); + } + + ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); + return *this; + } + ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ ) + { + aspectMask = aspectMask_; + return *this; + } + + ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ ) + { + mipLevel = mipLevel_; + return *this; + } + + ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ ) + { + baseArrayLayer = baseArrayLayer_; + return *this; + } + + ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ ) + { + layerCount = layerCount_; + return *this; + } + + operator const VkImageSubresourceLayers&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageSubresourceLayers const& rhs ) const + { + return ( aspectMask == rhs.aspectMask ) + && ( mipLevel == rhs.mipLevel ) + && ( baseArrayLayer == rhs.baseArrayLayer ) + && ( layerCount == rhs.layerCount ); + } + + bool operator!=( ImageSubresourceLayers const& rhs ) const + { + return !operator==( rhs ); + } + + ImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; + }; + static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" ); + + struct ImageSubresourceRange + { + ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), + uint32_t baseMipLevel_ = 0, + uint32_t levelCount_ = 0, + uint32_t baseArrayLayer_ = 0, + uint32_t layerCount_ = 0 ) + : aspectMask( aspectMask_ ) + , baseMipLevel( baseMipLevel_ ) + , levelCount( levelCount_ ) + , baseArrayLayer( baseArrayLayer_ ) + , layerCount( layerCount_ ) + { + } + + ImageSubresourceRange( VkImageSubresourceRange const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); + } + + ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); + return *this; + } + ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ ) + { + aspectMask = aspectMask_; + return *this; + } + + ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ ) + { + baseMipLevel = baseMipLevel_; + return *this; + } + + ImageSubresourceRange& setLevelCount( uint32_t levelCount_ ) + { + levelCount = levelCount_; + return *this; + } + + ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ ) + { + baseArrayLayer = baseArrayLayer_; + return *this; + } + + ImageSubresourceRange& setLayerCount( uint32_t layerCount_ ) + { + layerCount = layerCount_; + return *this; + } + + operator const VkImageSubresourceRange&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageSubresourceRange const& rhs ) const + { + return ( aspectMask == rhs.aspectMask ) + && ( baseMipLevel == rhs.baseMipLevel ) + && ( levelCount == rhs.levelCount ) + && ( baseArrayLayer == rhs.baseArrayLayer ) + && ( layerCount == rhs.layerCount ); + } + + bool operator!=( ImageSubresourceRange const& rhs ) const + { + return !operator==( rhs ); + } + + ImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; + }; + static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); + + struct ImageMemoryBarrier + { + ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), + AccessFlags dstAccessMask_ = AccessFlags(), + ImageLayout oldLayout_ = ImageLayout::eUndefined, + ImageLayout newLayout_ = ImageLayout::eUndefined, + uint32_t srcQueueFamilyIndex_ = 0, + uint32_t dstQueueFamilyIndex_ = 0, + Image image_ = Image(), + ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , oldLayout( oldLayout_ ) + , newLayout( newLayout_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , image( image_ ) + , subresourceRange( subresourceRange_ ) + { + } + + ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); + } + + ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); + return *this; + } + ImageMemoryBarrier& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) + { + srcAccessMask = srcAccessMask_; + return *this; + } + + ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) + { + dstAccessMask = dstAccessMask_; + return *this; + } + + ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ ) + { + oldLayout = oldLayout_; + return *this; + } + + ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ ) + { + newLayout = newLayout_; + return *this; + } + + ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + ImageMemoryBarrier& setImage( Image image_ ) + { + image = image_; + return *this; + } + + ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) + { + subresourceRange = subresourceRange_; + return *this; + } + + operator const VkImageMemoryBarrier&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageMemoryBarrier const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ) + && ( oldLayout == rhs.oldLayout ) + && ( newLayout == rhs.newLayout ) + && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) + && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) + && ( image == rhs.image ) + && ( subresourceRange == rhs.subresourceRange ); + } + + bool operator!=( ImageMemoryBarrier const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageMemoryBarrier; + + public: + const void* pNext = nullptr; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + ImageLayout oldLayout; + ImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + Image image; + ImageSubresourceRange subresourceRange; + }; + static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); + + struct ImageViewCreateInfo + { + ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), + Image image_ = Image(), + ImageViewType viewType_ = ImageViewType::e1D, + Format format_ = Format::eUndefined, + ComponentMapping components_ = ComponentMapping(), + ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) + : flags( flags_ ) + , image( image_ ) + , viewType( viewType_ ) + , format( format_ ) + , components( components_ ) + , subresourceRange( subresourceRange_ ) + { + } + + ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); + } + + ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); + return *this; + } + ImageViewCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + ImageViewCreateInfo& setImage( Image image_ ) + { + image = image_; + return *this; + } + + ImageViewCreateInfo& setViewType( ImageViewType viewType_ ) + { + viewType = viewType_; + return *this; + } + + ImageViewCreateInfo& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + ImageViewCreateInfo& setComponents( ComponentMapping components_ ) + { + components = components_; + return *this; + } + + ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) + { + subresourceRange = subresourceRange_; + return *this; + } + + operator const VkImageViewCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageViewCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( image == rhs.image ) + && ( viewType == rhs.viewType ) + && ( format == rhs.format ) + && ( components == rhs.components ) + && ( subresourceRange == rhs.subresourceRange ); + } + + bool operator!=( ImageViewCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageViewCreateInfo; + + public: + const void* pNext = nullptr; + ImageViewCreateFlags flags; + Image image; + ImageViewType viewType; + Format format; + ComponentMapping components; + ImageSubresourceRange subresourceRange; + }; + static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); + + struct ImageCopy + { + ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), + Offset3D srcOffset_ = Offset3D(), + ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), + Offset3D dstOffset_ = Offset3D(), + Extent3D extent_ = Extent3D() ) + : srcSubresource( srcSubresource_ ) + , srcOffset( srcOffset_ ) + , dstSubresource( dstSubresource_ ) + , dstOffset( dstOffset_ ) + , extent( extent_ ) + { + } + + ImageCopy( VkImageCopy const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageCopy ) ); + } + + ImageCopy& operator=( VkImageCopy const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageCopy ) ); + return *this; + } + ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) + { + srcSubresource = srcSubresource_; + return *this; + } + + ImageCopy& setSrcOffset( Offset3D srcOffset_ ) + { + srcOffset = srcOffset_; + return *this; + } + + ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) + { + dstSubresource = dstSubresource_; + return *this; + } + + ImageCopy& setDstOffset( Offset3D dstOffset_ ) + { + dstOffset = dstOffset_; + return *this; + } + + ImageCopy& setExtent( Extent3D extent_ ) + { + extent = extent_; + return *this; + } + + operator const VkImageCopy&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageCopy const& rhs ) const + { + return ( srcSubresource == rhs.srcSubresource ) + && ( srcOffset == rhs.srcOffset ) + && ( dstSubresource == rhs.dstSubresource ) + && ( dstOffset == rhs.dstOffset ) + && ( extent == rhs.extent ); + } + + bool operator!=( ImageCopy const& rhs ) const + { + return !operator==( rhs ); + } + + ImageSubresourceLayers srcSubresource; + Offset3D srcOffset; + ImageSubresourceLayers dstSubresource; + Offset3D dstOffset; + Extent3D extent; + }; + static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); + + struct ImageBlit + { + ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), + std::array const& srcOffsets_ = { { Offset3D(), Offset3D() } }, + ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), + std::array const& dstOffsets_ = { { Offset3D(), Offset3D() } } ) + : srcSubresource( srcSubresource_ ) + , dstSubresource( dstSubresource_ ) + { + memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); + memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); + } + + ImageBlit( VkImageBlit const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageBlit ) ); + } + + ImageBlit& operator=( VkImageBlit const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageBlit ) ); + return *this; + } + ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) + { + srcSubresource = srcSubresource_; + return *this; + } + + ImageBlit& setSrcOffsets( std::array srcOffsets_ ) + { + memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); + return *this; + } + + ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) + { + dstSubresource = dstSubresource_; + return *this; + } + + ImageBlit& setDstOffsets( std::array dstOffsets_ ) + { + memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); + return *this; + } + + operator const VkImageBlit&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageBlit const& rhs ) const + { + return ( srcSubresource == rhs.srcSubresource ) + && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 ) + && ( dstSubresource == rhs.dstSubresource ) + && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 ); + } + + bool operator!=( ImageBlit const& rhs ) const + { + return !operator==( rhs ); + } + + ImageSubresourceLayers srcSubresource; + Offset3D srcOffsets[2]; + ImageSubresourceLayers dstSubresource; + Offset3D dstOffsets[2]; + }; + static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); + + struct BufferImageCopy + { + BufferImageCopy( DeviceSize bufferOffset_ = 0, + uint32_t bufferRowLength_ = 0, + uint32_t bufferImageHeight_ = 0, + ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), + Offset3D imageOffset_ = Offset3D(), + Extent3D imageExtent_ = Extent3D() ) + : bufferOffset( bufferOffset_ ) + , bufferRowLength( bufferRowLength_ ) + , bufferImageHeight( bufferImageHeight_ ) + , imageSubresource( imageSubresource_ ) + , imageOffset( imageOffset_ ) + , imageExtent( imageExtent_ ) + { + } + + BufferImageCopy( VkBufferImageCopy const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); + } + + BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); + return *this; + } + BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ ) + { + bufferOffset = bufferOffset_; + return *this; + } + + BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ ) + { + bufferRowLength = bufferRowLength_; + return *this; + } + + BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ ) + { + bufferImageHeight = bufferImageHeight_; + return *this; + } + + BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ ) + { + imageSubresource = imageSubresource_; + return *this; + } + + BufferImageCopy& setImageOffset( Offset3D imageOffset_ ) + { + imageOffset = imageOffset_; + return *this; + } + + BufferImageCopy& setImageExtent( Extent3D imageExtent_ ) + { + imageExtent = imageExtent_; + return *this; + } + + operator const VkBufferImageCopy&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferImageCopy const& rhs ) const + { + return ( bufferOffset == rhs.bufferOffset ) + && ( bufferRowLength == rhs.bufferRowLength ) + && ( bufferImageHeight == rhs.bufferImageHeight ) + && ( imageSubresource == rhs.imageSubresource ) + && ( imageOffset == rhs.imageOffset ) + && ( imageExtent == rhs.imageExtent ); + } + + bool operator!=( BufferImageCopy const& rhs ) const + { + return !operator==( rhs ); + } + + DeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + ImageSubresourceLayers imageSubresource; + Offset3D imageOffset; + Extent3D imageExtent; + }; + static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); + + struct ImageResolve + { + ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), + Offset3D srcOffset_ = Offset3D(), + ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), + Offset3D dstOffset_ = Offset3D(), + Extent3D extent_ = Extent3D() ) + : srcSubresource( srcSubresource_ ) + , srcOffset( srcOffset_ ) + , dstSubresource( dstSubresource_ ) + , dstOffset( dstOffset_ ) + , extent( extent_ ) + { + } + + ImageResolve( VkImageResolve const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageResolve ) ); + } + + ImageResolve& operator=( VkImageResolve const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageResolve ) ); + return *this; + } + ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) + { + srcSubresource = srcSubresource_; + return *this; + } + + ImageResolve& setSrcOffset( Offset3D srcOffset_ ) + { + srcOffset = srcOffset_; + return *this; + } + + ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) + { + dstSubresource = dstSubresource_; + return *this; + } + + ImageResolve& setDstOffset( Offset3D dstOffset_ ) + { + dstOffset = dstOffset_; + return *this; + } + + ImageResolve& setExtent( Extent3D extent_ ) + { + extent = extent_; + return *this; + } + + operator const VkImageResolve&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageResolve const& rhs ) const + { + return ( srcSubresource == rhs.srcSubresource ) + && ( srcOffset == rhs.srcOffset ) + && ( dstSubresource == rhs.dstSubresource ) + && ( dstOffset == rhs.dstOffset ) + && ( extent == rhs.extent ); + } + + bool operator!=( ImageResolve const& rhs ) const + { + return !operator==( rhs ); + } + + ImageSubresourceLayers srcSubresource; + Offset3D srcOffset; + ImageSubresourceLayers dstSubresource; + Offset3D dstOffset; + Extent3D extent; + }; + static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); + + struct ClearAttachment + { + ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), + uint32_t colorAttachment_ = 0, + ClearValue clearValue_ = ClearValue() ) + : aspectMask( aspectMask_ ) + , colorAttachment( colorAttachment_ ) + , clearValue( clearValue_ ) + { + } + + ClearAttachment( VkClearAttachment const & rhs ) + { + memcpy( this, &rhs, sizeof( ClearAttachment ) ); + } + + ClearAttachment& operator=( VkClearAttachment const & rhs ) + { + memcpy( this, &rhs, sizeof( ClearAttachment ) ); + return *this; + } + ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ ) + { + aspectMask = aspectMask_; + return *this; + } + + ClearAttachment& setColorAttachment( uint32_t colorAttachment_ ) + { + colorAttachment = colorAttachment_; + return *this; + } + + ClearAttachment& setClearValue( ClearValue clearValue_ ) + { + clearValue = clearValue_; + return *this; + } + + operator const VkClearAttachment&() const + { + return *reinterpret_cast(this); + } + + ImageAspectFlags aspectMask; + uint32_t colorAttachment; + ClearValue clearValue; + }; + static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); + + struct InputAttachmentAspectReference + { + InputAttachmentAspectReference( uint32_t subpass_ = 0, + uint32_t inputAttachmentIndex_ = 0, + ImageAspectFlags aspectMask_ = ImageAspectFlags() ) + : subpass( subpass_ ) + , inputAttachmentIndex( inputAttachmentIndex_ ) + , aspectMask( aspectMask_ ) + { + } + + InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) + { + memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) ); + } + + InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs ) + { + memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) ); + return *this; + } + InputAttachmentAspectReference& setSubpass( uint32_t subpass_ ) + { + subpass = subpass_; + return *this; + } + + InputAttachmentAspectReference& setInputAttachmentIndex( uint32_t inputAttachmentIndex_ ) + { + inputAttachmentIndex = inputAttachmentIndex_; + return *this; + } + + InputAttachmentAspectReference& setAspectMask( ImageAspectFlags aspectMask_ ) + { + aspectMask = aspectMask_; + return *this; + } + + operator const VkInputAttachmentAspectReference&() const + { + return *reinterpret_cast(this); + } + + bool operator==( InputAttachmentAspectReference const& rhs ) const + { + return ( subpass == rhs.subpass ) + && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) + && ( aspectMask == rhs.aspectMask ); + } + + bool operator!=( InputAttachmentAspectReference const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t subpass; + uint32_t inputAttachmentIndex; + ImageAspectFlags aspectMask; + }; + static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" ); + + using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; + + struct RenderPassInputAttachmentAspectCreateInfo + { + RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0, + const InputAttachmentAspectReference* pAspectReferences_ = nullptr ) + : aspectReferenceCount( aspectReferenceCount_ ) + , pAspectReferences( pAspectReferences_ ) + { + } + + RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) ); + } + + RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) ); + return *this; + } + RenderPassInputAttachmentAspectCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassInputAttachmentAspectCreateInfo& setAspectReferenceCount( uint32_t aspectReferenceCount_ ) + { + aspectReferenceCount = aspectReferenceCount_; + return *this; + } + + RenderPassInputAttachmentAspectCreateInfo& setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ ) + { + pAspectReferences = pAspectReferences_; + return *this; + } + + operator const VkRenderPassInputAttachmentAspectCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( aspectReferenceCount == rhs.aspectReferenceCount ) + && ( pAspectReferences == rhs.pAspectReferences ); + } + + bool operator!=( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; + + public: + const void* pNext = nullptr; + uint32_t aspectReferenceCount; + const InputAttachmentAspectReference* pAspectReferences; + }; + static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" ); + + using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; + + struct BindImagePlaneMemoryInfo + { + BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) + : planeAspect( planeAspect_ ) + { + } + + BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) ); + } + + BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) ); + return *this; + } + BindImagePlaneMemoryInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindImagePlaneMemoryInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ ) + { + planeAspect = planeAspect_; + return *this; + } + + operator const VkBindImagePlaneMemoryInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BindImagePlaneMemoryInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( planeAspect == rhs.planeAspect ); + } + + bool operator!=( BindImagePlaneMemoryInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindImagePlaneMemoryInfo; + + public: + const void* pNext = nullptr; + ImageAspectFlagBits planeAspect; + }; + static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" ); + + using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; + + struct ImagePlaneMemoryRequirementsInfo + { + ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) + : planeAspect( planeAspect_ ) + { + } + + ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) ); + } + + ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) ); + return *this; + } + ImagePlaneMemoryRequirementsInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImagePlaneMemoryRequirementsInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ ) + { + planeAspect = planeAspect_; + return *this; + } + + operator const VkImagePlaneMemoryRequirementsInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImagePlaneMemoryRequirementsInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( planeAspect == rhs.planeAspect ); + } + + bool operator!=( ImagePlaneMemoryRequirementsInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; + + public: + const void* pNext = nullptr; + ImageAspectFlagBits planeAspect; + }; + static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" ); + + using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; + + enum class SparseImageFormatFlagBits + { + eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, + eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, + eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT + }; + + using SparseImageFormatFlags = Flags; + + VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 ) + { + return SparseImageFormatFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits ) + { + return ~( SparseImageFormatFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize) + }; + }; + + struct SparseImageFormatProperties + { + operator const VkSparseImageFormatProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageFormatProperties const& rhs ) const + { + return ( aspectMask == rhs.aspectMask ) + && ( imageGranularity == rhs.imageGranularity ) + && ( flags == rhs.flags ); + } + + bool operator!=( SparseImageFormatProperties const& rhs ) const + { + return !operator==( rhs ); + } + + ImageAspectFlags aspectMask; + Extent3D imageGranularity; + SparseImageFormatFlags flags; + }; + static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); + + struct SparseImageMemoryRequirements + { + operator const VkSparseImageMemoryRequirements&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageMemoryRequirements const& rhs ) const + { + return ( formatProperties == rhs.formatProperties ) + && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) + && ( imageMipTailSize == rhs.imageMipTailSize ) + && ( imageMipTailOffset == rhs.imageMipTailOffset ) + && ( imageMipTailStride == rhs.imageMipTailStride ); + } + + bool operator!=( SparseImageMemoryRequirements const& rhs ) const + { + return !operator==( rhs ); + } + + SparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + DeviceSize imageMipTailSize; + DeviceSize imageMipTailOffset; + DeviceSize imageMipTailStride; + }; + static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); + + struct SparseImageFormatProperties2 + { + operator const VkSparseImageFormatProperties2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageFormatProperties2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( properties == rhs.properties ); + } + + bool operator!=( SparseImageFormatProperties2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSparseImageFormatProperties2; + + public: + void* pNext = nullptr; + SparseImageFormatProperties properties; + }; + static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" ); + + using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; + + struct SparseImageMemoryRequirements2 + { + operator const VkSparseImageMemoryRequirements2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageMemoryRequirements2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryRequirements == rhs.memoryRequirements ); + } + + bool operator!=( SparseImageMemoryRequirements2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSparseImageMemoryRequirements2; + + public: + void* pNext = nullptr; + SparseImageMemoryRequirements memoryRequirements; + }; + static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" ); + + using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; + + enum class SparseMemoryBindFlagBits + { + eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT + }; + + using SparseMemoryBindFlags = Flags; + + VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 ) + { + return SparseMemoryBindFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits ) + { + return ~( SparseMemoryBindFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata) + }; + }; + + struct SparseMemoryBind + { + SparseMemoryBind( DeviceSize resourceOffset_ = 0, + DeviceSize size_ = 0, + DeviceMemory memory_ = DeviceMemory(), + DeviceSize memoryOffset_ = 0, + SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) + : resourceOffset( resourceOffset_ ) + , size( size_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , flags( flags_ ) + { + } + + SparseMemoryBind( VkSparseMemoryBind const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); + } + + SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); + return *this; + } + SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ ) + { + resourceOffset = resourceOffset_; + return *this; + } + + SparseMemoryBind& setSize( DeviceSize size_ ) + { + size = size_; + return *this; + } + + SparseMemoryBind& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) + { + memoryOffset = memoryOffset_; + return *this; + } + + SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkSparseMemoryBind&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseMemoryBind const& rhs ) const + { + return ( resourceOffset == rhs.resourceOffset ) + && ( size == rhs.size ) + && ( memory == rhs.memory ) + && ( memoryOffset == rhs.memoryOffset ) + && ( flags == rhs.flags ); + } + + bool operator!=( SparseMemoryBind const& rhs ) const + { + return !operator==( rhs ); + } + + DeviceSize resourceOffset; + DeviceSize size; + DeviceMemory memory; + DeviceSize memoryOffset; + SparseMemoryBindFlags flags; + }; + static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); + + struct SparseImageMemoryBind + { + SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), + Offset3D offset_ = Offset3D(), + Extent3D extent_ = Extent3D(), + DeviceMemory memory_ = DeviceMemory(), + DeviceSize memoryOffset_ = 0, + SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) + : subresource( subresource_ ) + , offset( offset_ ) + , extent( extent_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , flags( flags_ ) + { + } + + SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); + } + + SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); + return *this; + } + SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ ) + { + subresource = subresource_; + return *this; + } + + SparseImageMemoryBind& setOffset( Offset3D offset_ ) + { + offset = offset_; + return *this; + } + + SparseImageMemoryBind& setExtent( Extent3D extent_ ) + { + extent = extent_; + return *this; + } + + SparseImageMemoryBind& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) + { + memoryOffset = memoryOffset_; + return *this; + } + + SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkSparseImageMemoryBind&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageMemoryBind const& rhs ) const + { + return ( subresource == rhs.subresource ) + && ( offset == rhs.offset ) + && ( extent == rhs.extent ) + && ( memory == rhs.memory ) + && ( memoryOffset == rhs.memoryOffset ) + && ( flags == rhs.flags ); + } + + bool operator!=( SparseImageMemoryBind const& rhs ) const + { + return !operator==( rhs ); + } + + ImageSubresource subresource; + Offset3D offset; + Extent3D extent; + DeviceMemory memory; + DeviceSize memoryOffset; + SparseMemoryBindFlags flags; + }; + static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" ); + + struct SparseBufferMemoryBindInfo + { + SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), + uint32_t bindCount_ = 0, + const SparseMemoryBind* pBinds_ = nullptr ) + : buffer( buffer_ ) + , bindCount( bindCount_ ) + , pBinds( pBinds_ ) + { + } + + SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); + } + + SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); + return *this; + } + SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ ) + { + bindCount = bindCount_; + return *this; + } + + SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) + { + pBinds = pBinds_; + return *this; + } + + operator const VkSparseBufferMemoryBindInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseBufferMemoryBindInfo const& rhs ) const + { + return ( buffer == rhs.buffer ) + && ( bindCount == rhs.bindCount ) + && ( pBinds == rhs.pBinds ); + } + + bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const + { + return !operator==( rhs ); + } + + Buffer buffer; + uint32_t bindCount; + const SparseMemoryBind* pBinds; + }; + static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" ); + + struct SparseImageOpaqueMemoryBindInfo + { + SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), + uint32_t bindCount_ = 0, + const SparseMemoryBind* pBinds_ = nullptr ) + : image( image_ ) + , bindCount( bindCount_ ) + , pBinds( pBinds_ ) + { + } + + SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); + } + + SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); + return *this; + } + SparseImageOpaqueMemoryBindInfo& setImage( Image image_ ) + { + image = image_; + return *this; + } + + SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ ) + { + bindCount = bindCount_; + return *this; + } + + SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) + { + pBinds = pBinds_; + return *this; + } + + operator const VkSparseImageOpaqueMemoryBindInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const + { + return ( image == rhs.image ) + && ( bindCount == rhs.bindCount ) + && ( pBinds == rhs.pBinds ); + } + + bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const + { + return !operator==( rhs ); + } + + Image image; + uint32_t bindCount; + const SparseMemoryBind* pBinds; + }; + static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" ); + + struct SparseImageMemoryBindInfo + { + SparseImageMemoryBindInfo( Image image_ = Image(), + uint32_t bindCount_ = 0, + const SparseImageMemoryBind* pBinds_ = nullptr ) + : image( image_ ) + , bindCount( bindCount_ ) + , pBinds( pBinds_ ) + { + } + + SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); + } + + SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); + return *this; + } + SparseImageMemoryBindInfo& setImage( Image image_ ) + { + image = image_; + return *this; + } + + SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ ) + { + bindCount = bindCount_; + return *this; + } + + SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ ) + { + pBinds = pBinds_; + return *this; + } + + operator const VkSparseImageMemoryBindInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageMemoryBindInfo const& rhs ) const + { + return ( image == rhs.image ) + && ( bindCount == rhs.bindCount ) + && ( pBinds == rhs.pBinds ); + } + + bool operator!=( SparseImageMemoryBindInfo const& rhs ) const + { + return !operator==( rhs ); + } + + Image image; + uint32_t bindCount; + const SparseImageMemoryBind* pBinds; + }; + static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); + + struct BindSparseInfo + { + BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, + const Semaphore* pWaitSemaphores_ = nullptr, + uint32_t bufferBindCount_ = 0, + const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, + uint32_t imageOpaqueBindCount_ = 0, + const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, + uint32_t imageBindCount_ = 0, + const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, + uint32_t signalSemaphoreCount_ = 0, + const Semaphore* pSignalSemaphores_ = nullptr ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , bufferBindCount( bufferBindCount_ ) + , pBufferBinds( pBufferBinds_ ) + , imageOpaqueBindCount( imageOpaqueBindCount_ ) + , pImageOpaqueBinds( pImageOpaqueBinds_ ) + , imageBindCount( imageBindCount_ ) + , pImageBinds( pImageBinds_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphores( pSignalSemaphores_ ) + { + } + + BindSparseInfo( VkBindSparseInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); + } + + BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); + return *this; + } + BindSparseInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) + { + pWaitSemaphores = pWaitSemaphores_; + return *this; + } + + BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ ) + { + bufferBindCount = bufferBindCount_; + return *this; + } + + BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ ) + { + pBufferBinds = pBufferBinds_; + return *this; + } + + BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) + { + imageOpaqueBindCount = imageOpaqueBindCount_; + return *this; + } + + BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ ) + { + pImageOpaqueBinds = pImageOpaqueBinds_; + return *this; + } + + BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ ) + { + imageBindCount = imageBindCount_; + return *this; + } + + BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ ) + { + pImageBinds = pImageBinds_; + return *this; + } + + BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) + { + signalSemaphoreCount = signalSemaphoreCount_; + return *this; + } + + BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) + { + pSignalSemaphores = pSignalSemaphores_; + return *this; + } + + operator const VkBindSparseInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BindSparseInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) + && ( pWaitSemaphores == rhs.pWaitSemaphores ) + && ( bufferBindCount == rhs.bufferBindCount ) + && ( pBufferBinds == rhs.pBufferBinds ) + && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) + && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) + && ( imageBindCount == rhs.imageBindCount ) + && ( pImageBinds == rhs.pImageBinds ) + && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) + && ( pSignalSemaphores == rhs.pSignalSemaphores ); + } + + bool operator!=( BindSparseInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindSparseInfo; + + public: + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const Semaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const SparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const SparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const Semaphore* pSignalSemaphores; + }; + static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); + + enum class PipelineStageFlagBits + { + eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, + eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, + eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, + eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, + eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, + eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, + eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, + eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, + eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, + eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, + eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + eHost = VK_PIPELINE_STAGE_HOST_BIT, + eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, + eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX + }; + + using PipelineStageFlags = Flags; + + VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 ) + { + return PipelineStageFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits ) + { + return ~( PipelineStageFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) + }; + }; + + enum class CommandPoolCreateFlagBits + { + eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, + eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, + eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT + }; + + using CommandPoolCreateFlags = Flags; + + VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 ) + { + return CommandPoolCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits ) + { + return ~( CommandPoolCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) | VkFlags(CommandPoolCreateFlagBits::eProtected) + }; + }; + + struct CommandPoolCreateInfo + { + CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), + uint32_t queueFamilyIndex_ = 0 ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + { + } + + CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); + } + + CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); + return *this; + } + CommandPoolCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + operator const VkCommandPoolCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CommandPoolCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( queueFamilyIndex == rhs.queueFamilyIndex ); + } + + bool operator!=( CommandPoolCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCommandPoolCreateInfo; + + public: + const void* pNext = nullptr; + CommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; + }; + static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); + + enum class CommandPoolResetFlagBits + { + eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT + }; + + using CommandPoolResetFlags = Flags; + + VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 ) + { + return CommandPoolResetFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits ) + { + return ~( CommandPoolResetFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources) + }; + }; + + enum class CommandBufferResetFlagBits + { + eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT + }; + + using CommandBufferResetFlags = Flags; + + VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 ) + { + return CommandBufferResetFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits ) + { + return ~( CommandBufferResetFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources) + }; + }; + + enum class SampleCountFlagBits + { + e1 = VK_SAMPLE_COUNT_1_BIT, + e2 = VK_SAMPLE_COUNT_2_BIT, + e4 = VK_SAMPLE_COUNT_4_BIT, + e8 = VK_SAMPLE_COUNT_8_BIT, + e16 = VK_SAMPLE_COUNT_16_BIT, + e32 = VK_SAMPLE_COUNT_32_BIT, + e64 = VK_SAMPLE_COUNT_64_BIT + }; + + using SampleCountFlags = Flags; + + VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 ) + { + return SampleCountFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits ) + { + return ~( SampleCountFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64) + }; + }; + + struct ImageFormatProperties + { + operator const VkImageFormatProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageFormatProperties const& rhs ) const + { + return ( maxExtent == rhs.maxExtent ) + && ( maxMipLevels == rhs.maxMipLevels ) + && ( maxArrayLayers == rhs.maxArrayLayers ) + && ( sampleCounts == rhs.sampleCounts ) + && ( maxResourceSize == rhs.maxResourceSize ); + } + + bool operator!=( ImageFormatProperties const& rhs ) const + { + return !operator==( rhs ); + } + + Extent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + SampleCountFlags sampleCounts; + DeviceSize maxResourceSize; + }; + static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" ); + + struct ImageCreateInfo + { + ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), + ImageType imageType_ = ImageType::e1D, + Format format_ = Format::eUndefined, + Extent3D extent_ = Extent3D(), + uint32_t mipLevels_ = 0, + uint32_t arrayLayers_ = 0, + SampleCountFlagBits samples_ = SampleCountFlagBits::e1, + ImageTiling tiling_ = ImageTiling::eOptimal, + ImageUsageFlags usage_ = ImageUsageFlags(), + SharingMode sharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = 0, + const uint32_t* pQueueFamilyIndices_ = nullptr, + ImageLayout initialLayout_ = ImageLayout::eUndefined ) + : flags( flags_ ) + , imageType( imageType_ ) + , format( format_ ) + , extent( extent_ ) + , mipLevels( mipLevels_ ) + , arrayLayers( arrayLayers_ ) + , samples( samples_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + , initialLayout( initialLayout_ ) + { + } + + ImageCreateInfo( VkImageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); + } + + ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); + return *this; + } + ImageCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageCreateInfo& setFlags( ImageCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + ImageCreateInfo& setImageType( ImageType imageType_ ) + { + imageType = imageType_; + return *this; + } + + ImageCreateInfo& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + ImageCreateInfo& setExtent( Extent3D extent_ ) + { + extent = extent_; + return *this; + } + + ImageCreateInfo& setMipLevels( uint32_t mipLevels_ ) + { + mipLevels = mipLevels_; + return *this; + } + + ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ ) + { + arrayLayers = arrayLayers_; + return *this; + } + + ImageCreateInfo& setSamples( SampleCountFlagBits samples_ ) + { + samples = samples_; + return *this; + } + + ImageCreateInfo& setTiling( ImageTiling tiling_ ) + { + tiling = tiling_; + return *this; + } + + ImageCreateInfo& setUsage( ImageUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + ImageCreateInfo& setSharingMode( SharingMode sharingMode_ ) + { + sharingMode = sharingMode_; + return *this; + } + + ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ ) + { + initialLayout = initialLayout_; + return *this; + } + + operator const VkImageCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( imageType == rhs.imageType ) + && ( format == rhs.format ) + && ( extent == rhs.extent ) + && ( mipLevels == rhs.mipLevels ) + && ( arrayLayers == rhs.arrayLayers ) + && ( samples == rhs.samples ) + && ( tiling == rhs.tiling ) + && ( usage == rhs.usage ) + && ( sharingMode == rhs.sharingMode ) + && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) + && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) + && ( initialLayout == rhs.initialLayout ); + } + + bool operator!=( ImageCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageCreateInfo; + + public: + const void* pNext = nullptr; + ImageCreateFlags flags; + ImageType imageType; + Format format; + Extent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + SampleCountFlagBits samples; + ImageTiling tiling; + ImageUsageFlags usage; + SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + ImageLayout initialLayout; + }; + static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineMultisampleStateCreateInfo + { + PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), + SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, + Bool32 sampleShadingEnable_ = 0, + float minSampleShading_ = 0, + const SampleMask* pSampleMask_ = nullptr, + Bool32 alphaToCoverageEnable_ = 0, + Bool32 alphaToOneEnable_ = 0 ) + : flags( flags_ ) + , rasterizationSamples( rasterizationSamples_ ) + , sampleShadingEnable( sampleShadingEnable_ ) + , minSampleShading( minSampleShading_ ) + , pSampleMask( pSampleMask_ ) + , alphaToCoverageEnable( alphaToCoverageEnable_ ) + , alphaToOneEnable( alphaToOneEnable_ ) + { + } + + PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); + } + + PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); + return *this; + } + PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) + { + rasterizationSamples = rasterizationSamples_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ ) + { + sampleShadingEnable = sampleShadingEnable_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ ) + { + minSampleShading = minSampleShading_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ ) + { + pSampleMask = pSampleMask_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) + { + alphaToCoverageEnable = alphaToCoverageEnable_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) + { + alphaToOneEnable = alphaToOneEnable_; + return *this; + } + + operator const VkPipelineMultisampleStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( rasterizationSamples == rhs.rasterizationSamples ) + && ( sampleShadingEnable == rhs.sampleShadingEnable ) + && ( minSampleShading == rhs.minSampleShading ) + && ( pSampleMask == rhs.pSampleMask ) + && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) + && ( alphaToOneEnable == rhs.alphaToOneEnable ); + } + + bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; + + public: + const void* pNext = nullptr; + PipelineMultisampleStateCreateFlags flags; + SampleCountFlagBits rasterizationSamples; + Bool32 sampleShadingEnable; + float minSampleShading; + const SampleMask* pSampleMask; + Bool32 alphaToCoverageEnable; + Bool32 alphaToOneEnable; + }; + static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); + + struct GraphicsPipelineCreateInfo + { + GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), + uint32_t stageCount_ = 0, + const PipelineShaderStageCreateInfo* pStages_ = nullptr, + const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, + const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, + const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, + const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, + const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, + const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, + const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, + const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, + const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, + PipelineLayout layout_ = PipelineLayout(), + RenderPass renderPass_ = RenderPass(), + uint32_t subpass_ = 0, + Pipeline basePipelineHandle_ = Pipeline(), + int32_t basePipelineIndex_ = 0 ) + : flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , pVertexInputState( pVertexInputState_ ) + , pInputAssemblyState( pInputAssemblyState_ ) + , pTessellationState( pTessellationState_ ) + , pViewportState( pViewportState_ ) + , pRasterizationState( pRasterizationState_ ) + , pMultisampleState( pMultisampleState_ ) + , pDepthStencilState( pDepthStencilState_ ) + , pColorBlendState( pColorBlendState_ ) + , pDynamicState( pDynamicState_ ) + , layout( layout_ ) + , renderPass( renderPass_ ) + , subpass( subpass_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } + + GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); + } + + GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); + return *this; + } + GraphicsPipelineCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ ) + { + stageCount = stageCount_; + return *this; + } + + GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ ) + { + pStages = pStages_; + return *this; + } + + GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ ) + { + pVertexInputState = pVertexInputState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ ) + { + pInputAssemblyState = pInputAssemblyState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ ) + { + pTessellationState = pTessellationState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ ) + { + pViewportState = pViewportState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ ) + { + pRasterizationState = pRasterizationState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ ) + { + pMultisampleState = pMultisampleState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ ) + { + pDepthStencilState = pDepthStencilState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ ) + { + pColorBlendState = pColorBlendState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ ) + { + pDynamicState = pDynamicState_; + return *this; + } + + GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ ) + { + layout = layout_; + return *this; + } + + GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ ) + { + renderPass = renderPass_; + return *this; + } + + GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ ) + { + subpass = subpass_; + return *this; + } + + GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + operator const VkGraphicsPipelineCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( GraphicsPipelineCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( stageCount == rhs.stageCount ) + && ( pStages == rhs.pStages ) + && ( pVertexInputState == rhs.pVertexInputState ) + && ( pInputAssemblyState == rhs.pInputAssemblyState ) + && ( pTessellationState == rhs.pTessellationState ) + && ( pViewportState == rhs.pViewportState ) + && ( pRasterizationState == rhs.pRasterizationState ) + && ( pMultisampleState == rhs.pMultisampleState ) + && ( pDepthStencilState == rhs.pDepthStencilState ) + && ( pColorBlendState == rhs.pColorBlendState ) + && ( pDynamicState == rhs.pDynamicState ) + && ( layout == rhs.layout ) + && ( renderPass == rhs.renderPass ) + && ( subpass == rhs.subpass ) + && ( basePipelineHandle == rhs.basePipelineHandle ) + && ( basePipelineIndex == rhs.basePipelineIndex ); + } + + bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eGraphicsPipelineCreateInfo; + + public: + const void* pNext = nullptr; + PipelineCreateFlags flags; + uint32_t stageCount; + const PipelineShaderStageCreateInfo* pStages; + const PipelineVertexInputStateCreateInfo* pVertexInputState; + const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const PipelineTessellationStateCreateInfo* pTessellationState; + const PipelineViewportStateCreateInfo* pViewportState; + const PipelineRasterizationStateCreateInfo* pRasterizationState; + const PipelineMultisampleStateCreateInfo* pMultisampleState; + const PipelineDepthStencilStateCreateInfo* pDepthStencilState; + const PipelineColorBlendStateCreateInfo* pColorBlendState; + const PipelineDynamicStateCreateInfo* pDynamicState; + PipelineLayout layout; + RenderPass renderPass; + uint32_t subpass; + Pipeline basePipelineHandle; + int32_t basePipelineIndex; + }; + static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceLimits + { + operator const VkPhysicalDeviceLimits&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceLimits const& rhs ) const + { + return ( maxImageDimension1D == rhs.maxImageDimension1D ) + && ( maxImageDimension2D == rhs.maxImageDimension2D ) + && ( maxImageDimension3D == rhs.maxImageDimension3D ) + && ( maxImageDimensionCube == rhs.maxImageDimensionCube ) + && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) + && ( maxTexelBufferElements == rhs.maxTexelBufferElements ) + && ( maxUniformBufferRange == rhs.maxUniformBufferRange ) + && ( maxStorageBufferRange == rhs.maxStorageBufferRange ) + && ( maxPushConstantsSize == rhs.maxPushConstantsSize ) + && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) + && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) + && ( bufferImageGranularity == rhs.bufferImageGranularity ) + && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) + && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) + && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) + && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) + && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) + && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) + && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) + && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) + && ( maxPerStageResources == rhs.maxPerStageResources ) + && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) + && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) + && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) + && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) + && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) + && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) + && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) + && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) + && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) + && ( maxVertexInputBindings == rhs.maxVertexInputBindings ) + && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) + && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) + && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) + && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) + && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) + && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) + && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents ) + && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) + && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) + && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) + && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) + && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) + && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) + && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) + && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) + && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) + && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) + && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) + && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) + && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) + && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) + && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 ) + && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) + && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ) + && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) + && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) + && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) + && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) + && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) + && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) + && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) + && ( maxViewports == rhs.maxViewports ) + && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 ) + && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 ) + && ( viewportSubPixelBits == rhs.viewportSubPixelBits ) + && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) + && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) + && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) + && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) + && ( minTexelOffset == rhs.minTexelOffset ) + && ( maxTexelOffset == rhs.maxTexelOffset ) + && ( minTexelGatherOffset == rhs.minTexelGatherOffset ) + && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) + && ( minInterpolationOffset == rhs.minInterpolationOffset ) + && ( maxInterpolationOffset == rhs.maxInterpolationOffset ) + && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) + && ( maxFramebufferWidth == rhs.maxFramebufferWidth ) + && ( maxFramebufferHeight == rhs.maxFramebufferHeight ) + && ( maxFramebufferLayers == rhs.maxFramebufferLayers ) + && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) + && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) + && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) + && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) + && ( maxColorAttachments == rhs.maxColorAttachments ) + && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) + && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) + && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) + && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) + && ( storageImageSampleCounts == rhs.storageImageSampleCounts ) + && ( maxSampleMaskWords == rhs.maxSampleMaskWords ) + && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) + && ( timestampPeriod == rhs.timestampPeriod ) + && ( maxClipDistances == rhs.maxClipDistances ) + && ( maxCullDistances == rhs.maxCullDistances ) + && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) + && ( discreteQueuePriorities == rhs.discreteQueuePriorities ) + && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 ) + && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 ) + && ( pointSizeGranularity == rhs.pointSizeGranularity ) + && ( lineWidthGranularity == rhs.lineWidthGranularity ) + && ( strictLines == rhs.strictLines ) + && ( standardSampleLocations == rhs.standardSampleLocations ) + && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) + && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) + && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); + } + + bool operator!=( PhysicalDeviceLimits const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + DeviceSize bufferImageGranularity; + DeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + DeviceSize minTexelBufferOffsetAlignment; + DeviceSize minUniformBufferOffsetAlignment; + DeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + SampleCountFlags framebufferColorSampleCounts; + SampleCountFlags framebufferDepthSampleCounts; + SampleCountFlags framebufferStencilSampleCounts; + SampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + SampleCountFlags sampledImageColorSampleCounts; + SampleCountFlags sampledImageIntegerSampleCounts; + SampleCountFlags sampledImageDepthSampleCounts; + SampleCountFlags sampledImageStencilSampleCounts; + SampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + Bool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + Bool32 strictLines; + Bool32 standardSampleLocations; + DeviceSize optimalBufferCopyOffsetAlignment; + DeviceSize optimalBufferCopyRowPitchAlignment; + DeviceSize nonCoherentAtomSize; + }; + static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceProperties + { + operator const VkPhysicalDeviceProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceProperties const& rhs ) const + { + return ( apiVersion == rhs.apiVersion ) + && ( driverVersion == rhs.driverVersion ) + && ( vendorID == rhs.vendorID ) + && ( deviceID == rhs.deviceID ) + && ( deviceType == rhs.deviceType ) + && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 ) + && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) + && ( limits == rhs.limits ) + && ( sparseProperties == rhs.sparseProperties ); + } + + bool operator!=( PhysicalDeviceProperties const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + PhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + PhysicalDeviceLimits limits; + PhysicalDeviceSparseProperties sparseProperties; + }; + static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceProperties2 + { + operator const VkPhysicalDeviceProperties2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceProperties2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( properties == rhs.properties ); + } + + bool operator!=( PhysicalDeviceProperties2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceProperties2; + + public: + void* pNext = nullptr; + PhysicalDeviceProperties properties; + }; + static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" ); + + using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; + + struct ImageFormatProperties2 + { + operator const VkImageFormatProperties2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageFormatProperties2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( imageFormatProperties == rhs.imageFormatProperties ); + } + + bool operator!=( ImageFormatProperties2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageFormatProperties2; + + public: + void* pNext = nullptr; + ImageFormatProperties imageFormatProperties; + }; + static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" ); + + using ImageFormatProperties2KHR = ImageFormatProperties2; + + struct PhysicalDeviceSparseImageFormatInfo2 + { + PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined, + ImageType type_ = ImageType::e1D, + SampleCountFlagBits samples_ = SampleCountFlagBits::e1, + ImageUsageFlags usage_ = ImageUsageFlags(), + ImageTiling tiling_ = ImageTiling::eOptimal ) + : format( format_ ) + , type( type_ ) + , samples( samples_ ) + , usage( usage_ ) + , tiling( tiling_ ) + { + } + + PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) ); + } + + PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) ); + return *this; + } + PhysicalDeviceSparseImageFormatInfo2& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2& setType( ImageType type_ ) + { + type = type_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2& setSamples( SampleCountFlagBits samples_ ) + { + samples = samples_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2& setUsage( ImageUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2& setTiling( ImageTiling tiling_ ) + { + tiling = tiling_; + return *this; + } + + operator const VkPhysicalDeviceSparseImageFormatInfo2&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( format == rhs.format ) + && ( type == rhs.type ) + && ( samples == rhs.samples ) + && ( usage == rhs.usage ) + && ( tiling == rhs.tiling ); + } + + bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; + + public: + const void* pNext = nullptr; + Format format; + ImageType type; + SampleCountFlagBits samples; + ImageUsageFlags usage; + ImageTiling tiling; + }; + static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" ); + + using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; + + struct SampleLocationsInfoEXT + { + SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, + Extent2D sampleLocationGridSize_ = Extent2D(), + uint32_t sampleLocationsCount_ = 0, + const SampleLocationEXT* pSampleLocations_ = nullptr ) + : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) + , sampleLocationGridSize( sampleLocationGridSize_ ) + , sampleLocationsCount( sampleLocationsCount_ ) + , pSampleLocations( pSampleLocations_ ) + { + } + + SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) ); + } + + SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) ); + return *this; + } + SampleLocationsInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SampleLocationsInfoEXT& setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) + { + sampleLocationsPerPixel = sampleLocationsPerPixel_; + return *this; + } + + SampleLocationsInfoEXT& setSampleLocationGridSize( Extent2D sampleLocationGridSize_ ) + { + sampleLocationGridSize = sampleLocationGridSize_; + return *this; + } + + SampleLocationsInfoEXT& setSampleLocationsCount( uint32_t sampleLocationsCount_ ) + { + sampleLocationsCount = sampleLocationsCount_; + return *this; + } + + SampleLocationsInfoEXT& setPSampleLocations( const SampleLocationEXT* pSampleLocations_ ) + { + pSampleLocations = pSampleLocations_; + return *this; + } + + operator const VkSampleLocationsInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SampleLocationsInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) + && ( sampleLocationGridSize == rhs.sampleLocationGridSize ) + && ( sampleLocationsCount == rhs.sampleLocationsCount ) + && ( pSampleLocations == rhs.pSampleLocations ); + } + + bool operator!=( SampleLocationsInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSampleLocationsInfoEXT; + + public: + const void* pNext = nullptr; + SampleCountFlagBits sampleLocationsPerPixel; + Extent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const SampleLocationEXT* pSampleLocations; + }; + static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" ); + + struct AttachmentSampleLocationsEXT + { + AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0, + SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) + : attachmentIndex( attachmentIndex_ ) + , sampleLocationsInfo( sampleLocationsInfo_ ) + { + } + + AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) ); + } + + AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) ); + return *this; + } + AttachmentSampleLocationsEXT& setAttachmentIndex( uint32_t attachmentIndex_ ) + { + attachmentIndex = attachmentIndex_; + return *this; + } + + AttachmentSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) + { + sampleLocationsInfo = sampleLocationsInfo_; + return *this; + } + + operator const VkAttachmentSampleLocationsEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AttachmentSampleLocationsEXT const& rhs ) const + { + return ( attachmentIndex == rhs.attachmentIndex ) + && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + } + + bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t attachmentIndex; + SampleLocationsInfoEXT sampleLocationsInfo; + }; + static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" ); + + struct SubpassSampleLocationsEXT + { + SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0, + SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) + : subpassIndex( subpassIndex_ ) + , sampleLocationsInfo( sampleLocationsInfo_ ) + { + } + + SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) ); + } + + SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) ); + return *this; + } + SubpassSampleLocationsEXT& setSubpassIndex( uint32_t subpassIndex_ ) + { + subpassIndex = subpassIndex_; + return *this; + } + + SubpassSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) + { + sampleLocationsInfo = sampleLocationsInfo_; + return *this; + } + + operator const VkSubpassSampleLocationsEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SubpassSampleLocationsEXT const& rhs ) const + { + return ( subpassIndex == rhs.subpassIndex ) + && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + } + + bool operator!=( SubpassSampleLocationsEXT const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t subpassIndex; + SampleLocationsInfoEXT sampleLocationsInfo; + }; + static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" ); + + struct RenderPassSampleLocationsBeginInfoEXT + { + RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, + const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, + uint32_t postSubpassSampleLocationsCount_ = 0, + const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) + : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) + , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) + , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) + , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) + { + } + + RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) ); + } + + RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) ); + return *this; + } + RenderPassSampleLocationsBeginInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassSampleLocationsBeginInfoEXT& setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) + { + attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_; + return *this; + } + + RenderPassSampleLocationsBeginInfoEXT& setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ ) + { + pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_; + return *this; + } + + RenderPassSampleLocationsBeginInfoEXT& setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) + { + postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_; + return *this; + } + + RenderPassSampleLocationsBeginInfoEXT& setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ ) + { + pPostSubpassSampleLocations = pPostSubpassSampleLocations_; + return *this; + } + + operator const VkRenderPassSampleLocationsBeginInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) + && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) + && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) + && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); + } + + bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; + + public: + const void* pNext = nullptr; + uint32_t attachmentInitialSampleLocationsCount; + const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const SubpassSampleLocationsEXT* pPostSubpassSampleLocations; + }; + static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" ); + + struct PipelineSampleLocationsStateCreateInfoEXT + { + PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0, + SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) + : sampleLocationsEnable( sampleLocationsEnable_ ) + , sampleLocationsInfo( sampleLocationsInfo_ ) + { + } + + PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) ); + } + + PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) ); + return *this; + } + PipelineSampleLocationsStateCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsEnable( Bool32 sampleLocationsEnable_ ) + { + sampleLocationsEnable = sampleLocationsEnable_; + return *this; + } + + PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) + { + sampleLocationsInfo = sampleLocationsInfo_; + return *this; + } + + operator const VkPipelineSampleLocationsStateCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( sampleLocationsEnable == rhs.sampleLocationsEnable ) + && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + } + + bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; + + public: + const void* pNext = nullptr; + Bool32 sampleLocationsEnable; + SampleLocationsInfoEXT sampleLocationsInfo; + }; + static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceSampleLocationsPropertiesEXT + { + operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) + && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) + && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 ) + && ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) + && ( variableSampleLocations == rhs.variableSampleLocations ); + } + + bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; + + public: + void* pNext = nullptr; + SampleCountFlags sampleLocationSampleCounts; + Extent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + Bool32 variableSampleLocations; + }; + static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" ); + + enum class AttachmentDescriptionFlagBits + { + eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT + }; + + using AttachmentDescriptionFlags = Flags; + + VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 ) + { + return AttachmentDescriptionFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits ) + { + return ~( AttachmentDescriptionFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias) + }; + }; + + struct AttachmentDescription + { + AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), + Format format_ = Format::eUndefined, + SampleCountFlagBits samples_ = SampleCountFlagBits::e1, + AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, + AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, + AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, + AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, + ImageLayout initialLayout_ = ImageLayout::eUndefined, + ImageLayout finalLayout_ = ImageLayout::eUndefined ) + : flags( flags_ ) + , format( format_ ) + , samples( samples_ ) + , loadOp( loadOp_ ) + , storeOp( storeOp_ ) + , stencilLoadOp( stencilLoadOp_ ) + , stencilStoreOp( stencilStoreOp_ ) + , initialLayout( initialLayout_ ) + , finalLayout( finalLayout_ ) + { + } + + AttachmentDescription( VkAttachmentDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); + } + + AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); + return *this; + } + AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ ) + { + flags = flags_; + return *this; + } + + AttachmentDescription& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + AttachmentDescription& setSamples( SampleCountFlagBits samples_ ) + { + samples = samples_; + return *this; + } + + AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ ) + { + loadOp = loadOp_; + return *this; + } + + AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ ) + { + storeOp = storeOp_; + return *this; + } + + AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) + { + stencilLoadOp = stencilLoadOp_; + return *this; + } + + AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) + { + stencilStoreOp = stencilStoreOp_; + return *this; + } + + AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ ) + { + initialLayout = initialLayout_; + return *this; + } + + AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ ) + { + finalLayout = finalLayout_; + return *this; + } + + operator const VkAttachmentDescription&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AttachmentDescription const& rhs ) const + { + return ( flags == rhs.flags ) + && ( format == rhs.format ) + && ( samples == rhs.samples ) + && ( loadOp == rhs.loadOp ) + && ( storeOp == rhs.storeOp ) + && ( stencilLoadOp == rhs.stencilLoadOp ) + && ( stencilStoreOp == rhs.stencilStoreOp ) + && ( initialLayout == rhs.initialLayout ) + && ( finalLayout == rhs.finalLayout ); + } + + bool operator!=( AttachmentDescription const& rhs ) const + { + return !operator==( rhs ); + } + + AttachmentDescriptionFlags flags; + Format format; + SampleCountFlagBits samples; + AttachmentLoadOp loadOp; + AttachmentStoreOp storeOp; + AttachmentLoadOp stencilLoadOp; + AttachmentStoreOp stencilStoreOp; + ImageLayout initialLayout; + ImageLayout finalLayout; + }; + static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); + + enum class StencilFaceFlagBits + { + eFront = VK_STENCIL_FACE_FRONT_BIT, + eBack = VK_STENCIL_FACE_BACK_BIT, + eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK + }; + + using StencilFaceFlags = Flags; + + VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 ) + { + return StencilFaceFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits ) + { + return ~( StencilFaceFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack) + }; + }; + + enum class DescriptorPoolCreateFlagBits + { + eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, + eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT + }; + + using DescriptorPoolCreateFlags = Flags; + + VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 ) + { + return DescriptorPoolCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits ) + { + return ~( DescriptorPoolCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT) + }; + }; + + struct DescriptorPoolCreateInfo + { + DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), + uint32_t maxSets_ = 0, + uint32_t poolSizeCount_ = 0, + const DescriptorPoolSize* pPoolSizes_ = nullptr ) + : flags( flags_ ) + , maxSets( maxSets_ ) + , poolSizeCount( poolSizeCount_ ) + , pPoolSizes( pPoolSizes_ ) + { + } + + DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); + } + + DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); + return *this; + } + DescriptorPoolCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ ) + { + maxSets = maxSets_; + return *this; + } + + DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ ) + { + poolSizeCount = poolSizeCount_; + return *this; + } + + DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ ) + { + pPoolSizes = pPoolSizes_; + return *this; + } + + operator const VkDescriptorPoolCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorPoolCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( maxSets == rhs.maxSets ) + && ( poolSizeCount == rhs.poolSizeCount ) + && ( pPoolSizes == rhs.pPoolSizes ); + } + + bool operator!=( DescriptorPoolCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorPoolCreateInfo; + + public: + const void* pNext = nullptr; + DescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const DescriptorPoolSize* pPoolSizes; + }; + static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); + + enum class DependencyFlagBits + { + eByRegion = VK_DEPENDENCY_BY_REGION_BIT, + eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, + eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT, + eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT + }; + + using DependencyFlags = Flags; + + VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 ) + { + return DependencyFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits ) + { + return ~( DependencyFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eDeviceGroup) | VkFlags(DependencyFlagBits::eViewLocal) + }; + }; + + struct SubpassDependency + { + SubpassDependency( uint32_t srcSubpass_ = 0, + uint32_t dstSubpass_ = 0, + PipelineStageFlags srcStageMask_ = PipelineStageFlags(), + PipelineStageFlags dstStageMask_ = PipelineStageFlags(), + AccessFlags srcAccessMask_ = AccessFlags(), + AccessFlags dstAccessMask_ = AccessFlags(), + DependencyFlags dependencyFlags_ = DependencyFlags() ) + : srcSubpass( srcSubpass_ ) + , dstSubpass( dstSubpass_ ) + , srcStageMask( srcStageMask_ ) + , dstStageMask( dstStageMask_ ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , dependencyFlags( dependencyFlags_ ) + { + } + + SubpassDependency( VkSubpassDependency const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDependency ) ); + } + + SubpassDependency& operator=( VkSubpassDependency const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDependency ) ); + return *this; + } + SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ ) + { + srcSubpass = srcSubpass_; + return *this; + } + + SubpassDependency& setDstSubpass( uint32_t dstSubpass_ ) + { + dstSubpass = dstSubpass_; + return *this; + } + + SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ ) + { + srcStageMask = srcStageMask_; + return *this; + } + + SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ ) + { + dstStageMask = dstStageMask_; + return *this; + } + + SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ ) + { + srcAccessMask = srcAccessMask_; + return *this; + } + + SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ ) + { + dstAccessMask = dstAccessMask_; + return *this; + } + + SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ ) + { + dependencyFlags = dependencyFlags_; + return *this; + } + + operator const VkSubpassDependency&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SubpassDependency const& rhs ) const + { + return ( srcSubpass == rhs.srcSubpass ) + && ( dstSubpass == rhs.dstSubpass ) + && ( srcStageMask == rhs.srcStageMask ) + && ( dstStageMask == rhs.dstStageMask ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ) + && ( dependencyFlags == rhs.dependencyFlags ); + } + + bool operator!=( SubpassDependency const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t srcSubpass; + uint32_t dstSubpass; + PipelineStageFlags srcStageMask; + PipelineStageFlags dstStageMask; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + DependencyFlags dependencyFlags; + }; + static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); + + enum class PresentModeKHR + { + eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, + eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, + eFifo = VK_PRESENT_MODE_FIFO_KHR, + eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, + eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR + }; + + enum class ColorSpaceKHR + { + eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, + eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, + eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, + eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, + eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, + eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, + eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, + eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, + eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT, + eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, + eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, + eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, + ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, + eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT + }; + + struct SurfaceFormatKHR + { + operator const VkSurfaceFormatKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SurfaceFormatKHR const& rhs ) const + { + return ( format == rhs.format ) + && ( colorSpace == rhs.colorSpace ); + } + + bool operator!=( SurfaceFormatKHR const& rhs ) const + { + return !operator==( rhs ); + } + + Format format; + ColorSpaceKHR colorSpace; + }; + static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); + + struct SurfaceFormat2KHR + { + operator const VkSurfaceFormat2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SurfaceFormat2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surfaceFormat == rhs.surfaceFormat ); + } + + bool operator!=( SurfaceFormat2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceFormat2KHR; + + public: + void* pNext = nullptr; + SurfaceFormatKHR surfaceFormat; + }; + static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); + + enum class DisplayPlaneAlphaFlagBitsKHR + { + eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, + eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, + ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, + ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR + }; + + using DisplayPlaneAlphaFlagsKHR = Flags; + + VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 ) + { + return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits ) + { + return ~( DisplayPlaneAlphaFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) + }; + }; + + struct DisplayPlaneCapabilitiesKHR + { + operator const VkDisplayPlaneCapabilitiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const + { + return ( supportedAlpha == rhs.supportedAlpha ) + && ( minSrcPosition == rhs.minSrcPosition ) + && ( maxSrcPosition == rhs.maxSrcPosition ) + && ( minSrcExtent == rhs.minSrcExtent ) + && ( maxSrcExtent == rhs.maxSrcExtent ) + && ( minDstPosition == rhs.minDstPosition ) + && ( maxDstPosition == rhs.maxDstPosition ) + && ( minDstExtent == rhs.minDstExtent ) + && ( maxDstExtent == rhs.maxDstExtent ); + } + + bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + DisplayPlaneAlphaFlagsKHR supportedAlpha; + Offset2D minSrcPosition; + Offset2D maxSrcPosition; + Extent2D minSrcExtent; + Extent2D maxSrcExtent; + Offset2D minDstPosition; + Offset2D maxDstPosition; + Extent2D minDstExtent; + Extent2D maxDstExtent; + }; + static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); + + struct DisplayPlaneCapabilities2KHR + { + operator const VkDisplayPlaneCapabilities2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( capabilities == rhs.capabilities ); + } + + bool operator!=( DisplayPlaneCapabilities2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; + + public: + void* pNext = nullptr; + DisplayPlaneCapabilitiesKHR capabilities; + }; + static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" ); + + enum class CompositeAlphaFlagBitsKHR + { + eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, + ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, + eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR + }; + + using CompositeAlphaFlagsKHR = Flags; + + VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 ) + { + return CompositeAlphaFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits ) + { + return ~( CompositeAlphaFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit) + }; + }; + + enum class SurfaceTransformFlagBitsKHR + { + eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, + eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, + eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, + eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, + eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, + eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, + eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, + eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, + eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR + }; + + using SurfaceTransformFlagsKHR = Flags; + + VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 ) + { + return SurfaceTransformFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits ) + { + return ~( SurfaceTransformFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit) + }; + }; + + struct DisplayPropertiesKHR + { + operator const VkDisplayPropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPropertiesKHR const& rhs ) const + { + return ( display == rhs.display ) + && ( displayName == rhs.displayName ) + && ( physicalDimensions == rhs.physicalDimensions ) + && ( physicalResolution == rhs.physicalResolution ) + && ( supportedTransforms == rhs.supportedTransforms ) + && ( planeReorderPossible == rhs.planeReorderPossible ) + && ( persistentContent == rhs.persistentContent ); + } + + bool operator!=( DisplayPropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + DisplayKHR display; + const char* displayName; + Extent2D physicalDimensions; + Extent2D physicalResolution; + SurfaceTransformFlagsKHR supportedTransforms; + Bool32 planeReorderPossible; + Bool32 persistentContent; + }; + static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); + + struct DisplaySurfaceCreateInfoKHR + { + DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), + DisplayModeKHR displayMode_ = DisplayModeKHR(), + uint32_t planeIndex_ = 0, + uint32_t planeStackIndex_ = 0, + SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, + float globalAlpha_ = 0, + DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, + Extent2D imageExtent_ = Extent2D() ) + : flags( flags_ ) + , displayMode( displayMode_ ) + , planeIndex( planeIndex_ ) + , planeStackIndex( planeStackIndex_ ) + , transform( transform_ ) + , globalAlpha( globalAlpha_ ) + , alphaMode( alphaMode_ ) + , imageExtent( imageExtent_ ) + { + } + + DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); + } + + DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); + return *this; + } + DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ ) + { + displayMode = displayMode_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ ) + { + planeIndex = planeIndex_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ ) + { + planeStackIndex = planeStackIndex_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ ) + { + transform = transform_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ ) + { + globalAlpha = globalAlpha_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) + { + alphaMode = alphaMode_; + return *this; + } + + DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) + { + imageExtent = imageExtent_; + return *this; + } + + operator const VkDisplaySurfaceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( displayMode == rhs.displayMode ) + && ( planeIndex == rhs.planeIndex ) + && ( planeStackIndex == rhs.planeStackIndex ) + && ( transform == rhs.transform ) + && ( globalAlpha == rhs.globalAlpha ) + && ( alphaMode == rhs.alphaMode ) + && ( imageExtent == rhs.imageExtent ); + } + + bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; + + public: + const void* pNext = nullptr; + DisplaySurfaceCreateFlagsKHR flags; + DisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + SurfaceTransformFlagBitsKHR transform; + float globalAlpha; + DisplayPlaneAlphaFlagBitsKHR alphaMode; + Extent2D imageExtent; + }; + static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); + + struct SurfaceCapabilitiesKHR + { + operator const VkSurfaceCapabilitiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SurfaceCapabilitiesKHR const& rhs ) const + { + return ( minImageCount == rhs.minImageCount ) + && ( maxImageCount == rhs.maxImageCount ) + && ( currentExtent == rhs.currentExtent ) + && ( minImageExtent == rhs.minImageExtent ) + && ( maxImageExtent == rhs.maxImageExtent ) + && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) + && ( supportedTransforms == rhs.supportedTransforms ) + && ( currentTransform == rhs.currentTransform ) + && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) + && ( supportedUsageFlags == rhs.supportedUsageFlags ); + } + + bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t minImageCount; + uint32_t maxImageCount; + Extent2D currentExtent; + Extent2D minImageExtent; + Extent2D maxImageExtent; + uint32_t maxImageArrayLayers; + SurfaceTransformFlagsKHR supportedTransforms; + SurfaceTransformFlagBitsKHR currentTransform; + CompositeAlphaFlagsKHR supportedCompositeAlpha; + ImageUsageFlags supportedUsageFlags; + }; + static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); + + struct SurfaceCapabilities2KHR + { + operator const VkSurfaceCapabilities2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SurfaceCapabilities2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surfaceCapabilities == rhs.surfaceCapabilities ); + } + + bool operator!=( SurfaceCapabilities2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceCapabilities2KHR; + + public: + void* pNext = nullptr; + SurfaceCapabilitiesKHR surfaceCapabilities; + }; + static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); + + struct DisplayProperties2KHR + { + operator const VkDisplayProperties2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayProperties2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( displayProperties == rhs.displayProperties ); + } + + bool operator!=( DisplayProperties2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayProperties2KHR; + + public: + void* pNext = nullptr; + DisplayPropertiesKHR displayProperties; + }; + static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" ); + + enum class DebugReportFlagBitsEXT + { + eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, + eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT, + ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, + eError = VK_DEBUG_REPORT_ERROR_BIT_EXT, + eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT + }; + + using DebugReportFlagsEXT = Flags; + + VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 ) + { + return DebugReportFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits ) + { + return ~( DebugReportFlagsEXT( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug) + }; + }; + + struct DebugReportCallbackCreateInfoEXT + { + DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), + PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, + void* pUserData_ = nullptr ) + : flags( flags_ ) + , pfnCallback( pfnCallback_ ) + , pUserData( pUserData_ ) + { + } + + DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); + } + + DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); + return *this; + } + DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) + { + pfnCallback = pfnCallback_; + return *this; + } + + DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ ) + { + pUserData = pUserData_; + return *this; + } + + operator const VkDebugReportCallbackCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( pfnCallback == rhs.pfnCallback ) + && ( pUserData == rhs.pUserData ); + } + + bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; + + public: + const void* pNext = nullptr; + DebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; + }; + static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class DebugReportObjectTypeEXT + { + eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, + eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, + ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, + eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, + eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, + eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, + eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, + eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, + eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, + eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, + eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, + eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, + ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, + ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, + eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, + ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, + eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, + eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, + eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, + eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, + eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, + eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, + eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, + eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, + eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, + eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, + eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, + eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, + eValidationCacheExt = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT + }; + + struct DebugMarkerObjectNameInfoEXT + { + DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, + uint64_t object_ = 0, + const char* pObjectName_ = nullptr ) + : objectType( objectType_ ) + , object( object_ ) + , pObjectName( pObjectName_ ) + { + } + + DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); + } + + DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); + return *this; + } + DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) + { + objectType = objectType_; + return *this; + } + + DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ ) + { + object = object_; + return *this; + } + + DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ ) + { + pObjectName = pObjectName_; + return *this; + } + + operator const VkDebugMarkerObjectNameInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectType == rhs.objectType ) + && ( object == rhs.object ) + && ( pObjectName == rhs.pObjectName ); + } + + bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; + + public: + const void* pNext = nullptr; + DebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; + }; + static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); + + struct DebugMarkerObjectTagInfoEXT + { + DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, + uint64_t object_ = 0, + uint64_t tagName_ = 0, + size_t tagSize_ = 0, + const void* pTag_ = nullptr ) + : objectType( objectType_ ) + , object( object_ ) + , tagName( tagName_ ) + , tagSize( tagSize_ ) + , pTag( pTag_ ) + { + } + + DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); + } + + DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); + return *this; + } + DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) + { + objectType = objectType_; + return *this; + } + + DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ ) + { + object = object_; + return *this; + } + + DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ ) + { + tagName = tagName_; + return *this; + } + + DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ ) + { + tagSize = tagSize_; + return *this; + } + + DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ ) + { + pTag = pTag_; + return *this; + } + + operator const VkDebugMarkerObjectTagInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectType == rhs.objectType ) + && ( object == rhs.object ) + && ( tagName == rhs.tagName ) + && ( tagSize == rhs.tagSize ) + && ( pTag == rhs.pTag ); + } + + bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; + + public: + const void* pNext = nullptr; + DebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; + }; + static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); + + enum class RasterizationOrderAMD + { + eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, + eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD + }; + + struct PipelineRasterizationStateRasterizationOrderAMD + { + PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict ) + : rasterizationOrder( rasterizationOrder_ ) + { + } + + PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); + } + + PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); + return *this; + } + PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) + { + rasterizationOrder = rasterizationOrder_; + return *this; + } + + operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( rasterizationOrder == rhs.rasterizationOrder ); + } + + bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; + + public: + const void* pNext = nullptr; + RasterizationOrderAMD rasterizationOrder; + }; + static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); + + enum class ExternalMemoryHandleTypeFlagBitsNV + { + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, + eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, + eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV + }; + + using ExternalMemoryHandleTypeFlagsNV = Flags; + + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 ) + { + return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits ) + { + return ~( ExternalMemoryHandleTypeFlagsNV( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) + }; + }; + + struct ExternalMemoryImageCreateInfoNV + { + ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) + : handleTypes( handleTypes_ ) + { + } + + ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); + } + + ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); + return *this; + } + ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExternalMemoryImageCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlagsNV handleTypes; + }; + static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); + + struct ExportMemoryAllocateInfoNV + { + ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) + : handleTypes( handleTypes_ ) + { + } + + ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); + } + + ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); + return *this; + } + ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExportMemoryAllocateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportMemoryAllocateInfoNV; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlagsNV handleTypes; + }; + static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_WIN32_NV + struct ImportMemoryWin32HandleInfoNV + { + ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), + HANDLE handle_ = 0 ) + : handleType( handleType_ ) + , handle( handle_ ) + { + } + + ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); + } + + ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); + return *this; + } + ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ ) + { + handle = handle_; + return *this; + } + + operator const VkImportMemoryWin32HandleInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ); + } + + bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; + }; + static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_NV*/ + + enum class ExternalMemoryFeatureFlagBitsNV + { + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV + }; + + using ExternalMemoryFeatureFlagsNV = Flags; + + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 ) + { + return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits ) + { + return ~( ExternalMemoryFeatureFlagsNV( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable) + }; + }; + + struct ExternalImageFormatPropertiesNV + { + operator const VkExternalImageFormatPropertiesNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const + { + return ( imageFormatProperties == rhs.imageFormatProperties ) + && ( externalMemoryFeatures == rhs.externalMemoryFeatures ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + } + + bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const + { + return !operator==( rhs ); + } + + ImageFormatProperties imageFormatProperties; + ExternalMemoryFeatureFlagsNV externalMemoryFeatures; + ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; + }; + static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); + + enum class ValidationCheckEXT + { + eAll = VK_VALIDATION_CHECK_ALL_EXT, + eShaders = VK_VALIDATION_CHECK_SHADERS_EXT + }; + + struct ValidationFlagsEXT + { + ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, + ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) + : disabledValidationCheckCount( disabledValidationCheckCount_ ) + , pDisabledValidationChecks( pDisabledValidationChecks_ ) + { + } + + ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); + } + + ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); + return *this; + } + ValidationFlagsEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) + { + disabledValidationCheckCount = disabledValidationCheckCount_; + return *this; + } + + ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ ) + { + pDisabledValidationChecks = pDisabledValidationChecks_; + return *this; + } + + operator const VkValidationFlagsEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ValidationFlagsEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) + && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); + } + + bool operator!=( ValidationFlagsEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eValidationFlagsEXT; + + public: + const void* pNext = nullptr; + uint32_t disabledValidationCheckCount; + ValidationCheckEXT* pDisabledValidationChecks; + }; + static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); + + enum class SubgroupFeatureFlagBits + { + eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, + eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, + eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, + eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, + eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, + eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, + eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, + eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, + ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV + }; + + using SubgroupFeatureFlags = Flags; + + VULKAN_HPP_INLINE SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 ) + { + return SubgroupFeatureFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits ) + { + return ~( SubgroupFeatureFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) | VkFlags(SubgroupFeatureFlagBits::eVote) | VkFlags(SubgroupFeatureFlagBits::eArithmetic) | VkFlags(SubgroupFeatureFlagBits::eBallot) | VkFlags(SubgroupFeatureFlagBits::eShuffle) | VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) | VkFlags(SubgroupFeatureFlagBits::eClustered) | VkFlags(SubgroupFeatureFlagBits::eQuad) | VkFlags(SubgroupFeatureFlagBits::ePartitionedNV) + }; + }; + + struct PhysicalDeviceSubgroupProperties + { + operator const VkPhysicalDeviceSubgroupProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSubgroupProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( subgroupSize == rhs.subgroupSize ) + && ( supportedStages == rhs.supportedStages ) + && ( supportedOperations == rhs.supportedOperations ) + && ( quadOperationsInAllStages == rhs.quadOperationsInAllStages ); + } + + bool operator!=( PhysicalDeviceSubgroupProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; + + public: + void* pNext = nullptr; + uint32_t subgroupSize; + ShaderStageFlags supportedStages; + SubgroupFeatureFlags supportedOperations; + Bool32 quadOperationsInAllStages; + }; + static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" ); + + enum class IndirectCommandsLayoutUsageFlagBitsNVX + { + eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX, + eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX, + eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX, + eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX + }; + + using IndirectCommandsLayoutUsageFlagsNVX = Flags; + + VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 ) + { + return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits ) + { + return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) + }; + }; + + enum class ObjectEntryUsageFlagBitsNVX + { + eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, + eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX + }; + + using ObjectEntryUsageFlagsNVX = Flags; + + VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 ) + { + return ObjectEntryUsageFlagsNVX( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits ) + { + return ~( ObjectEntryUsageFlagsNVX( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute) + }; + }; + + enum class IndirectCommandsTokenTypeNVX + { + ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, + eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, + eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, + ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, + eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, + eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, + eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX + }; + + struct IndirectCommandsTokenNVX + { + IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, + Buffer buffer_ = Buffer(), + DeviceSize offset_ = 0 ) + : tokenType( tokenType_ ) + , buffer( buffer_ ) + , offset( offset_ ) + { + } + + IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); + } + + IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); + return *this; + } + IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) + { + tokenType = tokenType_; + return *this; + } + + IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ ) + { + offset = offset_; + return *this; + } + + operator const VkIndirectCommandsTokenNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( IndirectCommandsTokenNVX const& rhs ) const + { + return ( tokenType == rhs.tokenType ) + && ( buffer == rhs.buffer ) + && ( offset == rhs.offset ); + } + + bool operator!=( IndirectCommandsTokenNVX const& rhs ) const + { + return !operator==( rhs ); + } + + IndirectCommandsTokenTypeNVX tokenType; + Buffer buffer; + DeviceSize offset; + }; + static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" ); + + struct IndirectCommandsLayoutTokenNVX + { + IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, + uint32_t bindingUnit_ = 0, + uint32_t dynamicCount_ = 0, + uint32_t divisor_ = 0 ) + : tokenType( tokenType_ ) + , bindingUnit( bindingUnit_ ) + , dynamicCount( dynamicCount_ ) + , divisor( divisor_ ) + { + } + + IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); + } + + IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); + return *this; + } + IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) + { + tokenType = tokenType_; + return *this; + } + + IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ ) + { + bindingUnit = bindingUnit_; + return *this; + } + + IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ ) + { + dynamicCount = dynamicCount_; + return *this; + } + + IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ ) + { + divisor = divisor_; + return *this; + } + + operator const VkIndirectCommandsLayoutTokenNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const + { + return ( tokenType == rhs.tokenType ) + && ( bindingUnit == rhs.bindingUnit ) + && ( dynamicCount == rhs.dynamicCount ) + && ( divisor == rhs.divisor ); + } + + bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const + { + return !operator==( rhs ); + } + + IndirectCommandsTokenTypeNVX tokenType; + uint32_t bindingUnit; + uint32_t dynamicCount; + uint32_t divisor; + }; + static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" ); + + struct IndirectCommandsLayoutCreateInfoNVX + { + IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), + uint32_t tokenCount_ = 0, + const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) + : pipelineBindPoint( pipelineBindPoint_ ) + , flags( flags_ ) + , tokenCount( tokenCount_ ) + , pTokens( pTokens_ ) + { + } + + IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); + } + + IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); + return *this; + } + IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ ) + { + tokenCount = tokenCount_; + return *this; + } + + IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ ) + { + pTokens = pTokens_; + return *this; + } + + operator const VkIndirectCommandsLayoutCreateInfoNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pipelineBindPoint == rhs.pipelineBindPoint ) + && ( flags == rhs.flags ) + && ( tokenCount == rhs.tokenCount ) + && ( pTokens == rhs.pTokens ); + } + + bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; + + public: + const void* pNext = nullptr; + PipelineBindPoint pipelineBindPoint; + IndirectCommandsLayoutUsageFlagsNVX flags; + uint32_t tokenCount; + const IndirectCommandsLayoutTokenNVX* pTokens; + }; + static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); + + enum class ObjectEntryTypeNVX + { + eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, + eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, + eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, + ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX + }; + + struct ObjectTableCreateInfoNVX + { + ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, + const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, + const uint32_t* pObjectEntryCounts_ = nullptr, + const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, + uint32_t maxUniformBuffersPerDescriptor_ = 0, + uint32_t maxStorageBuffersPerDescriptor_ = 0, + uint32_t maxStorageImagesPerDescriptor_ = 0, + uint32_t maxSampledImagesPerDescriptor_ = 0, + uint32_t maxPipelineLayouts_ = 0 ) + : objectCount( objectCount_ ) + , pObjectEntryTypes( pObjectEntryTypes_ ) + , pObjectEntryCounts( pObjectEntryCounts_ ) + , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) + , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) + , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) + , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) + , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) + , maxPipelineLayouts( maxPipelineLayouts_ ) + { + } + + ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); + } + + ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); + return *this; + } + ObjectTableCreateInfoNVX& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ ) + { + objectCount = objectCount_; + return *this; + } + + ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ ) + { + pObjectEntryTypes = pObjectEntryTypes_; + return *this; + } + + ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ ) + { + pObjectEntryCounts = pObjectEntryCounts_; + return *this; + } + + ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ ) + { + pObjectEntryUsageFlags = pObjectEntryUsageFlags_; + return *this; + } + + ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ ) + { + maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_; + return *this; + } + + ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ ) + { + maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_; + return *this; + } + + ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ ) + { + maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_; + return *this; + } + + ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ ) + { + maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_; + return *this; + } + + ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ ) + { + maxPipelineLayouts = maxPipelineLayouts_; + return *this; + } + + operator const VkObjectTableCreateInfoNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ObjectTableCreateInfoNVX const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectCount == rhs.objectCount ) + && ( pObjectEntryTypes == rhs.pObjectEntryTypes ) + && ( pObjectEntryCounts == rhs.pObjectEntryCounts ) + && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags ) + && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor ) + && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor ) + && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor ) + && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor ) + && ( maxPipelineLayouts == rhs.maxPipelineLayouts ); + } + + bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eObjectTableCreateInfoNVX; + + public: + const void* pNext = nullptr; + uint32_t objectCount; + const ObjectEntryTypeNVX* pObjectEntryTypes; + const uint32_t* pObjectEntryCounts; + const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; + uint32_t maxUniformBuffersPerDescriptor; + uint32_t maxStorageBuffersPerDescriptor; + uint32_t maxStorageImagesPerDescriptor; + uint32_t maxSampledImagesPerDescriptor; + uint32_t maxPipelineLayouts; + }; + static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" ); + + struct ObjectTableEntryNVX + { + ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, + ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() ) + : type( type_ ) + , flags( flags_ ) + { + } + + ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); + } + + ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); + return *this; + } + ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } + + ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkObjectTableEntryNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ObjectTableEntryNVX const& rhs ) const + { + return ( type == rhs.type ) + && ( flags == rhs.flags ); + } + + bool operator!=( ObjectTableEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } + + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + }; + static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" ); + + struct ObjectTablePipelineEntryNVX + { + ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, + ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), + Pipeline pipeline_ = Pipeline() ) + : type( type_ ) + , flags( flags_ ) + , pipeline( pipeline_ ) + { + } + + explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, + Pipeline pipeline_ = Pipeline() ) + : type( objectTableEntryNVX.type ) + , flags( objectTableEntryNVX.flags ) + , pipeline( pipeline_ ) + {} + + ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); + } + + ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); + return *this; + } + ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } + + ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ ) + { + pipeline = pipeline_; + return *this; + } + + operator const VkObjectTablePipelineEntryNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const + { + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( pipeline == rhs.pipeline ); + } + + bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } + + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + Pipeline pipeline; + }; + static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" ); + + struct ObjectTableDescriptorSetEntryNVX + { + ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, + ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), + PipelineLayout pipelineLayout_ = PipelineLayout(), + DescriptorSet descriptorSet_ = DescriptorSet() ) + : type( type_ ) + , flags( flags_ ) + , pipelineLayout( pipelineLayout_ ) + , descriptorSet( descriptorSet_ ) + { + } + + explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, + PipelineLayout pipelineLayout_ = PipelineLayout(), + DescriptorSet descriptorSet_ = DescriptorSet() ) + : type( objectTableEntryNVX.type ) + , flags( objectTableEntryNVX.flags ) + , pipelineLayout( pipelineLayout_ ) + , descriptorSet( descriptorSet_ ) + {} + + ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); + } + + ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); + return *this; + } + ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } + + ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) + { + pipelineLayout = pipelineLayout_; + return *this; + } + + ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ ) + { + descriptorSet = descriptorSet_; + return *this; + } + + operator const VkObjectTableDescriptorSetEntryNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const + { + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( pipelineLayout == rhs.pipelineLayout ) + && ( descriptorSet == rhs.descriptorSet ); + } + + bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } + + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + PipelineLayout pipelineLayout; + DescriptorSet descriptorSet; + }; + static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" ); + + struct ObjectTableVertexBufferEntryNVX + { + ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, + ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), + Buffer buffer_ = Buffer() ) + : type( type_ ) + , flags( flags_ ) + , buffer( buffer_ ) + { + } + + explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, + Buffer buffer_ = Buffer() ) + : type( objectTableEntryNVX.type ) + , flags( objectTableEntryNVX.flags ) + , buffer( buffer_ ) + {} + + ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); + } + + ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); + return *this; + } + ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } + + ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator const VkObjectTableVertexBufferEntryNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const + { + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } + + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + Buffer buffer; + }; + static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" ); + + struct ObjectTableIndexBufferEntryNVX + { + ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, + ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), + Buffer buffer_ = Buffer(), + IndexType indexType_ = IndexType::eUint16 ) + : type( type_ ) + , flags( flags_ ) + , buffer( buffer_ ) + , indexType( indexType_ ) + { + } + + explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, + Buffer buffer_ = Buffer(), + IndexType indexType_ = IndexType::eUint16 ) + : type( objectTableEntryNVX.type ) + , flags( objectTableEntryNVX.flags ) + , buffer( buffer_ ) + , indexType( indexType_ ) + {} + + ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); + } + + ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); + return *this; + } + ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } + + ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ ) + { + indexType = indexType_; + return *this; + } + + operator const VkObjectTableIndexBufferEntryNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const + { + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( buffer == rhs.buffer ) + && ( indexType == rhs.indexType ); + } + + bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } + + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + Buffer buffer; + IndexType indexType; + }; + static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" ); + + struct ObjectTablePushConstantEntryNVX + { + ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, + ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), + PipelineLayout pipelineLayout_ = PipelineLayout(), + ShaderStageFlags stageFlags_ = ShaderStageFlags() ) + : type( type_ ) + , flags( flags_ ) + , pipelineLayout( pipelineLayout_ ) + , stageFlags( stageFlags_ ) + { + } + + explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, + PipelineLayout pipelineLayout_ = PipelineLayout(), + ShaderStageFlags stageFlags_ = ShaderStageFlags() ) + : type( objectTableEntryNVX.type ) + , flags( objectTableEntryNVX.flags ) + , pipelineLayout( pipelineLayout_ ) + , stageFlags( stageFlags_ ) + {} + + ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); + } + + ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); + return *this; + } + ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } + + ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) + { + pipelineLayout = pipelineLayout_; + return *this; + } + + ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ ) + { + stageFlags = stageFlags_; + return *this; + } + + operator const VkObjectTablePushConstantEntryNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const + { + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( pipelineLayout == rhs.pipelineLayout ) + && ( stageFlags == rhs.stageFlags ); + } + + bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } + + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + PipelineLayout pipelineLayout; + ShaderStageFlags stageFlags; + }; + static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" ); + + enum class DescriptorSetLayoutCreateFlagBits + { + ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, + eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT + }; + + using DescriptorSetLayoutCreateFlags = Flags; + + VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 ) + { + return DescriptorSetLayoutCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits ) + { + return ~( DescriptorSetLayoutCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT) + }; + }; + + struct DescriptorSetLayoutCreateInfo + { + DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), + uint32_t bindingCount_ = 0, + const DescriptorSetLayoutBinding* pBindings_ = nullptr ) + : flags( flags_ ) + , bindingCount( bindingCount_ ) + , pBindings( pBindings_ ) + { + } + + DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); + } + + DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); + return *this; + } + DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ ) + { + bindingCount = bindingCount_; + return *this; + } + + DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ ) + { + pBindings = pBindings_; + return *this; + } + + operator const VkDescriptorSetLayoutCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( bindingCount == rhs.bindingCount ) + && ( pBindings == rhs.pBindings ); + } + + bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; + + public: + const void* pNext = nullptr; + DescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const DescriptorSetLayoutBinding* pBindings; + }; + static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); + + enum class ExternalMemoryHandleTypeFlagBits + { + eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueFdKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eOpaqueWin32KmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + eD3D11TextureKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + eD3D11TextureKmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + eD3D12HeapKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + eD3D12ResourceKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, + eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, + eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, + eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT + }; + + using ExternalMemoryHandleTypeFlags = Flags; + + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 ) + { + return ExternalMemoryHandleTypeFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits ) + { + return ~( ExternalMemoryHandleTypeFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT) + }; + }; + + using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; + + struct PhysicalDeviceExternalImageFormatInfo + { + PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) + : handleType( handleType_ ) + { + } + + PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) ); + } + + PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) ); + return *this; + } + PhysicalDeviceExternalImageFormatInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExternalImageFormatInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkPhysicalDeviceExternalImageFormatInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceExternalImageFormatInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( PhysicalDeviceExternalImageFormatInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlagBits handleType; + }; + static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" ); + + using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; + + struct PhysicalDeviceExternalBufferInfo + { + PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(), + BufferUsageFlags usage_ = BufferUsageFlags(), + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) + : flags( flags_ ) + , usage( usage_ ) + , handleType( handleType_ ) + { + } + + PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) ); + } + + PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) ); + return *this; + } + PhysicalDeviceExternalBufferInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExternalBufferInfo& setFlags( BufferCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PhysicalDeviceExternalBufferInfo& setUsage( BufferUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + PhysicalDeviceExternalBufferInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkPhysicalDeviceExternalBufferInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceExternalBufferInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( usage == rhs.usage ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( PhysicalDeviceExternalBufferInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; + + public: + const void* pNext = nullptr; + BufferCreateFlags flags; + BufferUsageFlags usage; + ExternalMemoryHandleTypeFlagBits handleType; + }; + static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" ); + + using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; + + struct ExternalMemoryImageCreateInfo + { + ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() ) + : handleTypes( handleTypes_ ) + { + } + + ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) ); + } + + ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) ); + return *this; + } + ExternalMemoryImageCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExternalMemoryImageCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExternalMemoryImageCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalMemoryImageCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExternalMemoryImageCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalMemoryImageCreateInfo; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlags handleTypes; + }; + static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" ); + + using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; + + struct ExternalMemoryBufferCreateInfo + { + ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() ) + : handleTypes( handleTypes_ ) + { + } + + ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) ); + } + + ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) ); + return *this; + } + ExternalMemoryBufferCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExternalMemoryBufferCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExternalMemoryBufferCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalMemoryBufferCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExternalMemoryBufferCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlags handleTypes; + }; + static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" ); + + using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; + + struct ExportMemoryAllocateInfo + { + ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() ) + : handleTypes( handleTypes_ ) + { + } + + ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) ); + } + + ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) ); + return *this; + } + ExportMemoryAllocateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportMemoryAllocateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExportMemoryAllocateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportMemoryAllocateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExportMemoryAllocateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportMemoryAllocateInfo; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlags handleTypes; + }; + static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" ); + + using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportMemoryWin32HandleInfoKHR + { + ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = 0, + LPCWSTR name_ = 0 ) + : handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) + { + } + + ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); + } + + ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); + return *this; + } + ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ ) + { + handle = handle_; + return *this; + } + + ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkImportMemoryWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ) + && ( name == rhs.name ); + } + + bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; + }; + static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryGetWin32HandleInfoKHR + { + MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) + : memory( memory_ ) + , handleType( handleType_ ) + { + } + + MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); + } + + MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); + return *this; + } + MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkMemoryGetWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + DeviceMemory memory; + ExternalMemoryHandleTypeFlagBits handleType; + }; + static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct ImportMemoryFdInfoKHR + { + ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + int fd_ = 0 ) + : handleType( handleType_ ) + , fd( fd_ ) + { + } + + ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); + } + + ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); + return *this; + } + ImportMemoryFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportMemoryFdInfoKHR& setFd( int fd_ ) + { + fd = fd_; + return *this; + } + + operator const VkImportMemoryFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportMemoryFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ) + && ( fd == rhs.fd ); + } + + bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportMemoryFdInfoKHR; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlagBits handleType; + int fd; + }; + static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); + + struct MemoryGetFdInfoKHR + { + MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) + : memory( memory_ ) + , handleType( handleType_ ) + { + } + + MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); + } + + MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); + return *this; + } + MemoryGetFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkMemoryGetFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryGetFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( MemoryGetFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryGetFdInfoKHR; + + public: + const void* pNext = nullptr; + DeviceMemory memory; + ExternalMemoryHandleTypeFlagBits handleType; + }; + static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); + + struct ImportMemoryHostPointerInfoEXT + { + ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + void* pHostPointer_ = nullptr ) + : handleType( handleType_ ) + , pHostPointer( pHostPointer_ ) + { + } + + ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) ); + } + + ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) ); + return *this; + } + ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ ) + { + pHostPointer = pHostPointer_; + return *this; + } + + operator const VkImportMemoryHostPointerInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ) + && ( pHostPointer == rhs.pHostPointer ); + } + + bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; + + public: + const void* pNext = nullptr; + ExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; + }; + static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" ); + + enum class ExternalMemoryFeatureFlagBits + { + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + eDedicatedOnlyKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + eExportableKHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + eImportableKHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT + }; + + using ExternalMemoryFeatureFlags = Flags; + + VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 ) + { + return ExternalMemoryFeatureFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits ) + { + return ~( ExternalMemoryFeatureFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBits::eExportable) | VkFlags(ExternalMemoryFeatureFlagBits::eImportable) + }; + }; + + using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; + + struct ExternalMemoryProperties + { + operator const VkExternalMemoryProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalMemoryProperties const& rhs ) const + { + return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + } + + bool operator!=( ExternalMemoryProperties const& rhs ) const + { + return !operator==( rhs ); + } + + ExternalMemoryFeatureFlags externalMemoryFeatures; + ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + ExternalMemoryHandleTypeFlags compatibleHandleTypes; + }; + static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" ); + + using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; + + struct ExternalImageFormatProperties + { + operator const VkExternalImageFormatProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalImageFormatProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( externalMemoryProperties == rhs.externalMemoryProperties ); + } + + bool operator!=( ExternalImageFormatProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalImageFormatProperties; + + public: + void* pNext = nullptr; + ExternalMemoryProperties externalMemoryProperties; + }; + static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" ); + + using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; + + struct ExternalBufferProperties + { + operator const VkExternalBufferProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalBufferProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( externalMemoryProperties == rhs.externalMemoryProperties ); + } + + bool operator!=( ExternalBufferProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalBufferProperties; + + public: + void* pNext = nullptr; + ExternalMemoryProperties externalMemoryProperties; + }; + static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" ); + + using ExternalBufferPropertiesKHR = ExternalBufferProperties; + + enum class ExternalSemaphoreHandleTypeFlagBits + { + eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eOpaqueWin32KmtKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + eD3D12FenceKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + eSyncFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT + }; + + using ExternalSemaphoreHandleTypeFlags = Flags; + + VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 ) + { + return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits ) + { + return ~( ExternalSemaphoreHandleTypeFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd) + }; + }; + + using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; + + struct PhysicalDeviceExternalSemaphoreInfo + { + PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) + : handleType( handleType_ ) + { + } + + PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) ); + } + + PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) ); + return *this; + } + PhysicalDeviceExternalSemaphoreInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExternalSemaphoreInfo& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkPhysicalDeviceExternalSemaphoreInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; + + public: + const void* pNext = nullptr; + ExternalSemaphoreHandleTypeFlagBits handleType; + }; + static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" ); + + using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; + + struct ExportSemaphoreCreateInfo + { + ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() ) + : handleTypes( handleTypes_ ) + { + } + + ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) ); + } + + ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) ); + return *this; + } + ExportSemaphoreCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportSemaphoreCreateInfo& setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExportSemaphoreCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportSemaphoreCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExportSemaphoreCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportSemaphoreCreateInfo; + + public: + const void* pNext = nullptr; + ExternalSemaphoreHandleTypeFlags handleTypes; + }; + static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" ); + + using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SemaphoreGetWin32HandleInfoKHR + { + SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) + : semaphore( semaphore_ ) + , handleType( handleType_ ) + { + } + + SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); + } + + SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); + return *this; + } + SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkSemaphoreGetWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + Semaphore semaphore; + ExternalSemaphoreHandleTypeFlagBits handleType; + }; + static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct SemaphoreGetFdInfoKHR + { + SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) + : semaphore( semaphore_ ) + , handleType( handleType_ ) + { + } + + SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); + } + + SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); + return *this; + } + SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkSemaphoreGetFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; + + public: + const void* pNext = nullptr; + Semaphore semaphore; + ExternalSemaphoreHandleTypeFlagBits handleType; + }; + static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class ExternalSemaphoreFeatureFlagBits + { + eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + eExportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + eImportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT + }; + + using ExternalSemaphoreFeatureFlags = Flags; + + VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 ) + { + return ExternalSemaphoreFeatureFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits ) + { + return ~( ExternalSemaphoreFeatureFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable) + }; + }; + + using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; + + struct ExternalSemaphoreProperties + { + operator const VkExternalSemaphoreProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalSemaphoreProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) + && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); + } + + bool operator!=( ExternalSemaphoreProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalSemaphoreProperties; + + public: + void* pNext = nullptr; + ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + ExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + ExternalSemaphoreFeatureFlags externalSemaphoreFeatures; + }; + static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" ); + + using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; + + enum class SemaphoreImportFlagBits + { + eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + eTemporaryKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT + }; + + using SemaphoreImportFlags = Flags; + + VULKAN_HPP_INLINE SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 ) + { + return SemaphoreImportFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits ) + { + return ~( SemaphoreImportFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary) + }; + }; + + using SemaphoreImportFlagsKHR = SemaphoreImportFlags; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportSemaphoreWin32HandleInfoKHR + { + ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), + SemaphoreImportFlags flags_ = SemaphoreImportFlags(), + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = 0, + LPCWSTR name_ = 0 ) + : semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) + { + } + + ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); + } + + ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); + return *this; + } + ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlags flags_ ) + { + flags = flags_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ ) + { + handle = handle_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkImportSemaphoreWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ) + && ( name == rhs.name ); + } + + bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + Semaphore semaphore; + SemaphoreImportFlags flags; + ExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; + }; + static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct ImportSemaphoreFdInfoKHR + { + ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), + SemaphoreImportFlags flags_ = SemaphoreImportFlags(), + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + int fd_ = 0 ) + : semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) + { + } + + ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); + } + + ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); + return *this; + } + ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlags flags_ ) + { + flags = flags_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setFd( int fd_ ) + { + fd = fd_; + return *this; + } + + operator const VkImportSemaphoreFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( fd == rhs.fd ); + } + + bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; + + public: + const void* pNext = nullptr; + Semaphore semaphore; + SemaphoreImportFlags flags; + ExternalSemaphoreHandleTypeFlagBits handleType; + int fd; + }; + static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class ExternalFenceHandleTypeFlagBits + { + eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eOpaqueWin32KmtKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + eSyncFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT + }; + + using ExternalFenceHandleTypeFlags = Flags; + + VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 ) + { + return ExternalFenceHandleTypeFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits ) + { + return ~( ExternalFenceHandleTypeFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd) + }; + }; + + using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; + + struct PhysicalDeviceExternalFenceInfo + { + PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd ) + : handleType( handleType_ ) + { + } + + PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) ); + } + + PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) ); + return *this; + } + PhysicalDeviceExternalFenceInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExternalFenceInfo& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkPhysicalDeviceExternalFenceInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceExternalFenceInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( PhysicalDeviceExternalFenceInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; + + public: + const void* pNext = nullptr; + ExternalFenceHandleTypeFlagBits handleType; + }; + static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" ); + + using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; + + struct ExportFenceCreateInfo + { + ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() ) + : handleTypes( handleTypes_ ) + { + } + + ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) ); + } + + ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) ); + return *this; + } + ExportFenceCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportFenceCreateInfo& setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExportFenceCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportFenceCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExportFenceCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExportFenceCreateInfo; + + public: + const void* pNext = nullptr; + ExternalFenceHandleTypeFlags handleTypes; + }; + static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" ); + + using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct FenceGetWin32HandleInfoKHR + { + FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd ) + : fence( fence_ ) + , handleType( handleType_ ) + { + } + + FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); + } + + FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); + return *this; + } + FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + FenceGetWin32HandleInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkFenceGetWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + Fence fence; + ExternalFenceHandleTypeFlagBits handleType; + }; + static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct FenceGetFdInfoKHR + { + FenceGetFdInfoKHR( Fence fence_ = Fence(), + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd ) + : fence( fence_ ) + , handleType( handleType_ ) + { + } + + FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); + } + + FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); + return *this; + } + FenceGetFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + FenceGetFdInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkFenceGetFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FenceGetFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( FenceGetFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eFenceGetFdInfoKHR; + + public: + const void* pNext = nullptr; + Fence fence; + ExternalFenceHandleTypeFlagBits handleType; + }; + static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class ExternalFenceFeatureFlagBits + { + eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + eExportableKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + eImportableKHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT + }; + + using ExternalFenceFeatureFlags = Flags; + + VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 ) + { + return ExternalFenceFeatureFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits ) + { + return ~( ExternalFenceFeatureFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) | VkFlags(ExternalFenceFeatureFlagBits::eImportable) + }; + }; + + using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; + + struct ExternalFenceProperties + { + operator const VkExternalFenceProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalFenceProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) + && ( externalFenceFeatures == rhs.externalFenceFeatures ); + } + + bool operator!=( ExternalFenceProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eExternalFenceProperties; + + public: + void* pNext = nullptr; + ExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + ExternalFenceHandleTypeFlags compatibleHandleTypes; + ExternalFenceFeatureFlags externalFenceFeatures; + }; + static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" ); + + using ExternalFencePropertiesKHR = ExternalFenceProperties; + + enum class FenceImportFlagBits + { + eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT, + eTemporaryKHR = VK_FENCE_IMPORT_TEMPORARY_BIT + }; + + using FenceImportFlags = Flags; + + VULKAN_HPP_INLINE FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 ) + { + return FenceImportFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE FenceImportFlags operator~( FenceImportFlagBits bits ) + { + return ~( FenceImportFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(FenceImportFlagBits::eTemporary) + }; + }; + + using FenceImportFlagsKHR = FenceImportFlags; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportFenceWin32HandleInfoKHR + { + ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), + FenceImportFlags flags_ = FenceImportFlags(), + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = 0, + LPCWSTR name_ = 0 ) + : fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) + { + } + + ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); + } + + ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); + return *this; + } + ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlags flags_ ) + { + flags = flags_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ ) + { + handle = handle_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkImportFenceWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ) + && ( name == rhs.name ); + } + + bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; + + public: + const void* pNext = nullptr; + Fence fence; + FenceImportFlags flags; + ExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; + }; + static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct ImportFenceFdInfoKHR + { + ImportFenceFdInfoKHR( Fence fence_ = Fence(), + FenceImportFlags flags_ = FenceImportFlags(), + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + int fd_ = 0 ) + : fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) + { + } + + ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); + } + + ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); + return *this; + } + ImportFenceFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportFenceFdInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + ImportFenceFdInfoKHR& setFlags( FenceImportFlags flags_ ) + { + flags = flags_; + return *this; + } + + ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportFenceFdInfoKHR& setFd( int fd_ ) + { + fd = fd_; + return *this; + } + + operator const VkImportFenceFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportFenceFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( fd == rhs.fd ); + } + + bool operator!=( ImportFenceFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImportFenceFdInfoKHR; + + public: + const void* pNext = nullptr; + Fence fence; + FenceImportFlags flags; + ExternalFenceHandleTypeFlagBits handleType; + int fd; + }; + static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class SurfaceCounterFlagBitsEXT + { + eVblank = VK_SURFACE_COUNTER_VBLANK_EXT + }; + + using SurfaceCounterFlagsEXT = Flags; + + VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 ) + { + return SurfaceCounterFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits ) + { + return ~( SurfaceCounterFlagsEXT( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank) + }; + }; + + struct SurfaceCapabilities2EXT + { + operator const VkSurfaceCapabilities2EXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SurfaceCapabilities2EXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( minImageCount == rhs.minImageCount ) + && ( maxImageCount == rhs.maxImageCount ) + && ( currentExtent == rhs.currentExtent ) + && ( minImageExtent == rhs.minImageExtent ) + && ( maxImageExtent == rhs.maxImageExtent ) + && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) + && ( supportedTransforms == rhs.supportedTransforms ) + && ( currentTransform == rhs.currentTransform ) + && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) + && ( supportedUsageFlags == rhs.supportedUsageFlags ) + && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters ); + } + + bool operator!=( SurfaceCapabilities2EXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceCapabilities2EXT; + + public: + void* pNext = nullptr; + uint32_t minImageCount; + uint32_t maxImageCount; + Extent2D currentExtent; + Extent2D minImageExtent; + Extent2D maxImageExtent; + uint32_t maxImageArrayLayers; + SurfaceTransformFlagsKHR supportedTransforms; + SurfaceTransformFlagBitsKHR currentTransform; + CompositeAlphaFlagsKHR supportedCompositeAlpha; + ImageUsageFlags supportedUsageFlags; + SurfaceCounterFlagsEXT supportedSurfaceCounters; + }; + static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" ); + + struct SwapchainCounterCreateInfoEXT + { + SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() ) + : surfaceCounters( surfaceCounters_ ) + { + } + + SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); + } + + SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); + return *this; + } + SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ ) + { + surfaceCounters = surfaceCounters_; + return *this; + } + + operator const VkSwapchainCounterCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surfaceCounters == rhs.surfaceCounters ); + } + + bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; + + public: + const void* pNext = nullptr; + SurfaceCounterFlagsEXT surfaceCounters; + }; + static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class DisplayPowerStateEXT + { + eOff = VK_DISPLAY_POWER_STATE_OFF_EXT, + eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT, + eOn = VK_DISPLAY_POWER_STATE_ON_EXT + }; + + struct DisplayPowerInfoEXT + { + DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff ) + : powerState( powerState_ ) + { + } + + DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); + } + + DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); + return *this; + } + DisplayPowerInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ ) + { + powerState = powerState_; + return *this; + } + + operator const VkDisplayPowerInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayPowerInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( powerState == rhs.powerState ); + } + + bool operator!=( DisplayPowerInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayPowerInfoEXT; + + public: + const void* pNext = nullptr; + DisplayPowerStateEXT powerState; + }; + static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); + + enum class DeviceEventTypeEXT + { + eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + }; + + struct DeviceEventInfoEXT + { + DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug ) + : deviceEvent( deviceEvent_ ) + { + } + + DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); + } + + DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); + return *this; + } + DeviceEventInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ ) + { + deviceEvent = deviceEvent_; + return *this; + } + + operator const VkDeviceEventInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceEventInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( deviceEvent == rhs.deviceEvent ); + } + + bool operator!=( DeviceEventInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceEventInfoEXT; + + public: + const void* pNext = nullptr; + DeviceEventTypeEXT deviceEvent; + }; + static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); + + enum class DisplayEventTypeEXT + { + eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + }; + + struct DisplayEventInfoEXT + { + DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut ) + : displayEvent( displayEvent_ ) + { + } + + DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); + } + + DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); + return *this; + } + DisplayEventInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ ) + { + displayEvent = displayEvent_; + return *this; + } + + operator const VkDisplayEventInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DisplayEventInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( displayEvent == rhs.displayEvent ); + } + + bool operator!=( DisplayEventInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayEventInfoEXT; + + public: + const void* pNext = nullptr; + DisplayEventTypeEXT displayEvent; + }; + static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); + + enum class PeerMemoryFeatureFlagBits + { + eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + eCopySrcKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + eCopyDstKHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + eGenericSrcKHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + eGenericDstKHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT + }; + + using PeerMemoryFeatureFlags = Flags; + + VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 ) + { + return PeerMemoryFeatureFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits ) + { + return ~( PeerMemoryFeatureFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBits::eGenericDst) + }; + }; + + using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; + + enum class MemoryAllocateFlagBits + { + eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + eDeviceMaskKHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT + }; + + using MemoryAllocateFlags = Flags; + + VULKAN_HPP_INLINE MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 ) + { + return MemoryAllocateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits ) + { + return ~( MemoryAllocateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask) + }; + }; + + using MemoryAllocateFlagsKHR = MemoryAllocateFlags; + + struct MemoryAllocateFlagsInfo + { + MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(), + uint32_t deviceMask_ = 0 ) + : flags( flags_ ) + , deviceMask( deviceMask_ ) + { + } + + MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) ); + } + + MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) ); + return *this; + } + MemoryAllocateFlagsInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryAllocateFlagsInfo& setFlags( MemoryAllocateFlags flags_ ) + { + flags = flags_; + return *this; + } + + MemoryAllocateFlagsInfo& setDeviceMask( uint32_t deviceMask_ ) + { + deviceMask = deviceMask_; + return *this; + } + + operator const VkMemoryAllocateFlagsInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryAllocateFlagsInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( deviceMask == rhs.deviceMask ); + } + + bool operator!=( MemoryAllocateFlagsInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryAllocateFlagsInfo; + + public: + const void* pNext = nullptr; + MemoryAllocateFlags flags; + uint32_t deviceMask; + }; + static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" ); + + using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; + + enum class DeviceGroupPresentModeFlagBitsKHR + { + eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, + eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, + eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, + eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR + }; + + using DeviceGroupPresentModeFlagsKHR = Flags; + + VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 ) + { + return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits ) + { + return ~( DeviceGroupPresentModeFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice) + }; + }; + + struct DeviceGroupPresentCapabilitiesKHR + { + operator const VkDeviceGroupPresentCapabilitiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupPresentCapabilitiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 ) + && ( modes == rhs.modes ); + } + + bool operator!=( DeviceGroupPresentCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; + + public: + const void* pNext = nullptr; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + DeviceGroupPresentModeFlagsKHR modes; + }; + static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" ); + + struct DeviceGroupPresentInfoKHR + { + DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0, + const uint32_t* pDeviceMasks_ = nullptr, + DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal ) + : swapchainCount( swapchainCount_ ) + , pDeviceMasks( pDeviceMasks_ ) + , mode( mode_ ) + { + } + + DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) ); + } + + DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) ); + return *this; + } + DeviceGroupPresentInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGroupPresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ ) + { + swapchainCount = swapchainCount_; + return *this; + } + + DeviceGroupPresentInfoKHR& setPDeviceMasks( const uint32_t* pDeviceMasks_ ) + { + pDeviceMasks = pDeviceMasks_; + return *this; + } + + DeviceGroupPresentInfoKHR& setMode( DeviceGroupPresentModeFlagBitsKHR mode_ ) + { + mode = mode_; + return *this; + } + + operator const VkDeviceGroupPresentInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( swapchainCount == rhs.swapchainCount ) + && ( pDeviceMasks == rhs.pDeviceMasks ) + && ( mode == rhs.mode ); + } + + bool operator!=( DeviceGroupPresentInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; + + public: + const void* pNext = nullptr; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + DeviceGroupPresentModeFlagBitsKHR mode; + }; + static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" ); + + struct DeviceGroupSwapchainCreateInfoKHR + { + DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() ) + : modes( modes_ ) + { + } + + DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) ); + } + + DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) ); + return *this; + } + DeviceGroupSwapchainCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGroupSwapchainCreateInfoKHR& setModes( DeviceGroupPresentModeFlagsKHR modes_ ) + { + modes = modes_; + return *this; + } + + operator const VkDeviceGroupSwapchainCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( modes == rhs.modes ); + } + + bool operator!=( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; + + public: + const void* pNext = nullptr; + DeviceGroupPresentModeFlagsKHR modes; + }; + static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); + + enum class SwapchainCreateFlagBitsKHR + { + eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, + eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR + }; + + using SwapchainCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 ) + { + return SwapchainCreateFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits ) + { + return ~( SwapchainCreateFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected) + }; + }; + + struct SwapchainCreateInfoKHR + { + SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(), + SurfaceKHR surface_ = SurfaceKHR(), + uint32_t minImageCount_ = 0, + Format imageFormat_ = Format::eUndefined, + ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, + Extent2D imageExtent_ = Extent2D(), + uint32_t imageArrayLayers_ = 0, + ImageUsageFlags imageUsage_ = ImageUsageFlags(), + SharingMode imageSharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = 0, + const uint32_t* pQueueFamilyIndices_ = nullptr, + SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, + CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, + PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, + Bool32 clipped_ = 0, + SwapchainKHR oldSwapchain_ = SwapchainKHR() ) + : flags( flags_ ) + , surface( surface_ ) + , minImageCount( minImageCount_ ) + , imageFormat( imageFormat_ ) + , imageColorSpace( imageColorSpace_ ) + , imageExtent( imageExtent_ ) + , imageArrayLayers( imageArrayLayers_ ) + , imageUsage( imageUsage_ ) + , imageSharingMode( imageSharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + , preTransform( preTransform_ ) + , compositeAlpha( compositeAlpha_ ) + , presentMode( presentMode_ ) + , clipped( clipped_ ) + , oldSwapchain( oldSwapchain_ ) + { + } + + SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); + } + + SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); + return *this; + } + SwapchainCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ ) + { + surface = surface_; + return *this; + } + + SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ ) + { + minImageCount = minImageCount_; + return *this; + } + + SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ ) + { + imageFormat = imageFormat_; + return *this; + } + + SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ ) + { + imageColorSpace = imageColorSpace_; + return *this; + } + + SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) + { + imageExtent = imageExtent_; + return *this; + } + + SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ ) + { + imageArrayLayers = imageArrayLayers_; + return *this; + } + + SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ ) + { + imageUsage = imageUsage_; + return *this; + } + + SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ ) + { + imageSharingMode = imageSharingMode_; + return *this; + } + + SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ ) + { + preTransform = preTransform_; + return *this; + } + + SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ ) + { + compositeAlpha = compositeAlpha_; + return *this; + } + + SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ ) + { + presentMode = presentMode_; + return *this; + } + + SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ ) + { + clipped = clipped_; + return *this; + } + + SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ ) + { + oldSwapchain = oldSwapchain_; + return *this; + } + + operator const VkSwapchainCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SwapchainCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( surface == rhs.surface ) + && ( minImageCount == rhs.minImageCount ) + && ( imageFormat == rhs.imageFormat ) + && ( imageColorSpace == rhs.imageColorSpace ) + && ( imageExtent == rhs.imageExtent ) + && ( imageArrayLayers == rhs.imageArrayLayers ) + && ( imageUsage == rhs.imageUsage ) + && ( imageSharingMode == rhs.imageSharingMode ) + && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) + && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) + && ( preTransform == rhs.preTransform ) + && ( compositeAlpha == rhs.compositeAlpha ) + && ( presentMode == rhs.presentMode ) + && ( clipped == rhs.clipped ) + && ( oldSwapchain == rhs.oldSwapchain ); + } + + bool operator!=( SwapchainCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSwapchainCreateInfoKHR; + + public: + const void* pNext = nullptr; + SwapchainCreateFlagsKHR flags; + SurfaceKHR surface; + uint32_t minImageCount; + Format imageFormat; + ColorSpaceKHR imageColorSpace; + Extent2D imageExtent; + uint32_t imageArrayLayers; + ImageUsageFlags imageUsage; + SharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + SurfaceTransformFlagBitsKHR preTransform; + CompositeAlphaFlagBitsKHR compositeAlpha; + PresentModeKHR presentMode; + Bool32 clipped; + SwapchainKHR oldSwapchain; + }; + static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); + + enum class ViewportCoordinateSwizzleNV + { + ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, + eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, + ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, + eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, + ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, + eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, + ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, + eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV + }; + + struct ViewportSwizzleNV + { + ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX, + ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX, + ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX, + ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX ) + : x( x_ ) + , y( y_ ) + , z( z_ ) + , w( w_ ) + { + } + + ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); + } + + ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); + return *this; + } + ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ ) + { + x = x_; + return *this; + } + + ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ ) + { + y = y_; + return *this; + } + + ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ ) + { + z = z_; + return *this; + } + + ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ ) + { + w = w_; + return *this; + } + + operator const VkViewportSwizzleNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ViewportSwizzleNV const& rhs ) const + { + return ( x == rhs.x ) + && ( y == rhs.y ) + && ( z == rhs.z ) + && ( w == rhs.w ); + } + + bool operator!=( ViewportSwizzleNV const& rhs ) const + { + return !operator==( rhs ); + } + + ViewportCoordinateSwizzleNV x; + ViewportCoordinateSwizzleNV y; + ViewportCoordinateSwizzleNV z; + ViewportCoordinateSwizzleNV w; + }; + static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); + + struct PipelineViewportSwizzleStateCreateInfoNV + { + PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), + uint32_t viewportCount_ = 0, + const ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) + : flags( flags_ ) + , viewportCount( viewportCount_ ) + , pViewportSwizzles( pViewportSwizzles_ ) + { + } + + PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); + } + + PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); + return *this; + } + PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ ) + { + viewportCount = viewportCount_; + return *this; + } + + PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ ) + { + pViewportSwizzles = pViewportSwizzles_; + return *this; + } + + operator const VkPipelineViewportSwizzleStateCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( viewportCount == rhs.viewportCount ) + && ( pViewportSwizzles == rhs.pViewportSwizzles ); + } + + bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; + + public: + const void* pNext = nullptr; + PipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const ViewportSwizzleNV* pViewportSwizzles; + }; + static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" ); + + enum class DiscardRectangleModeEXT + { + eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT + }; + + struct PipelineDiscardRectangleStateCreateInfoEXT + { + PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), + DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, + uint32_t discardRectangleCount_ = 0, + const Rect2D* pDiscardRectangles_ = nullptr ) + : flags( flags_ ) + , discardRectangleMode( discardRectangleMode_ ) + , discardRectangleCount( discardRectangleCount_ ) + , pDiscardRectangles( pDiscardRectangles_ ) + { + } + + PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); + } + + PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); + return *this; + } + PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ ) + { + discardRectangleMode = discardRectangleMode_; + return *this; + } + + PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ ) + { + discardRectangleCount = discardRectangleCount_; + return *this; + } + + PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ ) + { + pDiscardRectangles = pDiscardRectangles_; + return *this; + } + + operator const VkPipelineDiscardRectangleStateCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( discardRectangleMode == rhs.discardRectangleMode ) + && ( discardRectangleCount == rhs.discardRectangleCount ) + && ( pDiscardRectangles == rhs.pDiscardRectangles ); + } + + bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; + + public: + const void* pNext = nullptr; + PipelineDiscardRectangleStateCreateFlagsEXT flags; + DiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const Rect2D* pDiscardRectangles; + }; + static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class SubpassDescriptionFlagBits + { + ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, + ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX + }; + + using SubpassDescriptionFlags = Flags; + + VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 ) + { + return SubpassDescriptionFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits ) + { + return ~( SubpassDescriptionFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) + }; + }; + + struct SubpassDescription + { + SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(), + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + uint32_t inputAttachmentCount_ = 0, + const AttachmentReference* pInputAttachments_ = nullptr, + uint32_t colorAttachmentCount_ = 0, + const AttachmentReference* pColorAttachments_ = nullptr, + const AttachmentReference* pResolveAttachments_ = nullptr, + const AttachmentReference* pDepthStencilAttachment_ = nullptr, + uint32_t preserveAttachmentCount_ = 0, + const uint32_t* pPreserveAttachments_ = nullptr ) + : flags( flags_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , inputAttachmentCount( inputAttachmentCount_ ) + , pInputAttachments( pInputAttachments_ ) + , colorAttachmentCount( colorAttachmentCount_ ) + , pColorAttachments( pColorAttachments_ ) + , pResolveAttachments( pResolveAttachments_ ) + , pDepthStencilAttachment( pDepthStencilAttachment_ ) + , preserveAttachmentCount( preserveAttachmentCount_ ) + , pPreserveAttachments( pPreserveAttachments_ ) + { + } + + SubpassDescription( VkSubpassDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDescription ) ); + } + + SubpassDescription& operator=( VkSubpassDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDescription ) ); + return *this; + } + SubpassDescription& setFlags( SubpassDescriptionFlags flags_ ) + { + flags = flags_; + return *this; + } + + SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ ) + { + inputAttachmentCount = inputAttachmentCount_; + return *this; + } + + SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ ) + { + pInputAttachments = pInputAttachments_; + return *this; + } + + SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ ) + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ ) + { + pColorAttachments = pColorAttachments_; + return *this; + } + + SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ ) + { + pResolveAttachments = pResolveAttachments_; + return *this; + } + + SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ ) + { + pDepthStencilAttachment = pDepthStencilAttachment_; + return *this; + } + + SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) + { + preserveAttachmentCount = preserveAttachmentCount_; + return *this; + } + + SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ ) + { + pPreserveAttachments = pPreserveAttachments_; + return *this; + } + + operator const VkSubpassDescription&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SubpassDescription const& rhs ) const + { + return ( flags == rhs.flags ) + && ( pipelineBindPoint == rhs.pipelineBindPoint ) + && ( inputAttachmentCount == rhs.inputAttachmentCount ) + && ( pInputAttachments == rhs.pInputAttachments ) + && ( colorAttachmentCount == rhs.colorAttachmentCount ) + && ( pColorAttachments == rhs.pColorAttachments ) + && ( pResolveAttachments == rhs.pResolveAttachments ) + && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) + && ( preserveAttachmentCount == rhs.preserveAttachmentCount ) + && ( pPreserveAttachments == rhs.pPreserveAttachments ); + } + + bool operator!=( SubpassDescription const& rhs ) const + { + return !operator==( rhs ); + } + + SubpassDescriptionFlags flags; + PipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const AttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const AttachmentReference* pColorAttachments; + const AttachmentReference* pResolveAttachments; + const AttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; + }; + static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" ); + + struct RenderPassCreateInfo + { + RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), + uint32_t attachmentCount_ = 0, + const AttachmentDescription* pAttachments_ = nullptr, + uint32_t subpassCount_ = 0, + const SubpassDescription* pSubpasses_ = nullptr, + uint32_t dependencyCount_ = 0, + const SubpassDependency* pDependencies_ = nullptr ) + : flags( flags_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , subpassCount( subpassCount_ ) + , pSubpasses( pSubpasses_ ) + , dependencyCount( dependencyCount_ ) + , pDependencies( pDependencies_ ) + { + } + + RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); + } + + RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); + return *this; + } + RenderPassCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) + { + attachmentCount = attachmentCount_; + return *this; + } + + RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ ) + { + pAttachments = pAttachments_; + return *this; + } + + RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ ) + { + subpassCount = subpassCount_; + return *this; + } + + RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ ) + { + pSubpasses = pSubpasses_; + return *this; + } + + RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ ) + { + dependencyCount = dependencyCount_; + return *this; + } + + RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ ) + { + pDependencies = pDependencies_; + return *this; + } + + operator const VkRenderPassCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( RenderPassCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( attachmentCount == rhs.attachmentCount ) + && ( pAttachments == rhs.pAttachments ) + && ( subpassCount == rhs.subpassCount ) + && ( pSubpasses == rhs.pSubpasses ) + && ( dependencyCount == rhs.dependencyCount ) + && ( pDependencies == rhs.pDependencies ); + } + + bool operator!=( RenderPassCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassCreateInfo; + + public: + const void* pNext = nullptr; + RenderPassCreateFlags flags; + uint32_t attachmentCount; + const AttachmentDescription* pAttachments; + uint32_t subpassCount; + const SubpassDescription* pSubpasses; + uint32_t dependencyCount; + const SubpassDependency* pDependencies; + }; + static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); + + enum class PointClippingBehavior + { + eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY + }; + + struct PhysicalDevicePointClippingProperties + { + operator const VkPhysicalDevicePointClippingProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDevicePointClippingProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pointClippingBehavior == rhs.pointClippingBehavior ); + } + + bool operator!=( PhysicalDevicePointClippingProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; + + public: + void* pNext = nullptr; + PointClippingBehavior pointClippingBehavior; + }; + static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" ); + + using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; + + enum class SamplerReductionModeEXT + { + eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT, + eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT + }; + + struct SamplerReductionModeCreateInfoEXT + { + SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage ) + : reductionMode( reductionMode_ ) + { + } + + SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); + } + + SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); + return *this; + } + SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ ) + { + reductionMode = reductionMode_; + return *this; + } + + operator const VkSamplerReductionModeCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( reductionMode == rhs.reductionMode ); + } + + bool operator!=( SamplerReductionModeCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; + + public: + const void* pNext = nullptr; + SamplerReductionModeEXT reductionMode; + }; + static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class TessellationDomainOrigin + { + eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT + }; + + struct PipelineTessellationDomainOriginStateCreateInfo + { + PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft ) + : domainOrigin( domainOrigin_ ) + { + } + + PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) ); + } + + PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) ); + return *this; + } + PipelineTessellationDomainOriginStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineTessellationDomainOriginStateCreateInfo& setDomainOrigin( TessellationDomainOrigin domainOrigin_ ) + { + domainOrigin = domainOrigin_; + return *this; + } + + operator const VkPipelineTessellationDomainOriginStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( domainOrigin == rhs.domainOrigin ); + } + + bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; + + public: + const void* pNext = nullptr; + TessellationDomainOrigin domainOrigin; + }; + static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" ); + + using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; + + enum class SamplerYcbcrModelConversion + { + eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 + }; + + enum class SamplerYcbcrRange + { + eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW + }; + + enum class ChromaLocation + { + eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN, + eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN, + eMidpoint = VK_CHROMA_LOCATION_MIDPOINT, + eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT + }; + + struct SamplerYcbcrConversionCreateInfo + { + SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined, + SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, + SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull, + ComponentMapping components_ = ComponentMapping(), + ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven, + ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven, + Filter chromaFilter_ = Filter::eNearest, + Bool32 forceExplicitReconstruction_ = 0 ) + : format( format_ ) + , ycbcrModel( ycbcrModel_ ) + , ycbcrRange( ycbcrRange_ ) + , components( components_ ) + , xChromaOffset( xChromaOffset_ ) + , yChromaOffset( yChromaOffset_ ) + , chromaFilter( chromaFilter_ ) + , forceExplicitReconstruction( forceExplicitReconstruction_ ) + { + } + + SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) ); + } + + SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) ); + return *this; + } + SamplerYcbcrConversionCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ ) + { + ycbcrModel = ycbcrModel_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setYcbcrRange( SamplerYcbcrRange ycbcrRange_ ) + { + ycbcrRange = ycbcrRange_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setComponents( ComponentMapping components_ ) + { + components = components_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setXChromaOffset( ChromaLocation xChromaOffset_ ) + { + xChromaOffset = xChromaOffset_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setYChromaOffset( ChromaLocation yChromaOffset_ ) + { + yChromaOffset = yChromaOffset_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setChromaFilter( Filter chromaFilter_ ) + { + chromaFilter = chromaFilter_; + return *this; + } + + SamplerYcbcrConversionCreateInfo& setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ ) + { + forceExplicitReconstruction = forceExplicitReconstruction_; + return *this; + } + + operator const VkSamplerYcbcrConversionCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SamplerYcbcrConversionCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( format == rhs.format ) + && ( ycbcrModel == rhs.ycbcrModel ) + && ( ycbcrRange == rhs.ycbcrRange ) + && ( components == rhs.components ) + && ( xChromaOffset == rhs.xChromaOffset ) + && ( yChromaOffset == rhs.yChromaOffset ) + && ( chromaFilter == rhs.chromaFilter ) + && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction ); + } + + bool operator!=( SamplerYcbcrConversionCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; + + public: + const void* pNext = nullptr; + Format format; + SamplerYcbcrModelConversion ycbcrModel; + SamplerYcbcrRange ycbcrRange; + ComponentMapping components; + ChromaLocation xChromaOffset; + ChromaLocation yChromaOffset; + Filter chromaFilter; + Bool32 forceExplicitReconstruction; + }; + static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" ); + + using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + struct AndroidHardwareBufferFormatPropertiesANDROID + { + operator const VkAndroidHardwareBufferFormatPropertiesANDROID&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( format == rhs.format ) + && ( externalFormat == rhs.externalFormat ) + && ( formatFeatures == rhs.formatFeatures ) + && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) + && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) + && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) + && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) + && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); + } + + bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; + + public: + void* pNext = nullptr; + Format format; + uint64_t externalFormat; + FormatFeatureFlags formatFeatures; + ComponentMapping samplerYcbcrConversionComponents; + SamplerYcbcrModelConversion suggestedYcbcrModel; + SamplerYcbcrRange suggestedYcbcrRange; + ChromaLocation suggestedXChromaOffset; + ChromaLocation suggestedYChromaOffset; + }; + static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + + enum class BlendOverlapEXT + { + eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, + eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT + }; + + struct PipelineColorBlendAdvancedStateCreateInfoEXT + { + PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, + Bool32 dstPremultiplied_ = 0, + BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated ) + : srcPremultiplied( srcPremultiplied_ ) + , dstPremultiplied( dstPremultiplied_ ) + , blendOverlap( blendOverlap_ ) + { + } + + PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); + return *this; + } + PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ ) + { + srcPremultiplied = srcPremultiplied_; + return *this; + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ ) + { + dstPremultiplied = dstPremultiplied_; + return *this; + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ ) + { + blendOverlap = blendOverlap_; + return *this; + } + + operator const VkPipelineColorBlendAdvancedStateCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcPremultiplied == rhs.srcPremultiplied ) + && ( dstPremultiplied == rhs.dstPremultiplied ) + && ( blendOverlap == rhs.blendOverlap ); + } + + bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; + + public: + const void* pNext = nullptr; + Bool32 srcPremultiplied; + Bool32 dstPremultiplied; + BlendOverlapEXT blendOverlap; + }; + static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class CoverageModulationModeNV + { + eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV, + eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV, + eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV, + eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV + }; + + struct PipelineCoverageModulationStateCreateInfoNV + { + PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), + CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, + Bool32 coverageModulationTableEnable_ = 0, + uint32_t coverageModulationTableCount_ = 0, + const float* pCoverageModulationTable_ = nullptr ) + : flags( flags_ ) + , coverageModulationMode( coverageModulationMode_ ) + , coverageModulationTableEnable( coverageModulationTableEnable_ ) + , coverageModulationTableCount( coverageModulationTableCount_ ) + , pCoverageModulationTable( pCoverageModulationTable_ ) + { + } + + PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); + } + + PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); + return *this; + } + PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) + { + coverageModulationMode = coverageModulationMode_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) + { + coverageModulationTableEnable = coverageModulationTableEnable_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) + { + coverageModulationTableCount = coverageModulationTableCount_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ ) + { + pCoverageModulationTable = pCoverageModulationTable_; + return *this; + } + + operator const VkPipelineCoverageModulationStateCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( coverageModulationMode == rhs.coverageModulationMode ) + && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) + && ( coverageModulationTableCount == rhs.coverageModulationTableCount ) + && ( pCoverageModulationTable == rhs.pCoverageModulationTable ); + } + + bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; + + public: + const void* pNext = nullptr; + PipelineCoverageModulationStateCreateFlagsNV flags; + CoverageModulationModeNV coverageModulationMode; + Bool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; + }; + static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" ); + + enum class ValidationCacheHeaderVersionEXT + { + eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + }; + + enum class ShaderInfoTypeAMD + { + eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD, + eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD, + eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD + }; + + enum class QueueGlobalPriorityEXT + { + eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, + eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT, + eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT, + eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT + }; + + struct DeviceQueueGlobalPriorityCreateInfoEXT + { + DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow ) + : globalPriority( globalPriority_ ) + { + } + + DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); + } + + DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); + return *this; + } + DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ ) + { + globalPriority = globalPriority_; + return *this; + } + + operator const VkDeviceQueueGlobalPriorityCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( globalPriority == rhs.globalPriority ); + } + + bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; + + public: + const void* pNext = nullptr; + QueueGlobalPriorityEXT globalPriority; + }; + static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class DebugUtilsMessageSeverityFlagBitsEXT + { + eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, + eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, + eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, + eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT + }; + + using DebugUtilsMessageSeverityFlagsEXT = Flags; + + VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 ) + { + return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits ) + { + return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError) + }; + }; + + enum class DebugUtilsMessageTypeFlagBitsEXT + { + eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, + eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, + ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT + }; + + using DebugUtilsMessageTypeFlagsEXT = Flags; + + VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 ) + { + return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits ) + { + return ~( DebugUtilsMessageTypeFlagsEXT( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance) + }; + }; + + struct DebugUtilsMessengerCreateInfoEXT + { + DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(), + DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(), + DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(), + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr, + void* pUserData_ = nullptr ) + : flags( flags_ ) + , messageSeverity( messageSeverity_ ) + , messageType( messageType_ ) + , pfnUserCallback( pfnUserCallback_ ) + , pUserData( pUserData_ ) + { + } + + DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) ); + } + + DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) ); + return *this; + } + DebugUtilsMessengerCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DebugUtilsMessengerCreateInfoEXT& setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + DebugUtilsMessengerCreateInfoEXT& setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) + { + messageSeverity = messageSeverity_; + return *this; + } + + DebugUtilsMessengerCreateInfoEXT& setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) + { + messageType = messageType_; + return *this; + } + + DebugUtilsMessengerCreateInfoEXT& setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) + { + pfnUserCallback = pfnUserCallback_; + return *this; + } + + DebugUtilsMessengerCreateInfoEXT& setPUserData( void* pUserData_ ) + { + pUserData = pUserData_; + return *this; + } + + operator const VkDebugUtilsMessengerCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugUtilsMessengerCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( messageSeverity == rhs.messageSeverity ) + && ( messageType == rhs.messageType ) + && ( pfnUserCallback == rhs.pfnUserCallback ) + && ( pUserData == rhs.pUserData ); + } + + bool operator!=( DebugUtilsMessengerCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + + public: + const void* pNext = nullptr; + DebugUtilsMessengerCreateFlagsEXT flags; + DebugUtilsMessageSeverityFlagsEXT messageSeverity; + DebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; + }; + static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class ConservativeRasterizationModeEXT + { + eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, + eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, + eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT + }; + + struct PipelineRasterizationConservativeStateCreateInfoEXT + { + PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(), + ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled, + float extraPrimitiveOverestimationSize_ = 0 ) + : flags( flags_ ) + , conservativeRasterizationMode( conservativeRasterizationMode_ ) + , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ ) + { + } + + PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) ); + } + + PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) ); + return *this; + } + PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ ) + { + conservativeRasterizationMode = conservativeRasterizationMode_; + return *this; + } + + PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ ) + { + extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_; + return *this; + } + + operator const VkPipelineRasterizationConservativeStateCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) + && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); + } + + bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; + + public: + const void* pNext = nullptr; + PipelineRasterizationConservativeStateCreateFlagsEXT flags; + ConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; + }; + static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class DescriptorBindingFlagBitsEXT + { + eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT, + eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT, + ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT, + eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT + }; + + using DescriptorBindingFlagsEXT = Flags; + + VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 ) + { + return DescriptorBindingFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits ) + { + return ~( DescriptorBindingFlagsEXT( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DescriptorBindingFlagBitsEXT::eUpdateAfterBind) | VkFlags(DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) | VkFlags(DescriptorBindingFlagBitsEXT::ePartiallyBound) | VkFlags(DescriptorBindingFlagBitsEXT::eVariableDescriptorCount) + }; + }; + + struct DescriptorSetLayoutBindingFlagsCreateInfoEXT + { + DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0, + const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) + : bindingCount( bindingCount_ ) + , pBindingFlags( pBindingFlags_ ) + { + } + + DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) ); + } + + DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) ); + return *this; + } + DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorSetLayoutBindingFlagsCreateInfoEXT& setBindingCount( uint32_t bindingCount_ ) + { + bindingCount = bindingCount_; + return *this; + } + + DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ ) + { + pBindingFlags = pBindingFlags_; + return *this; + } + + operator const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( bindingCount == rhs.bindingCount ) + && ( pBindingFlags == rhs.pBindingFlags ); + } + + bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT; + + public: + const void* pNext = nullptr; + uint32_t bindingCount; + const DescriptorBindingFlagsEXT* pBindingFlags; + }; + static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class VendorId + { + eViv = VK_VENDOR_ID_VIV, + eVsi = VK_VENDOR_ID_VSI, + eKazan = VK_VENDOR_ID_KAZAN + }; + + template + Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() ); +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type enumerateInstanceVersion(Dispatch const &d = Dispatch() ); +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d) + { + return static_cast( d.vkEnumerateInstanceVersion( pApiVersion ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type enumerateInstanceVersion(Dispatch const &d ) + { + uint32_t apiVersion; + Result result = static_cast( d.vkEnumerateInstanceVersion( &apiVersion ) ); + return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceVersion" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + template + Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ); +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() ); +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) + { + return static_cast( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceLayerProperties(Dispatch const &d ) + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + template + Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ); +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName = nullptr, Dispatch const &d = Dispatch() ); +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) + { + return static_cast( d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName, Dispatch const &d ) + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + // forward declarations + struct CmdProcessCommandsInfoNVX; + + class CommandBuffer + { + public: + VULKAN_HPP_CONSTEXPR CommandBuffer() + : m_commandBuffer(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) + : m_commandBuffer(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) + : m_commandBuffer( commandBuffer ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + CommandBuffer & operator=(VkCommandBuffer commandBuffer) + { + m_commandBuffer = commandBuffer; + return *this; + } +#endif + + CommandBuffer & operator=( std::nullptr_t ) + { + m_commandBuffer = VK_NULL_HANDLE; + return *this; + } + + bool operator==( CommandBuffer const & rhs ) const + { + return m_commandBuffer == rhs.m_commandBuffer; + } + + bool operator!=(CommandBuffer const & rhs ) const + { + return m_commandBuffer != rhs.m_commandBuffer; + } + + bool operator<(CommandBuffer const & rhs ) const + { + return m_commandBuffer < rhs.m_commandBuffer; + } + + template + Result begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result end(Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type end(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const; + + template + void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setViewport( uint32_t firstViewport, ArrayProxy viewports, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setScissor( uint32_t firstScissor, ArrayProxy scissors, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const; + + template + void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = Dispatch() ) const; + + template + void setBlendConstants( const float blendConstants[4], Dispatch const &d = Dispatch() ) const; + + template + void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = Dispatch() ) const; + + template + void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const; + + template + void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const; + + template + void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const; + + template + void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy descriptorSets, ArrayProxy dynamicOffsets, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d = Dispatch() ) const; + + template + void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void bindVertexBuffers( uint32_t firstBinding, ArrayProxy buffers, ArrayProxy offsets, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const; + + template + void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const; + + template + void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + template + void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + template + void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const; + + template + void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const; + + template + void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Filter filter, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy data, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const; + + template + void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy ranges, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy ranges, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void clearAttachments( ArrayProxy attachments, ArrayProxy rects, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const; + + template + void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const; + + template + void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void waitEvents( ArrayProxy events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const; + + template + void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const; + + template + void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const; + + template + void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const; + + template + void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; + + template + void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy values, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const; + + template + void endRenderPass(Dispatch const &d = Dispatch() ) const; + + template + void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void executeCommands( ArrayProxy commandBuffers, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void debugMarkerEndEXT(Dispatch const &d = Dispatch() ) const; + + template + void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + template + void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + template + void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy descriptorWrites, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setDeviceMask( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const; + + template + void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const; + + template + void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const; + + template + void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const; + + template + void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const; + + template + void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy viewportWScalings, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy discardRectangles, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const; + + template + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const; + + template + void drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + template + void drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const + { + return m_commandBuffer; + } + + explicit operator bool() const + { + return m_commandBuffer != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_commandBuffer == VK_NULL_HANDLE; + } + + private: + VkCommandBuffer m_commandBuffer; + }; + + static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); + + template + VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const + { + return static_cast( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( pBeginInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( &beginInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::begin" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result CommandBuffer::end(Dispatch const &d) const + { + return static_cast( d.vkEndCommandBuffer( m_commandBuffer ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::end(Dispatch const &d ) const + { + Result result = static_cast( d.vkEndCommandBuffer( m_commandBuffer ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::end" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d) const + { + return static_cast( d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d ) const + { + Result result = static_cast( d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::reset" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d) const + { + d.vkCmdBindPipeline( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( pipeline ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d ) const + { + d.vkCmdBindPipeline( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( pipeline ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d) const + { + d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast( pViewports ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy viewports, Dispatch const &d ) const + { + d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast( viewports.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d) const + { + d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast( pScissors ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy scissors, Dispatch const &d ) const + { + d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast( scissors.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const + { + d.vkCmdSetLineWidth( m_commandBuffer, lineWidth ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d ) const + { + d.vkCmdSetLineWidth( m_commandBuffer, lineWidth ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d) const + { + d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d ) const + { + d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d) const + { + d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d ) const + { + d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d) const + { + d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d ) const + { + d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const + { + d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast( faceMask ), compareMask ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const + { + d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast( faceMask ), compareMask ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const + { + d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast( faceMask ), writeMask ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const + { + d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast( faceMask ), writeMask ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const + { + d.vkCmdSetStencilReference( m_commandBuffer, static_cast( faceMask ), reference ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const + { + d.vkCmdSetStencilReference( m_commandBuffer, static_cast( faceMask ), reference ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d) const + { + d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), firstSet, descriptorSetCount, reinterpret_cast( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy descriptorSets, ArrayProxy dynamicOffsets, Dispatch const &d ) const + { + d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), firstSet, descriptorSets.size() , reinterpret_cast( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d) const + { + d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast( buffer ), offset, static_cast( indexType ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d ) const + { + d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast( buffer ), offset, static_cast( indexType ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d) const + { + d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast( pBuffers ), pOffsets ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy buffers, ArrayProxy offsets, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); +#else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); + } +#endif // VULKAN_HPP_NO_EXCEPTIONS + d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast( buffers.data() ), offsets.data() ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d) const + { + d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d ) const + { + d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d) const + { + d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d ) const + { + d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const + { + d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const + { + d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d) const + { + d.vkCmdDispatchIndirect( m_commandBuffer, static_cast( buffer ), offset ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d ) const + { + d.vkCmdDispatchIndirect( m_commandBuffer, static_cast( buffer ), offset ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d) const + { + d.vkCmdCopyBuffer( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstBuffer ), regionCount, reinterpret_cast( pRegions ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d ) const + { + d.vkCmdCopyBuffer( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstBuffer ), regions.size() , reinterpret_cast( regions.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d) const + { + d.vkCmdCopyImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d ) const + { + d.vkCmdCopyImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d) const + { + d.vkCmdBlitImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ), static_cast( filter ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Filter filter, Dispatch const &d ) const + { + d.vkCmdBlitImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ), static_cast( filter ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const + { + d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d ) const + { + d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const + { + d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstBuffer ), regionCount, reinterpret_cast( pRegions ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d ) const + { + d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstBuffer ), regions.size() , reinterpret_cast( regions.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d) const + { + d.vkCmdUpdateBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, dataSize, pData ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy data, Dispatch const &d ) const + { + d.vkCmdUpdateBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d) const + { + d.vkCmdFillBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, size, data ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d ) const + { + d.vkCmdFillBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, size, data ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const + { + d.vkCmdClearColorImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( pColor ), rangeCount, reinterpret_cast( pRanges ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy ranges, Dispatch const &d ) const + { + d.vkCmdClearColorImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( &color ), ranges.size() , reinterpret_cast( ranges.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const + { + d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( pDepthStencil ), rangeCount, reinterpret_cast( pRanges ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy ranges, Dispatch const &d ) const + { + d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( &depthStencil ), ranges.size() , reinterpret_cast( ranges.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d) const + { + d.vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast( pAttachments ), rectCount, reinterpret_cast( pRects ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy attachments, ArrayProxy rects, Dispatch const &d ) const + { + d.vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast( attachments.data() ), rects.size() , reinterpret_cast( rects.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d) const + { + d.vkCmdResolveImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d ) const + { + d.vkCmdResolveImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const + { + d.vkCmdSetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const + { + d.vkCmdSetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const + { + d.vkCmdResetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const + { + d.vkCmdResetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const + { + d.vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast( pEvents ), static_cast( srcStageMask ), static_cast( dstStageMask ), memoryBarrierCount, reinterpret_cast( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d ) const + { + d.vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast( events.data() ), static_cast( srcStageMask ), static_cast( dstStageMask ), memoryBarriers.size() , reinterpret_cast( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast( imageMemoryBarriers.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const + { + d.vkCmdPipelineBarrier( m_commandBuffer, static_cast( srcStageMask ), static_cast( dstStageMask ), static_cast( dependencyFlags ), memoryBarrierCount, reinterpret_cast( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d ) const + { + d.vkCmdPipelineBarrier( m_commandBuffer, static_cast( srcStageMask ), static_cast( dstStageMask ), static_cast( dependencyFlags ), memoryBarriers.size() , reinterpret_cast( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast( imageMemoryBarriers.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d) const + { + d.vkCmdBeginQuery( m_commandBuffer, static_cast( queryPool ), query, static_cast( flags ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d ) const + { + d.vkCmdBeginQuery( m_commandBuffer, static_cast( queryPool ), query, static_cast( flags ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d) const + { + d.vkCmdEndQuery( m_commandBuffer, static_cast( queryPool ), query ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d ) const + { + d.vkCmdEndQuery( m_commandBuffer, static_cast( queryPool ), query ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const + { + d.vkCmdResetQueryPool( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const + { + d.vkCmdResetQueryPool( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d) const + { + d.vkCmdWriteTimestamp( m_commandBuffer, static_cast( pipelineStage ), static_cast( queryPool ), query ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d ) const + { + d.vkCmdWriteTimestamp( m_commandBuffer, static_cast( pipelineStage ), static_cast( queryPool ), query ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const + { + d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount, static_cast( dstBuffer ), dstOffset, stride, static_cast( flags ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const + { + d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount, static_cast( dstBuffer ), dstOffset, stride, static_cast( flags ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const + { + d.vkCmdPushConstants( m_commandBuffer, static_cast( layout ), static_cast( stageFlags ), offset, size, pValues ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy values, Dispatch const &d ) const + { + d.vkCmdPushConstants( m_commandBuffer, static_cast( layout ), static_cast( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast( values.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d) const + { + d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast( pRenderPassBegin ), static_cast( contents ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d ) const + { + d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast( &renderPassBegin ), static_cast( contents ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d) const + { + d.vkCmdNextSubpass( m_commandBuffer, static_cast( contents ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d ) const + { + d.vkCmdNextSubpass( m_commandBuffer, static_cast( contents ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d) const + { + d.vkCmdEndRenderPass( m_commandBuffer ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d ) const + { + d.vkCmdEndRenderPass( m_commandBuffer ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const + { + d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast( pCommandBuffers ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy commandBuffers, Dispatch const &d ) const + { + d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast( commandBuffers.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const + { + d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast( pMarkerInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d ) const + { + d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT(Dispatch const &d) const + { + d.vkCmdDebugMarkerEndEXT( m_commandBuffer ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT(Dispatch const &d ) const + { + d.vkCmdDebugMarkerEndEXT( m_commandBuffer ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const + { + d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast( pMarkerInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d ) const + { + d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const + { + d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast( pProcessCommandsInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d ) const + { + d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast( &processCommandsInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const + { + d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast( pReserveSpaceInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d ) const + { + d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast( &reserveSpaceInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const + { + d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), set, descriptorWriteCount, reinterpret_cast( pDescriptorWrites ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy descriptorWrites, Dispatch const &d ) const + { + d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), set, descriptorWrites.size() , reinterpret_cast( descriptorWrites.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d) const + { + d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d ) const + { + d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d) const + { + d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d ) const + { + d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const + { + d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const + { + d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const + { + d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const + { + d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const + { + d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast( descriptorUpdateTemplate ), static_cast( layout ), set, pData ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const + { + d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast( descriptorUpdateTemplate ), static_cast( layout ), set, pData ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const + { + d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast( pViewportWScalings ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy viewportWScalings, Dispatch const &d ) const + { + d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast( viewportWScalings.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d) const + { + d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast( pDiscardRectangles ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy discardRectangles, Dispatch const &d ) const + { + d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast( discardRectangles.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const + { + d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast( pSampleLocationsInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d ) const + { + d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast( &sampleLocationsInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const + { + d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( pLabelInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const + { + d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d) const + { + d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d ) const + { + d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const + { + d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( pLabelInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const + { + d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const + { + d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast( pipelineStage ), static_cast( dstBuffer ), dstOffset, marker ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const + { + d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast( pipelineStage ), static_cast( dstBuffer ), dstOffset, marker ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + struct SubmitInfo + { + SubmitInfo( uint32_t waitSemaphoreCount_ = 0, + const Semaphore* pWaitSemaphores_ = nullptr, + const PipelineStageFlags* pWaitDstStageMask_ = nullptr, + uint32_t commandBufferCount_ = 0, + const CommandBuffer* pCommandBuffers_ = nullptr, + uint32_t signalSemaphoreCount_ = 0, + const Semaphore* pSignalSemaphores_ = nullptr ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , pWaitDstStageMask( pWaitDstStageMask_ ) + , commandBufferCount( commandBufferCount_ ) + , pCommandBuffers( pCommandBuffers_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphores( pSignalSemaphores_ ) + { + } + + SubmitInfo( VkSubmitInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SubmitInfo ) ); + } + + SubmitInfo& operator=( VkSubmitInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( SubmitInfo ) ); + return *this; + } + SubmitInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + SubmitInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) + { + pWaitSemaphores = pWaitSemaphores_; + return *this; + } + + SubmitInfo& setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ ) + { + pWaitDstStageMask = pWaitDstStageMask_; + return *this; + } + + SubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) + { + commandBufferCount = commandBufferCount_; + return *this; + } + + SubmitInfo& setPCommandBuffers( const CommandBuffer* pCommandBuffers_ ) + { + pCommandBuffers = pCommandBuffers_; + return *this; + } + + SubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) + { + signalSemaphoreCount = signalSemaphoreCount_; + return *this; + } + + SubmitInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) + { + pSignalSemaphores = pSignalSemaphores_; + return *this; + } + + operator const VkSubmitInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SubmitInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) + && ( pWaitSemaphores == rhs.pWaitSemaphores ) + && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) + && ( commandBufferCount == rhs.commandBufferCount ) + && ( pCommandBuffers == rhs.pCommandBuffers ) + && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) + && ( pSignalSemaphores == rhs.pSignalSemaphores ); + } + + bool operator!=( SubmitInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSubmitInfo; + + public: + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const Semaphore* pWaitSemaphores; + const PipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const CommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const Semaphore* pSignalSemaphores; + }; + static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); + + class Queue + { + public: + VULKAN_HPP_CONSTEXPR Queue() + : m_queue(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) + : m_queue(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) + : m_queue( queue ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Queue & operator=(VkQueue queue) + { + m_queue = queue; + return *this; + } +#endif + + Queue & operator=( std::nullptr_t ) + { + m_queue = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Queue const & rhs ) const + { + return m_queue == rhs.m_queue; + } + + bool operator!=(Queue const & rhs ) const + { + return m_queue != rhs.m_queue; + } + + bool operator<(Queue const & rhs ) const + { + return m_queue < rhs.m_queue; + } + + template + Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type submit( ArrayProxy submits, Fence fence, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result waitIdle(Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type waitIdle(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type bindSparse( ArrayProxy bindInfo, Fence fence, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const; + + template + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const + { + return m_queue; + } + + explicit operator bool() const + { + return m_queue != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_queue == VK_NULL_HANDLE; + } + + private: + VkQueue m_queue; + }; + + static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); + + template + VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const + { + return static_cast( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Queue::submit( ArrayProxy submits, Fence fence, Dispatch const &d ) const + { + Result result = static_cast( d.vkQueueSubmit( m_queue, submits.size() , reinterpret_cast( submits.data() ), static_cast( fence ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::submit" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Queue::waitIdle(Dispatch const &d) const + { + return static_cast( d.vkQueueWaitIdle( m_queue ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Queue::waitIdle(Dispatch const &d ) const + { + Result result = static_cast( d.vkQueueWaitIdle( m_queue ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::waitIdle" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d) const + { + return static_cast( d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast( pBindInfo ), static_cast( fence ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Queue::bindSparse( ArrayProxy bindInfo, Fence fence, Dispatch const &d ) const + { + Result result = static_cast( d.vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast( bindInfo.data() ), static_cast( fence ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::bindSparse" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d) const + { + return static_cast( d.vkQueuePresentKHR( m_queue, reinterpret_cast( pPresentInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkQueuePresentKHR( m_queue, reinterpret_cast( &presentInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const + { + d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast( pLabelInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const + { + d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d) const + { + d.vkQueueEndDebugUtilsLabelEXT( m_queue ); + } +#else + template + VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d ) const + { + d.vkQueueEndDebugUtilsLabelEXT( m_queue ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const + { + d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast( pLabelInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const + { + d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + class Device; + + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueBuffer = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueBufferView = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = PoolFree; }; + using UniqueCommandBuffer = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueCommandPool = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueDescriptorPool = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = PoolFree; }; + using UniqueDescriptorSet = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueDescriptorSetLayout = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueDescriptorUpdateTemplate = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectFree; }; + using UniqueDeviceMemory = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueEvent = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueFence = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueFramebuffer = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueImage = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueImageView = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueIndirectCommandsLayoutNVX = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueObjectTableNVX = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniquePipeline = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniquePipelineCache = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniquePipelineLayout = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueQueryPool = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueRenderPass = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueSampler = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueSamplerYcbcrConversion = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueSemaphore = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueShaderModule = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueSwapchainKHR = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueValidationCacheEXT = UniqueHandle; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + class Device + { + public: + VULKAN_HPP_CONSTEXPR Device() + : m_device(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) + : m_device(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) + : m_device( device ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Device & operator=(VkDevice device) + { + m_device = device; + return *this; + } +#endif + + Device & operator=( std::nullptr_t ) + { + m_device = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Device const & rhs ) const + { + return m_device == rhs.m_device; + } + + bool operator!=(Device const & rhs ) const + { + return m_device != rhs.m_device; + } + + bool operator<(Device const & rhs ) const + { + return m_device < rhs.m_device; + } + + template + PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result waitIdle(Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type waitIdle(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void freeMemory( DeviceMemory memory, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void free( DeviceMemory memory, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const; + + template + Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type flushMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type invalidateMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + DeviceSize getMemoryCommitment( DeviceMemory memory, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MemoryRequirements getBufferMemoryRequirements( Buffer buffer, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MemoryRequirements getImageMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createFence( const FenceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createFenceUnique( const FenceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyFence( Fence fence, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Fence fence, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type resetFences( ArrayProxy fences, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const; + + template + Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result waitForFences( ArrayProxy fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroySemaphore( Semaphore semaphore, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Semaphore semaphore, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createEvent( const EventCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createEventUnique( const EventCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyEvent( Event event, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Event event, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getEventStatus( Event event, Dispatch const &d = Dispatch() ) const; + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result setEvent( Event event, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type setEvent( Event event, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result resetEvent( Event event, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type resetEvent( Event event, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyQueryPool( QueryPool queryPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( QueryPool queryPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createBuffer( const BufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createBufferUnique( const BufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyBuffer( Buffer buffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Buffer buffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createBufferView( const BufferViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyBufferView( BufferView bufferView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( BufferView bufferView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createImage( const ImageCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createImageUnique( const ImageCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyImage( Image image, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Image image, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createImageView( const ImageViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyImageView( ImageView imageView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( ImageView imageView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyShaderModule( ShaderModule shaderModule, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( ShaderModule shaderModule, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyPipelineCache( PipelineCache pipelineCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( PipelineCache pipelineCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy srcCaches, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template , typename Dispatch = DispatchLoaderStatic> + ResultValueType::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template , typename Dispatch = DispatchLoaderStatic> + ResultValueType::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template , typename Dispatch = DispatchLoaderStatic> + ResultValueType::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template , typename Dispatch = DispatchLoaderStatic> + ResultValueType::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyPipeline( Pipeline pipeline, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Pipeline pipeline, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( PipelineLayout pipelineLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createSampler( const SamplerCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroySampler( Sampler sampler, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Sampler sampler, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( DescriptorSetLayout descriptorSetLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyDescriptorPool( DescriptorPool descriptorPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( DescriptorPool descriptorPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type free( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void updateDescriptorSets( ArrayProxy descriptorWrites, ArrayProxy descriptorCopies, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyFramebuffer( Framebuffer framebuffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Framebuffer framebuffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyRenderPass( RenderPass renderPass, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( RenderPass renderPass, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Extent2D getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyCommandPool( CommandPool commandPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( CommandPool commandPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void freeCommandBuffers( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void free( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template , typename Dispatch = DispatchLoaderStatic> + ResultValueType::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template , typename Dispatch = DispatchLoaderStatic> + ResultValueType::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroySwapchainKHR( SwapchainKHR swapchain, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( SwapchainKHR swapchain, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValue acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_NV + template + Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_NV*/ + + template + Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( ObjectTableNVX objectTable, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy pObjectTableEntries, ArrayProxy objectIndices, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy objectEntryTypes, ArrayProxy objectIndices, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const; + + template + void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template + Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template + Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template + Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type bindBufferMemory2( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type bindBufferMemory2KHR( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type bindImageMemory2( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type bindImageMemory2KHR( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValue acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const; + + template + void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const; + + template + void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setHdrMetadataEXT( ArrayProxy swapchains, ArrayProxy metadata, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; + + template + Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; + template + StructureChain getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; + template + StructureChain getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; + template + StructureChain getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; + template + StructureChain getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( SamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( ValidationCacheEXT validationCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy srcCaches, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; + template + StructureChain getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; + template + StructureChain getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template + Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const; + template + typename ResultValueType>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template + Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const + { + return m_device; + } + + explicit operator bool() const + { + return m_device != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_device == VK_NULL_HANDLE; + } + + private: + VkDevice m_device; + }; + + static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); + + template + VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char* pName, Dispatch const &d) const + { + return d.vkGetDeviceProcAddr( m_device, pName ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name, Dispatch const &d ) const + { + return d.vkGetDeviceProcAddr( m_device, name.c_str() ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDevice( m_device, reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDevice( m_device, reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d) const + { + d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast( pQueue ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const + { + Queue queue; + d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast( &queue ) ); + return queue; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::waitIdle(Dispatch const &d) const + { + return static_cast( d.vkDeviceWaitIdle( m_device ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::waitIdle(Dispatch const &d ) const + { + Result result = static_cast( d.vkDeviceWaitIdle( m_device ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitIdle" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d) const + { + return static_cast( d.vkAllocateMemory( m_device, reinterpret_cast( pAllocateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMemory ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const &d ) const + { + DeviceMemory memory; + Result result = static_cast( d.vkAllocateMemory( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &memory ) ) ); + return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemory" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const &d ) const + { + DeviceMemory memory; + Result result = static_cast( d.vkAllocateMemory( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &memory ) ) ); + + ObjectFree deleter( *this, allocator ); + return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemoryUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional allocator, Dispatch const &d ) const + { + d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, Optional allocator, Dispatch const &d ) const + { + d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d) const + { + return static_cast( d.vkMapMemory( m_device, static_cast( memory ), offset, size, static_cast( flags ), ppData ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const &d ) const + { + void* pData; + Result result = static_cast( d.vkMapMemory( m_device, static_cast( memory ), offset, size, static_cast( flags ), &pData ) ); + return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING"::Device::mapMemory" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const + { + d.vkUnmapMemory( m_device, static_cast( memory ) ); + } +#else + template + VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d ) const + { + d.vkUnmapMemory( m_device, static_cast( memory ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const + { + return static_cast( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::flushMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d ) const + { + Result result = static_cast( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast( memoryRanges.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::flushMappedMemoryRanges" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const + { + return static_cast( d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::invalidateMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d ) const + { + Result result = static_cast( d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast( memoryRanges.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::invalidateMappedMemoryRanges" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const + { + d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), pCommittedMemoryInBytes ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const &d ) const + { + DeviceSize committedMemoryInBytes; + d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), &committedMemoryInBytes ); + return committedMemoryInBytes; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const + { + d.vkGetBufferMemoryRequirements( m_device, static_cast( buffer ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const &d ) const + { + MemoryRequirements memoryRequirements; + d.vkGetBufferMemoryRequirements( m_device, static_cast( buffer ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const + { + return static_cast( d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), memoryOffset ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const + { + Result result = static_cast( d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), memoryOffset ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const + { + d.vkGetImageMemoryRequirements( m_device, static_cast( image ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const &d ) const + { + MemoryRequirements memoryRequirements; + d.vkGetImageMemoryRequirements( m_device, static_cast( image ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const + { + return static_cast( d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), memoryOffset ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const + { + Result result = static_cast( d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), memoryOffset ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const + { + d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements( Image image, Dispatch const &d ) const + { + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); + return sparseMemoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const + { + return static_cast( d.vkCreateFence( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFence ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createFence( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Fence fence; + Result result = static_cast( d.vkCreateFence( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); + return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFence" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Fence fence; + Result result = static_cast( d.vkCreateFence( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFenceUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d) const + { + return static_cast( d.vkResetFences( m_device, fenceCount, reinterpret_cast( pFences ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::resetFences( ArrayProxy fences, Dispatch const &d ) const + { + Result result = static_cast( d.vkResetFences( m_device, fences.size() , reinterpret_cast( fences.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetFences" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d) const + { + return static_cast( d.vkGetFenceStatus( m_device, static_cast( fence ) ) ); + } +#else + template + VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d ) const + { + Result result = static_cast( d.vkGetFenceStatus( m_device, static_cast( fence ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d) const + { + return static_cast( d.vkWaitForFences( m_device, fenceCount, reinterpret_cast( pFences ), waitAll, timeout ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const + { + Result result = static_cast( d.vkWaitForFences( m_device, fences.size() , reinterpret_cast( fences.data() ), waitAll, timeout ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d) const + { + return static_cast( d.vkCreateSemaphore( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSemaphore ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Semaphore semaphore; + Result result = static_cast( d.vkCreateSemaphore( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &semaphore ) ) ); + return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphore" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Semaphore semaphore; + Result result = static_cast( d.vkCreateSemaphore( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &semaphore ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphoreUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d) const + { + return static_cast( d.vkCreateEvent( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pEvent ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createEvent( const EventCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Event event; + Result result = static_cast( d.vkCreateEvent( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &event ) ) ); + return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEvent" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Event event; + Result result = static_cast( d.vkCreateEvent( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &event ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEventUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Event event, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d) const + { + return static_cast( d.vkGetEventStatus( m_device, static_cast( event ) ) ); + } +#else + template + VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d ) const + { + Result result = static_cast( d.vkGetEventStatus( m_device, static_cast( event ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const &d) const + { + return static_cast( d.vkSetEvent( m_device, static_cast( event ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::setEvent( Event event, Dispatch const &d ) const + { + Result result = static_cast( d.vkSetEvent( m_device, static_cast( event ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setEvent" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const &d) const + { + return static_cast( d.vkResetEvent( m_device, static_cast( event ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::resetEvent( Event event, Dispatch const &d ) const + { + Result result = static_cast( d.vkResetEvent( m_device, static_cast( event ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetEvent" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d) const + { + return static_cast( d.vkCreateQueryPool( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pQueryPool ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + QueryPool queryPool; + Result result = static_cast( d.vkCreateQueryPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &queryPool ) ) ); + return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPool" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + QueryPool queryPool; + Result result = static_cast( d.vkCreateQueryPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &queryPool ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPoolUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const + { + return static_cast( d.vkGetQueryPoolResults( m_device, static_cast( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast( flags ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const + { + Result result = static_cast( d.vkGetQueryPoolResults( m_device, static_cast( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast( data.data() ), stride, static_cast( flags ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d) const + { + return static_cast( d.vkCreateBuffer( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pBuffer ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Buffer buffer; + Result result = static_cast( d.vkCreateBuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &buffer ) ) ); + return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBuffer" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Buffer buffer; + Result result = static_cast( d.vkCreateBuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &buffer ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d) const + { + return static_cast( d.vkCreateBufferView( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pView ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + BufferView view; + Result result = static_cast( d.vkCreateBufferView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); + return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferView" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + BufferView view; + Result result = static_cast( d.vkCreateBufferView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferViewUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d) const + { + return static_cast( d.vkCreateImage( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pImage ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createImage( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Image image; + Result result = static_cast( d.vkCreateImage( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &image ) ) ); + return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImage" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Image image; + Result result = static_cast( d.vkCreateImage( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &image ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Image image, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d) const + { + d.vkGetImageSubresourceLayout( m_device, static_cast( image ), reinterpret_cast( pSubresource ), reinterpret_cast( pLayout ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d ) const + { + SubresourceLayout layout; + d.vkGetImageSubresourceLayout( m_device, static_cast( image ), reinterpret_cast( &subresource ), reinterpret_cast( &layout ) ); + return layout; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d) const + { + return static_cast( d.vkCreateImageView( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pView ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + ImageView view; + Result result = static_cast( d.vkCreateImageView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); + return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageView" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + ImageView view; + Result result = static_cast( d.vkCreateImageView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageViewUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d) const + { + return static_cast( d.vkCreateShaderModule( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pShaderModule ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + ShaderModule shaderModule; + Result result = static_cast( d.vkCreateShaderModule( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shaderModule ) ) ); + return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModule" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + ShaderModule shaderModule; + Result result = static_cast( d.vkCreateShaderModule( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shaderModule ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModuleUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d) const + { + return static_cast( d.vkCreatePipelineCache( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelineCache ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + PipelineCache pipelineCache; + Result result = static_cast( d.vkCreatePipelineCache( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineCache ) ) ); + return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCache" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + PipelineCache pipelineCache; + Result result = static_cast( d.vkCreatePipelineCache( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineCache ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCacheUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const + { + return static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), pDataSize, pData ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d ) const + { + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + data.resize( dataSize ); + return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d) const + { + return static_cast( d.vkMergePipelineCaches( m_device, static_cast( dstCache ), srcCacheCount, reinterpret_cast( pSrcCaches ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy srcCaches, Dispatch const &d ) const + { + Result result = static_cast( d.vkMergePipelineCaches( m_device, static_cast( dstCache ), srcCaches.size() , reinterpret_cast( srcCaches.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergePipelineCaches" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const + { + return static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" ); + } + template + VULKAN_HPP_INLINE ResultValueType::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Pipeline pipeline; + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); + return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipeline" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); + std::vector pipelines; + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Result result = static_cast(d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); + + ObjectDestroy deleter( *this, allocator ); + for ( size_t i=0 ; i + VULKAN_HPP_INLINE ResultValueType::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Pipeline pipeline; + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelineUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const + { + return static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" ); + } + template + VULKAN_HPP_INLINE ResultValueType::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Pipeline pipeline; + Result result = static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); + return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipeline" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); + std::vector pipelines; + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); + Result result = static_cast(d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); + + ObjectDestroy deleter( *this, allocator ); + for ( size_t i=0 ; i + VULKAN_HPP_INLINE ResultValueType::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Pipeline pipeline; + Result result = static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelineUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d) const + { + return static_cast( d.vkCreatePipelineLayout( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelineLayout ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + PipelineLayout pipelineLayout; + Result result = static_cast( d.vkCreatePipelineLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineLayout ) ) ); + return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayout" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + PipelineLayout pipelineLayout; + Result result = static_cast( d.vkCreatePipelineLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineLayout ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayoutUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d) const + { + return static_cast( d.vkCreateSampler( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSampler ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Sampler sampler; + Result result = static_cast( d.vkCreateSampler( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &sampler ) ) ); + return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSampler" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Sampler sampler; + Result result = static_cast( d.vkCreateSampler( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &sampler ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d) const + { + return static_cast( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSetLayout ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorSetLayout setLayout; + Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &setLayout ) ) ); + return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayout" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorSetLayout setLayout; + Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &setLayout ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayoutUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d) const + { + return static_cast( d.vkCreateDescriptorPool( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDescriptorPool ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorPool descriptorPool; + Result result = static_cast( d.vkCreateDescriptorPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorPool ) ) ); + return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPool" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorPool descriptorPool; + Result result = static_cast( d.vkCreateDescriptorPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorPool ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPoolUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d) const + { + return static_cast( d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d ) const + { + Result result = static_cast( d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetDescriptorPool" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d) const + { + return static_cast( d.vkAllocateDescriptorSets( m_device, reinterpret_cast( pAllocateInfo ), reinterpret_cast( pDescriptorSets ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const + { + std::vector descriptorSets( allocateInfo.descriptorSetCount ); + Result result = static_cast( d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); + return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const + { + static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueDescriptorSet ), "DescriptorSet is greater than UniqueDescriptorSet!" ); + std::vector descriptorSets; + descriptorSets.reserve( allocateInfo.descriptorSetCount ); + DescriptorSet* buffer = reinterpret_cast( reinterpret_cast( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueDescriptorSet ) - sizeof( DescriptorSet ) ) ); + Result result = static_cast(d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); + + PoolFree deleter( *this, allocateInfo.descriptorPool ); + for ( size_t i=0 ; i + VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const + { + return static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSetCount, reinterpret_cast( pDescriptorSets ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d ) const + { + Result result = static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSets.size() , reinterpret_cast( descriptorSets.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::freeDescriptorSets" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const + { + return static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSetCount, reinterpret_cast( pDescriptorSets ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::free( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d ) const + { + Result result = static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSets.size() , reinterpret_cast( descriptorSets.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::free" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const + { + d.vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast( pDescriptorCopies ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy descriptorWrites, ArrayProxy descriptorCopies, Dispatch const &d ) const + { + d.vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast( descriptorCopies.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d) const + { + return static_cast( d.vkCreateFramebuffer( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFramebuffer ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Framebuffer framebuffer; + Result result = static_cast( d.vkCreateFramebuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &framebuffer ) ) ); + return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebuffer" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Framebuffer framebuffer; + Result result = static_cast( d.vkCreateFramebuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &framebuffer ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebufferUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const + { + return static_cast( d.vkCreateRenderPass( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pRenderPass ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ) ); + return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPassUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d) const + { + d.vkGetRenderAreaGranularity( m_device, static_cast( renderPass ), reinterpret_cast( pGranularity ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d ) const + { + Extent2D granularity; + d.vkGetRenderAreaGranularity( m_device, static_cast( renderPass ), reinterpret_cast( &granularity ) ); + return granularity; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d) const + { + return static_cast( d.vkCreateCommandPool( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pCommandPool ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + CommandPool commandPool; + Result result = static_cast( d.vkCreateCommandPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &commandPool ) ) ); + return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPool" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + CommandPool commandPool; + Result result = static_cast( d.vkCreateCommandPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &commandPool ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPoolUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const + { + return static_cast( d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d ) const + { + Result result = static_cast( d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetCommandPool" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const + { + return static_cast( d.vkAllocateCommandBuffers( m_device, reinterpret_cast( pAllocateInfo ), reinterpret_cast( pCommandBuffers ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const + { + std::vector commandBuffers( allocateInfo.commandBufferCount ); + Result result = static_cast( d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); + return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const + { + static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueCommandBuffer ), "CommandBuffer is greater than UniqueCommandBuffer!" ); + std::vector commandBuffers; + commandBuffers.reserve( allocateInfo.commandBufferCount ); + CommandBuffer* buffer = reinterpret_cast( reinterpret_cast( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueCommandBuffer ) - sizeof( CommandBuffer ) ) ); + Result result = static_cast(d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); + + PoolFree deleter( *this, allocateInfo.commandPool ); + for ( size_t i=0 ; i + VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const + { + d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d ) const + { + d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBuffers.size() , reinterpret_cast( commandBuffers.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const + { + d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d ) const + { + d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBuffers.size() , reinterpret_cast( commandBuffers.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d) const + { + return static_cast( d.vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pSwapchains ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + std::vector swapchains( createInfos.size() ); + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( swapchains.data() ) ) ); + return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" ); + } + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); + return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueSwapchainKHR ), "SwapchainKHR is greater than UniqueSwapchainKHR!" ); + std::vector swapchainKHRs; + swapchainKHRs.reserve( createInfos.size() ); + SwapchainKHR* buffer = reinterpret_cast( reinterpret_cast( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueSwapchainKHR ) - sizeof( SwapchainKHR ) ) ); + Result result = static_cast(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); + + ObjectDestroy deleter( *this, allocator ); + for ( size_t i=0 ; i + VULKAN_HPP_INLINE ResultValueType::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d) const + { + return static_cast( d.vkCreateSwapchainKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSwapchain ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSwapchainKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); + return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSwapchainKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d) const + { + return static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), pSwapchainImageCount, reinterpret_cast( pSwapchainImages ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d ) const + { + std::vector swapchainImages; + uint32_t swapchainImageCount; + Result result; + do + { + result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && swapchainImageCount ) + { + swapchainImages.resize( swapchainImageCount ); + result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); + swapchainImages.resize( swapchainImageCount ); + return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d) const + { + return static_cast( d.vkAcquireNextImageKHR( m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), pImageIndex ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValue Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d ) const + { + uint32_t imageIndex; + Result result = static_cast( d.vkAcquireNextImageKHR( m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), &imageIndex ) ); + return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const + { + return static_cast( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( pNameInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectNameEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const + { + return static_cast( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( pTagInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectTagEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_NV + template + VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const + { + return static_cast( d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), pHandle ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const + { + HANDLE handle; + Result result = static_cast( d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); + return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleNV" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_NV*/ + + template + VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const + { + return static_cast( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pIndirectCommandsLayout ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + { + IndirectCommandsLayoutNVX indirectCommandsLayout; + Result result = static_cast( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &indirectCommandsLayout ) ) ); + return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVX" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + { + IndirectCommandsLayoutNVX indirectCommandsLayout; + Result result = static_cast( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &indirectCommandsLayout ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVXUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d) const + { + return static_cast( d.vkCreateObjectTableNVX( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pObjectTable ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + { + ObjectTableNVX objectTable; + Result result = static_cast( d.vkCreateObjectTableNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &objectTable ) ) ); + return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVX" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const + { + ObjectTableNVX objectTable; + Result result = static_cast( d.vkCreateObjectTableNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &objectTable ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVXUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const + { + return static_cast( d.vkRegisterObjectsNVX( m_device, static_cast( objectTable ), objectCount, reinterpret_cast( ppObjectTableEntries ), pObjectIndices ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy pObjectTableEntries, ArrayProxy objectIndices, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( pObjectTableEntries.size() == objectIndices.size() ); +#else + if ( pObjectTableEntries.size() != objectIndices.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" ); + } +#endif // VULKAN_HPP_NO_EXCEPTIONS + Result result = static_cast( d.vkRegisterObjectsNVX( m_device, static_cast( objectTable ), pObjectTableEntries.size() , reinterpret_cast( pObjectTableEntries.data() ), objectIndices.data() ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::registerObjectsNVX" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const + { + return static_cast( d.vkUnregisterObjectsNVX( m_device, static_cast( objectTable ), objectCount, reinterpret_cast( pObjectEntryTypes ), pObjectIndices ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy objectEntryTypes, ArrayProxy objectIndices, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( objectEntryTypes.size() == objectIndices.size() ); +#else + if ( objectEntryTypes.size() != objectIndices.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" ); + } +#endif // VULKAN_HPP_NO_EXCEPTIONS + Result result = static_cast( d.vkUnregisterObjectsNVX( m_device, static_cast( objectTable ), objectEntryTypes.size() , reinterpret_cast( objectEntryTypes.data() ), objectIndices.data() ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::unregisterObjectsNVX" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const + { + d.vkTrimCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ); + } +#else + template + VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const + { + d.vkTrimCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const + { + d.vkTrimCommandPoolKHR( m_device, static_cast( commandPool ), static_cast( flags ) ); + } +#else + template + VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const + { + d.vkTrimCommandPoolKHR( m_device, static_cast( commandPool ), static_cast( flags ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const + { + return static_cast( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const + { + HANDLE handle; + Result result = static_cast( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const + { + return static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( pMemoryWin32HandleProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const + { + MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; + Result result = static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( &memoryWin32HandleProperties ) ) ); + return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandlePropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template + VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const + { + return static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d ) const + { + int fd; + Result result = static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const + { + return static_cast( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( pMemoryFdProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const + { + MemoryFdPropertiesKHR memoryFdProperties; + Result result = static_cast( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); + return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdPropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const + { + return static_cast( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const + { + HANDLE handle; + Result result = static_cast( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const + { + return static_cast( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template + VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const + { + return static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d ) const + { + int fd; + Result result = static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const + { + return static_cast( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( pImportSemaphoreFdInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const + { + return static_cast( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const + { + HANDLE handle; + Result result = static_cast( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const + { + return static_cast( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( pImportFenceWin32HandleInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template + VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const + { + return static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d ) const + { + int fd; + Result result = static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const + { + return static_cast( d.vkImportFenceFdKHR( m_device, reinterpret_cast( pImportFenceFdInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const + { + return static_cast( d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( pDisplayPowerInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( &displayPowerInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::displayPowerControlEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const + { + return static_cast( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast( pDeviceEventInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFence ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator, Dispatch const &d ) const + { + Fence fence; + Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast( &deviceEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); + return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const + { + return static_cast( d.vkRegisterDisplayEventEXT( m_device, static_cast( display ), reinterpret_cast( pDisplayEventInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFence ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator, Dispatch const &d ) const + { + Fence fence; + Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, static_cast( display ), reinterpret_cast( &displayEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); + return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const + { + return static_cast( d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), pCounterValue ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const + { + uint64_t counterValue; + Result result = static_cast( d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), &counterValue ) ); + return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainCounterEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const + { + d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const + { + PeerMemoryFeatureFlags peerMemoryFeatures; + d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); + return peerMemoryFeatures; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const + { + d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const + { + PeerMemoryFeatureFlags peerMemoryFeatures; + d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); + return peerMemoryFeatures; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const + { + return static_cast( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::bindBufferMemory2( ArrayProxy bindInfos, Dispatch const &d ) const + { + Result result = static_cast( d.vkBindBufferMemory2( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const + { + return static_cast( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::bindBufferMemory2KHR( ArrayProxy bindInfos, Dispatch const &d ) const + { + Result result = static_cast( d.vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const + { + return static_cast( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::bindImageMemory2( ArrayProxy bindInfos, Dispatch const &d ) const + { + Result result = static_cast( d.vkBindImageMemory2( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const + { + return static_cast( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::bindImageMemory2KHR( ArrayProxy bindInfos, Dispatch const &d ) const + { + Result result = static_cast( d.vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const + { + return static_cast( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( pDeviceGroupPresentCapabilities ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const + { + DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; + Result result = static_cast( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); + return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupPresentCapabilitiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const + { + return static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast( surface ), reinterpret_cast( pModes ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const + { + DeviceGroupPresentModeFlagsKHR modes; + Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast( surface ), reinterpret_cast( &modes ) ) ); + return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const + { + return static_cast( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( pAcquireInfo ), pImageIndex ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValue Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d ) const + { + uint32_t imageIndex; + Result result = static_cast( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( &acquireInfo ), &imageIndex ) ); + return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImage2KHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const + { + return static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDescriptorUpdateTemplate ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); + return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplate" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const + { + return static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDescriptorUpdateTemplate ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); + return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const + { + d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); + } +#else + template + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const + { + d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const + { + d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); + } +#else + template + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const + { + d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d) const + { + d.vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast( pSwapchains ), reinterpret_cast( pMetadata ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy swapchains, ArrayProxy metadata, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); +#else + if ( swapchains.size() != metadata.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); + } +#endif // VULKAN_HPP_NO_EXCEPTIONS + d.vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast( swapchains.data() ), reinterpret_cast( metadata.data() ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d) const + { + return static_cast( d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); + } +#else + template + VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d ) const + { + Result result = static_cast( d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const + { + return static_cast( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast( swapchain ), reinterpret_cast( pDisplayTimingProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const + { + RefreshCycleDurationGOOGLE displayTimingProperties; + Result result = static_cast( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast( swapchain ), reinterpret_cast( &displayTimingProperties ) ) ); + return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getRefreshCycleDurationGOOGLE" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const + { + return static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), pPresentationTimingCount, reinterpret_cast( pPresentationTimings ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const + { + std::vector presentationTimings; + uint32_t presentationTimingCount; + Result result; + do + { + result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentationTimingCount ) + { + presentationTimings.resize( presentationTimingCount ); + result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, reinterpret_cast( presentationTimings.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); + presentationTimings.resize( presentationTimingCount ); + return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const + { + d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + MemoryRequirements2 memoryRequirements; + d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } + template + VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + StructureChain structureChain; + MemoryRequirements2& memoryRequirements = structureChain.template get(); + d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const + { + d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + MemoryRequirements2 memoryRequirements; + d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } + template + VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + StructureChain structureChain; + MemoryRequirements2& memoryRequirements = structureChain.template get(); + d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const + { + d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + MemoryRequirements2 memoryRequirements; + d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } + template + VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + StructureChain structureChain; + MemoryRequirements2& memoryRequirements = structureChain.template get(); + d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const + { + d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + MemoryRequirements2 memoryRequirements; + d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } + template + VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + StructureChain structureChain; + MemoryRequirements2& memoryRequirements = structureChain.template get(); + d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const + { + d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); + return sparseMemoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const + { + d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const + { + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); + return sparseMemoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const + { + return static_cast( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pYcbcrConversion ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); + return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversion" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const + { + return static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pYcbcrConversion ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); + return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast( ycbcrConversion ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast( ycbcrConversion ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d) const + { + d.vkGetDeviceQueue2( m_device, reinterpret_cast( pQueueInfo ), reinterpret_cast( pQueue ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const + { + Queue queue; + d.vkGetDeviceQueue2( m_device, reinterpret_cast( &queueInfo ), reinterpret_cast( &queue ) ); + return queue; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d) const + { + return static_cast( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pValidationCache ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + ValidationCacheEXT validationCache; + Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &validationCache ) ) ); + return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXT" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + ValidationCacheEXT validationCache; + Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &validationCache ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXTUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const + { + return static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), pDataSize, pData ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d ) const + { + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + data.resize( dataSize ); + return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d) const + { + return static_cast( d.vkMergeValidationCachesEXT( m_device, static_cast( dstCache ), srcCacheCount, reinterpret_cast( pSrcCaches ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy srcCaches, Dispatch const &d ) const + { + Result result = static_cast( d.vkMergeValidationCachesEXT( m_device, static_cast( dstCache ), srcCaches.size() , reinterpret_cast( srcCaches.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergeValidationCachesEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const + { + d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pSupport ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const + { + DescriptorSetLayoutSupport support; + d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return support; + } + template + VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const + { + StructureChain structureChain; + DescriptorSetLayoutSupport& support = structureChain.template get(); + d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const + { + d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pSupport ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const + { + DescriptorSetLayoutSupport support; + d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return support; + } + template + VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const + { + StructureChain structureChain; + DescriptorSetLayoutSupport& support = structureChain.template get(); + d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const + { + return static_cast( d.vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), pInfoSize, pInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d ) const + { + std::vector info; + size_t infoSize; + Result result; + do + { + result = static_cast( d.vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), &infoSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && infoSize ) + { + info.resize( infoSize ); + result = static_cast( d.vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), &infoSize, reinterpret_cast( info.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( infoSize <= info.size() ); + info.resize( infoSize ); + return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const + { + return static_cast( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( pNameInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setDebugUtilsObjectNameEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d) const + { + return static_cast( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( pTagInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d ) const + { + Result result = static_cast( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setDebugUtilsObjectTagEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const + { + return static_cast( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast( handleType ), pHostPointer, reinterpret_cast( pMemoryHostPointerProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const + { + MemoryHostPointerPropertiesEXT memoryHostPointerProperties; + Result result = static_cast( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast( handleType ), pHostPointer, reinterpret_cast( &memoryHostPointerProperties ) ) ); + return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryHostPointerPropertiesEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template + VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const + { + AndroidHardwareBufferPropertiesANDROID properties; + Result result = static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast( &properties ) ) ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const + { + StructureChain structureChain; + AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get(); + Result result = static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast( &properties ) ) ); + return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template + VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const + { + return static_cast( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( pInfo ), pBuffer ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d ) const + { + struct AHardwareBuffer* buffer; + Result result = static_cast( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( &info ), &buffer ) ); + return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryAndroidHardwareBufferANDROID" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueDevice = UniqueHandle; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + class PhysicalDevice + { + public: + VULKAN_HPP_CONSTEXPR PhysicalDevice() + : m_physicalDevice(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) + : m_physicalDevice(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) + : m_physicalDevice( physicalDevice ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) + { + m_physicalDevice = physicalDevice; + return *this; + } +#endif + + PhysicalDevice & operator=( std::nullptr_t ) + { + m_physicalDevice = VK_NULL_HANDLE; + return *this; + } + + bool operator==( PhysicalDevice const & rhs ) const + { + return m_physicalDevice == rhs.m_physicalDevice; + } + + bool operator!=(PhysicalDevice const & rhs ) const + { + return m_physicalDevice != rhs.m_physicalDevice; + } + + bool operator<(PhysicalDevice const & rhs ) const + { + return m_physicalDevice < rhs.m_physicalDevice; + } + + template + void getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + FormatProperties getFormatProperties( Format format, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDevice( const DeviceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateDeviceLayerProperties(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateDeviceExtensionProperties( Optional layerName = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPropertiesKHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPlanePropertiesKHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + template + Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + + template + Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + template + Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d = Dispatch() ) const; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + template + Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + template + Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + + template + Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const; + template + StructureChain getFeatures2(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const; + template + StructureChain getFeatures2KHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const; + template + StructureChain getProperties2(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const; + template + StructureChain getProperties2KHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; + template + typename ResultValueType>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; + template + typename ResultValueType>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + template + Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + template + Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + + template + Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; + template + typename ResultValueType>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayProperties2KHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPlaneProperties2KHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const + { + return m_physicalDevice; + } + + explicit operator bool() const + { + return m_physicalDevice != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_physicalDevice == VK_NULL_HANDLE; + } + + private: + VkPhysicalDevice m_physicalDevice; + }; + + static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); + + template + VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast( pProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const + { + PhysicalDeviceProperties properties; + d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast( &properties ) ); + return properties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties(Dispatch const &d ) const + { + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + return queueFamilyProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast( pMemoryProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const + { + PhysicalDeviceMemoryProperties memoryProperties; + d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return memoryProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const + { + d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast( pFeatures ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const + { + PhysicalDeviceFeatures features; + d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast( &features ) ); + return features; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast( format ), reinterpret_cast( pFormatProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const &d ) const + { + FormatProperties formatProperties; + d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return formatProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), reinterpret_cast( pImageFormatProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d ) const + { + ImageFormatProperties imageFormatProperties; + Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), reinterpret_cast( &imageFormatProperties ) ) ); + return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d) const + { + return static_cast( d.vkCreateDevice( m_physicalDevice, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDevice ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Device device; + Result result = static_cast( d.vkCreateDevice( m_physicalDevice, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &device ) ) ); + return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDevice" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const + { + Device device; + Result result = static_cast( d.vkCreateDevice( m_physicalDevice, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &device ) ) ); + + ObjectDestroy deleter( allocator ); + return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDeviceUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) const + { + return static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceLayerProperties(Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) const + { + return static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), pPropertyCount, reinterpret_cast( pProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), &propertyCount, nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), &propertyCount, reinterpret_cast( properties.data() ) ); + return properties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPropertiesKHR(Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d) const + { + return static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast( pDisplays ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d ) const + { + std::vector displays; + uint32_t displayCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && displayCount ) + { + displays.resize( displayCount ); + result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( displayCount <= displays.size() ); + displays.resize( displayCount ); + return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d) const + { + return static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast( display ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMode ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + DisplayModeKHR mode; + Result result = static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast( display ), reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &mode ) ) ); + return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDisplayModeKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const + { + return static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( pCapabilities ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const + { + DisplayPlaneCapabilitiesKHR capabilities; + Result result = static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( &capabilities ) ) ); + return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d) const + { + return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d ) const + { + return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast( surface ), pSupported ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d ) const + { + Bool32 supported; + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast( surface ), &supported ) ); + return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast( surface ), reinterpret_cast( pSurfaceCapabilities ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d ) const + { + SurfaceCapabilitiesKHR surfaceCapabilities; + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); + return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilitiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d ) const + { + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + surfaceFormats.resize( surfaceFormatCount ); + return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), pPresentModeCount, reinterpret_cast( pPresentModes ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const + { + std::vector presentModes; + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + presentModes.resize( presentModeCount ); + return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d) const + { + return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d ) const + { + return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d) const + { + return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ); + } +#else + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d ) const + { + return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d) const + { + return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d ) const + { + return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d) const + { + return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d ) const + { + return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), static_cast( externalHandleType ), reinterpret_cast( pExternalImageFormatProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const + { + ExternalImageFormatPropertiesNV externalImageFormatProperties; + Result result = static_cast( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), static_cast( externalHandleType ), reinterpret_cast( &externalImageFormatProperties ) ) ); + return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getExternalImageFormatPropertiesNV" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const + { + d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast( pFeatures ), reinterpret_cast( pLimits ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const + { + DeviceGeneratedCommandsLimitsNVX limits; + d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast( &features ), reinterpret_cast( &limits ) ); + return limits; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const + { + d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( pFeatures ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const + { + PhysicalDeviceFeatures2 features; + d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); + return features; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2(Dispatch const &d ) const + { + StructureChain structureChain; + PhysicalDeviceFeatures2& features = structureChain.template get(); + d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const + { + d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( pFeatures ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const + { + PhysicalDeviceFeatures2 features; + d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); + return features; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const + { + StructureChain structureChain; + PhysicalDeviceFeatures2& features = structureChain.template get(); + d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( pProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const + { + PhysicalDeviceProperties2 properties; + d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); + return properties; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2(Dispatch const &d ) const + { + StructureChain structureChain; + PhysicalDeviceProperties2& properties = structureChain.template get(); + d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( pProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const + { + PhysicalDeviceProperties2 properties; + d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); + return properties; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2KHR(Dispatch const &d ) const + { + StructureChain structureChain; + PhysicalDeviceProperties2& properties = structureChain.template get(); + d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( pFormatProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const + { + FormatProperties2 formatProperties; + d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return formatProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast( format ), reinterpret_cast( pFormatProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const + { + FormatProperties2 formatProperties; + d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return formatProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast( pImageFormatInfo ), reinterpret_cast( pImageFormatProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const + { + ImageFormatProperties2 imageFormatProperties; + Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); + return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const + { + StructureChain structureChain; + ImageFormatProperties2& imageFormatProperties = structureChain.template get(); + Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); + return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( pImageFormatInfo ), reinterpret_cast( pImageFormatProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const + { + ImageFormatProperties2 imageFormatProperties; + Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); + return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const + { + StructureChain structureChain; + ImageFormatProperties2& imageFormatProperties = structureChain.template get(); + Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); + return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d ) const + { + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + return queueFamilyProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d ) const + { + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + return queueFamilyProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( pMemoryProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const + { + PhysicalDeviceMemoryProperties2 memoryProperties; + d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return memoryProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( pMemoryProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const + { + PhysicalDeviceMemoryProperties2 memoryProperties; + d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return memoryProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast( pFormatInfo ), pPropertyCount, reinterpret_cast( pProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, reinterpret_cast( properties.data() ) ); + return properties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( pFormatInfo ), pPropertyCount, reinterpret_cast( pProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, reinterpret_cast( properties.data() ) ); + return properties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const + { + ExternalBufferProperties externalBufferProperties; + d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); + return externalBufferProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const + { + ExternalBufferProperties externalBufferProperties; + d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); + return externalBufferProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const + { + ExternalSemaphoreProperties externalSemaphoreProperties; + d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); + return externalSemaphoreProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const + { + ExternalSemaphoreProperties externalSemaphoreProperties; + d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); + return externalSemaphoreProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast( pExternalFenceInfo ), reinterpret_cast( pExternalFenceProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const + { + ExternalFenceProperties externalFenceProperties; + d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); + return externalFenceProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalFenceInfo ), reinterpret_cast( pExternalFenceProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const + { + ExternalFenceProperties externalFenceProperties; + d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); + return externalFenceProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d) const + { + return static_cast( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d ) const + { + Result result = static_cast( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::releaseDisplayEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + template + VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d) const + { + return static_cast( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast( display ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d ) const + { + Display dpy; + Result result = static_cast( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast( display ) ) ); + return createResultValue( result, dpy, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::acquireXlibDisplayEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + template + VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d) const + { + return static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast( pDisplay ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const + { + DisplayKHR display; + Result result = static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); + return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getRandROutputDisplayEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast( surface ), reinterpret_cast( pSurfaceCapabilities ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d ) const + { + SurfaceCapabilities2EXT surfaceCapabilities; + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); + return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2EXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), pRectCount, reinterpret_cast( pRects ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d ) const + { + std::vector rects; + uint32_t rectCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && rectCount ) + { + rects.resize( rectCount ); + result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( rectCount <= rects.size() ); + rects.resize( rectCount ); + return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const + { + d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast( samples ), reinterpret_cast( pMultisampleProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d ) const + { + MultisamplePropertiesEXT multisampleProperties; + d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast( samples ), reinterpret_cast( &multisampleProperties ) ); + return multisampleProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( pSurfaceInfo ), reinterpret_cast( pSurfaceCapabilities ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const + { + SurfaceCapabilities2KHR surfaceCapabilities; + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &surfaceCapabilities ) ) ); + return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const + { + StructureChain structureChain; + SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get(); + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &surfaceCapabilities ) ) ); + return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const + { + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + surfaceFormats.resize( surfaceFormatCount ); + return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayProperties2KHR(Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const + { + return static_cast( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast( pDisplayPlaneInfo ), reinterpret_cast( pCapabilities ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const + { + DisplayPlaneCapabilities2KHR capabilities; + Result result = static_cast( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast( &displayPlaneInfo ), reinterpret_cast( &capabilities ) ) ); + return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + struct CmdProcessCommandsInfoNVX + { + CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), + IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), + uint32_t indirectCommandsTokenCount_ = 0, + const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, + uint32_t maxSequencesCount_ = 0, + CommandBuffer targetCommandBuffer_ = CommandBuffer(), + Buffer sequencesCountBuffer_ = Buffer(), + DeviceSize sequencesCountOffset_ = 0, + Buffer sequencesIndexBuffer_ = Buffer(), + DeviceSize sequencesIndexOffset_ = 0 ) + : objectTable( objectTable_ ) + , indirectCommandsLayout( indirectCommandsLayout_ ) + , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) + , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) + , maxSequencesCount( maxSequencesCount_ ) + , targetCommandBuffer( targetCommandBuffer_ ) + , sequencesCountBuffer( sequencesCountBuffer_ ) + , sequencesCountOffset( sequencesCountOffset_ ) + , sequencesIndexBuffer( sequencesIndexBuffer_ ) + , sequencesIndexOffset( sequencesIndexOffset_ ) + { + } + + CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); + } + + CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); + return *this; + } + CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CmdProcessCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ ) + { + objectTable = objectTable_; + return *this; + } + + CmdProcessCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ ) + { + indirectCommandsLayout = indirectCommandsLayout_; + return *this; + } + + CmdProcessCommandsInfoNVX& setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ ) + { + indirectCommandsTokenCount = indirectCommandsTokenCount_; + return *this; + } + + CmdProcessCommandsInfoNVX& setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ ) + { + pIndirectCommandsTokens = pIndirectCommandsTokens_; + return *this; + } + + CmdProcessCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ ) + { + maxSequencesCount = maxSequencesCount_; + return *this; + } + + CmdProcessCommandsInfoNVX& setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ ) + { + targetCommandBuffer = targetCommandBuffer_; + return *this; + } + + CmdProcessCommandsInfoNVX& setSequencesCountBuffer( Buffer sequencesCountBuffer_ ) + { + sequencesCountBuffer = sequencesCountBuffer_; + return *this; + } + + CmdProcessCommandsInfoNVX& setSequencesCountOffset( DeviceSize sequencesCountOffset_ ) + { + sequencesCountOffset = sequencesCountOffset_; + return *this; + } + + CmdProcessCommandsInfoNVX& setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ ) + { + sequencesIndexBuffer = sequencesIndexBuffer_; + return *this; + } + + CmdProcessCommandsInfoNVX& setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ ) + { + sequencesIndexOffset = sequencesIndexOffset_; + return *this; + } + + operator const VkCmdProcessCommandsInfoNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectTable == rhs.objectTable ) + && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) + && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount ) + && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens ) + && ( maxSequencesCount == rhs.maxSequencesCount ) + && ( targetCommandBuffer == rhs.targetCommandBuffer ) + && ( sequencesCountBuffer == rhs.sequencesCountBuffer ) + && ( sequencesCountOffset == rhs.sequencesCountOffset ) + && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) + && ( sequencesIndexOffset == rhs.sequencesIndexOffset ); + } + + bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; + + public: + const void* pNext = nullptr; + ObjectTableNVX objectTable; + IndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t indirectCommandsTokenCount; + const IndirectCommandsTokenNVX* pIndirectCommandsTokens; + uint32_t maxSequencesCount; + CommandBuffer targetCommandBuffer; + Buffer sequencesCountBuffer; + DeviceSize sequencesCountOffset; + Buffer sequencesIndexBuffer; + DeviceSize sequencesIndexOffset; + }; + static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceGroupProperties + { + operator const VkPhysicalDeviceGroupProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceGroupProperties const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( physicalDeviceCount == rhs.physicalDeviceCount ) + && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( PhysicalDevice ) ) == 0 ) + && ( subsetAllocation == rhs.subsetAllocation ); + } + + bool operator!=( PhysicalDeviceGroupProperties const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceGroupProperties; + + public: + void* pNext = nullptr; + uint32_t physicalDeviceCount; + PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + Bool32 subsetAllocation; + }; + static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" ); + + using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + class Instance; + + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueDebugReportCallbackEXT = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueDebugUtilsMessengerEXT = UniqueHandle; + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueSurfaceKHR = UniqueHandle; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + class Instance + { + public: + VULKAN_HPP_CONSTEXPR Instance() + : m_instance(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) + : m_instance(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) + : m_instance( instance ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + Instance & operator=(VkInstance instance) + { + m_instance = instance; + return *this; + } +#endif + + Instance & operator=( std::nullptr_t ) + { + m_instance = VK_NULL_HANDLE; + return *this; + } + + bool operator==( Instance const & rhs ) const + { + return m_instance == rhs.m_instance; + } + + bool operator!=(Instance const & rhs ) const + { + return m_instance != rhs.m_instance; + } + + bool operator<(Instance const & rhs ) const + { + return m_instance < rhs.m_instance; + } + + template + void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumeratePhysicalDevices(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + template + Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + template + Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + template + Result createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + + template + void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroySurfaceKHR( SurfaceKHR surface, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( SurfaceKHR surface, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_VI_NN + template + Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + template + Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + template + Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + template + Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + + template + Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( DebugReportCallbackEXT callback, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumeratePhysicalDeviceGroups(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_IOS_MVK + template + Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + template + Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + template + Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( DebugUtilsMessengerEXT messenger, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const + { + return m_instance; + } + + explicit operator bool() const + { + return m_instance != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_instance == VK_NULL_HANDLE; + } + + private: + VkInstance m_instance; + }; + + static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); + + template + VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyInstance( m_instance, reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::destroy( Optional allocator, Dispatch const &d ) const + { + d.vkDestroyInstance( m_instance, reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d) const + { + return static_cast( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast( pPhysicalDevices ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDevices(Dispatch const &d ) const + { + std::vector physicalDevices; + uint32_t physicalDeviceCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceCount ) + { + physicalDevices.resize( physicalDeviceCount ); + result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); + physicalDevices.resize( physicalDeviceCount ); + return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char* pName, Dispatch const &d) const + { + return d.vkGetInstanceProcAddr( m_instance, pName ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name, Dispatch const &d ) const + { + return d.vkGetInstanceProcAddr( m_instance, name.c_str() ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + template + VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + template + VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + template + VULKAN_HPP_INLINE Result Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + + template + VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional allocator, Dispatch const &d ) const + { + d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_VI_NN + template + VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNN" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNNUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + template + VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + template + VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + template + VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + + template + VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d) const + { + return static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pCallback ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + DebugReportCallbackEXT callback; + Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &callback ) ) ); + return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXT" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + DebugReportCallbackEXT callback; + Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &callback ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXTUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const + { + d.vkDebugReportMessageEXT( m_instance, static_cast( flags ), static_cast( objectType ), object, location, messageCode, pLayerPrefix, pMessage ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() ); +#else + if ( layerPrefix.size() != message.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" ); + } +#endif // VULKAN_HPP_NO_EXCEPTIONS + d.vkDebugReportMessageEXT( m_instance, static_cast( flags ), static_cast( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const + { + return static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroups(Dispatch const &d ) const + { + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const + { + return static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroupsKHR(Dispatch const &d ) const + { + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_IOS_MVK + template + VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVK" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVKUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + template + VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVK" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVKUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + template + VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const + { + return static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMessenger ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + DebugUtilsMessengerEXT messenger; + Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &messenger ) ) ); + return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXT" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const + { + DebugUtilsMessengerEXT messenger; + Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &messenger ) ) ); + + ObjectDestroy deleter( *this, allocator ); + return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXTUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d) const + { + d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast( messageSeverity ), static_cast( messageTypes ), reinterpret_cast( pCallbackData ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d ) const + { + d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast( messageSeverity ), static_cast( messageTypes ), reinterpret_cast( &callbackData ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + struct DeviceGroupDeviceCreateInfo + { + DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0, + const PhysicalDevice* pPhysicalDevices_ = nullptr ) + : physicalDeviceCount( physicalDeviceCount_ ) + , pPhysicalDevices( pPhysicalDevices_ ) + { + } + + DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) ); + } + + DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) ); + return *this; + } + DeviceGroupDeviceCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceGroupDeviceCreateInfo& setPhysicalDeviceCount( uint32_t physicalDeviceCount_ ) + { + physicalDeviceCount = physicalDeviceCount_; + return *this; + } + + DeviceGroupDeviceCreateInfo& setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ ) + { + pPhysicalDevices = pPhysicalDevices_; + return *this; + } + + operator const VkDeviceGroupDeviceCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DeviceGroupDeviceCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( physicalDeviceCount == rhs.physicalDeviceCount ) + && ( pPhysicalDevices == rhs.pPhysicalDevices ); + } + + bool operator!=( DeviceGroupDeviceCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; + + public: + const void* pNext = nullptr; + uint32_t physicalDeviceCount; + const PhysicalDevice* pPhysicalDevices; + }; + static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" ); + + using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + + template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; + using UniqueInstance = UniqueHandle; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + template + Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d = Dispatch() ); +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createInstance( const InstanceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ); +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + ResultValueType::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ); +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d) + { + return static_cast( d.vkCreateInstance( reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pInstance ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type createInstance( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) + { + Instance instance; + Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &instance ) ) ); + return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstance" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE ResultValueType::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) + { + Instance instance; + Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &instance ) ) ); + + ObjectDestroy deleter( allocator ); + return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstanceUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + struct BaseOutStructure + { + BaseOutStructure( ) + { + } + + BaseOutStructure( VkBaseOutStructure const & rhs ) + { + memcpy( this, &rhs, sizeof( BaseOutStructure ) ); + } + + BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) + { + memcpy( this, &rhs, sizeof( BaseOutStructure ) ); + return *this; + } + BaseOutStructure& setPNext( struct BaseOutStructure* pNext_ ) + { + pNext = pNext_; + return *this; + } + + operator const VkBaseOutStructure&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BaseOutStructure const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ); + } + + bool operator!=( BaseOutStructure const& rhs ) const + { + return !operator==( rhs ); + } + + StructureType sType; + struct BaseOutStructure* pNext = nullptr; + }; + static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" ); + + struct BaseInStructure + { + BaseInStructure( ) + { + } + + BaseInStructure( VkBaseInStructure const & rhs ) + { + memcpy( this, &rhs, sizeof( BaseInStructure ) ); + } + + BaseInStructure& operator=( VkBaseInStructure const & rhs ) + { + memcpy( this, &rhs, sizeof( BaseInStructure ) ); + return *this; + } + BaseInStructure& setPNext( const struct BaseInStructure* pNext_ ) + { + pNext = pNext_; + return *this; + } + + operator const VkBaseInStructure&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BaseInStructure const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ); + } + + bool operator!=( BaseInStructure const& rhs ) const + { + return !operator==( rhs ); + } + + StructureType sType; + const struct BaseInStructure* pNext = nullptr; + }; + static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); + + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_WIN32_NV + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_NV*/ +#ifdef VK_USE_PLATFORM_WIN32_NV + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_NV*/ + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_WIN32_NV + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_NV*/ + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(EventCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(EventCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(MemoryMapFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(MemoryMapFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagBitsKHR) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagsKHR) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagBitsKHR) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagsKHR) + { + return "{}"; + } + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagBitsKHR) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + +#ifdef VK_USE_PLATFORM_MIR_KHR + VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagsKHR) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + +#ifdef VK_USE_PLATFORM_VI_NN + VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_VI_NN + VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#ifdef VK_USE_PLATFORM_IOS_MVK + VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#ifdef VK_USE_PLATFORM_IOS_MVK + VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBits) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlags) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagBitsNV) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagsNV) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagsEXT) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagBitsNV) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagsNV) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagBitsNV) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagsNV) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagBitsEXT) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagsEXT) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagBitsEXT) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagsEXT) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCallbackDataFlagBitsEXT) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCallbackDataFlagsEXT) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagsEXT) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(ImageLayout value) + { + switch (value) + { + case ImageLayout::eUndefined: return "Undefined"; + case ImageLayout::eGeneral: return "General"; + case ImageLayout::eColorAttachmentOptimal: return "ColorAttachmentOptimal"; + case ImageLayout::eDepthStencilAttachmentOptimal: return "DepthStencilAttachmentOptimal"; + case ImageLayout::eDepthStencilReadOnlyOptimal: return "DepthStencilReadOnlyOptimal"; + case ImageLayout::eShaderReadOnlyOptimal: return "ShaderReadOnlyOptimal"; + case ImageLayout::eTransferSrcOptimal: return "TransferSrcOptimal"; + case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal"; + case ImageLayout::ePreinitialized: return "Preinitialized"; + case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal: return "DepthReadOnlyStencilAttachmentOptimal"; + case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal: return "DepthAttachmentStencilReadOnlyOptimal"; + case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR"; + case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(AttachmentLoadOp value) + { + switch (value) + { + case AttachmentLoadOp::eLoad: return "Load"; + case AttachmentLoadOp::eClear: return "Clear"; + case AttachmentLoadOp::eDontCare: return "DontCare"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(AttachmentStoreOp value) + { + switch (value) + { + case AttachmentStoreOp::eStore: return "Store"; + case AttachmentStoreOp::eDontCare: return "DontCare"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ImageType value) + { + switch (value) + { + case ImageType::e1D: return "1D"; + case ImageType::e2D: return "2D"; + case ImageType::e3D: return "3D"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ImageTiling value) + { + switch (value) + { + case ImageTiling::eOptimal: return "Optimal"; + case ImageTiling::eLinear: return "Linear"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ImageViewType value) + { + switch (value) + { + case ImageViewType::e1D: return "1D"; + case ImageViewType::e2D: return "2D"; + case ImageViewType::e3D: return "3D"; + case ImageViewType::eCube: return "Cube"; + case ImageViewType::e1DArray: return "1DArray"; + case ImageViewType::e2DArray: return "2DArray"; + case ImageViewType::eCubeArray: return "CubeArray"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CommandBufferLevel value) + { + switch (value) + { + case CommandBufferLevel::ePrimary: return "Primary"; + case CommandBufferLevel::eSecondary: return "Secondary"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ComponentSwizzle value) + { + switch (value) + { + case ComponentSwizzle::eIdentity: return "Identity"; + case ComponentSwizzle::eZero: return "Zero"; + case ComponentSwizzle::eOne: return "One"; + case ComponentSwizzle::eR: return "R"; + case ComponentSwizzle::eG: return "G"; + case ComponentSwizzle::eB: return "B"; + case ComponentSwizzle::eA: return "A"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorType value) + { + switch (value) + { + case DescriptorType::eSampler: return "Sampler"; + case DescriptorType::eCombinedImageSampler: return "CombinedImageSampler"; + case DescriptorType::eSampledImage: return "SampledImage"; + case DescriptorType::eStorageImage: return "StorageImage"; + case DescriptorType::eUniformTexelBuffer: return "UniformTexelBuffer"; + case DescriptorType::eStorageTexelBuffer: return "StorageTexelBuffer"; + case DescriptorType::eUniformBuffer: return "UniformBuffer"; + case DescriptorType::eStorageBuffer: return "StorageBuffer"; + case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic"; + case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic"; + case DescriptorType::eInputAttachment: return "InputAttachment"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueryType value) + { + switch (value) + { + case QueryType::eOcclusion: return "Occlusion"; + case QueryType::ePipelineStatistics: return "PipelineStatistics"; + case QueryType::eTimestamp: return "Timestamp"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(BorderColor value) + { + switch (value) + { + case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack"; + case BorderColor::eIntTransparentBlack: return "IntTransparentBlack"; + case BorderColor::eFloatOpaqueBlack: return "FloatOpaqueBlack"; + case BorderColor::eIntOpaqueBlack: return "IntOpaqueBlack"; + case BorderColor::eFloatOpaqueWhite: return "FloatOpaqueWhite"; + case BorderColor::eIntOpaqueWhite: return "IntOpaqueWhite"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PipelineBindPoint value) + { + switch (value) + { + case PipelineBindPoint::eGraphics: return "Graphics"; + case PipelineBindPoint::eCompute: return "Compute"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCacheHeaderVersion value) + { + switch (value) + { + case PipelineCacheHeaderVersion::eOne: return "One"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PrimitiveTopology value) + { + switch (value) + { + case PrimitiveTopology::ePointList: return "PointList"; + case PrimitiveTopology::eLineList: return "LineList"; + case PrimitiveTopology::eLineStrip: return "LineStrip"; + case PrimitiveTopology::eTriangleList: return "TriangleList"; + case PrimitiveTopology::eTriangleStrip: return "TriangleStrip"; + case PrimitiveTopology::eTriangleFan: return "TriangleFan"; + case PrimitiveTopology::eLineListWithAdjacency: return "LineListWithAdjacency"; + case PrimitiveTopology::eLineStripWithAdjacency: return "LineStripWithAdjacency"; + case PrimitiveTopology::eTriangleListWithAdjacency: return "TriangleListWithAdjacency"; + case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency"; + case PrimitiveTopology::ePatchList: return "PatchList"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SharingMode value) + { + switch (value) + { + case SharingMode::eExclusive: return "Exclusive"; + case SharingMode::eConcurrent: return "Concurrent"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(IndexType value) + { + switch (value) + { + case IndexType::eUint16: return "Uint16"; + case IndexType::eUint32: return "Uint32"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(Filter value) + { + switch (value) + { + case Filter::eNearest: return "Nearest"; + case Filter::eLinear: return "Linear"; + case Filter::eCubicIMG: return "CubicIMG"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SamplerMipmapMode value) + { + switch (value) + { + case SamplerMipmapMode::eNearest: return "Nearest"; + case SamplerMipmapMode::eLinear: return "Linear"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SamplerAddressMode value) + { + switch (value) + { + case SamplerAddressMode::eRepeat: return "Repeat"; + case SamplerAddressMode::eMirroredRepeat: return "MirroredRepeat"; + case SamplerAddressMode::eClampToEdge: return "ClampToEdge"; + case SamplerAddressMode::eClampToBorder: return "ClampToBorder"; + case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CompareOp value) + { + switch (value) + { + case CompareOp::eNever: return "Never"; + case CompareOp::eLess: return "Less"; + case CompareOp::eEqual: return "Equal"; + case CompareOp::eLessOrEqual: return "LessOrEqual"; + case CompareOp::eGreater: return "Greater"; + case CompareOp::eNotEqual: return "NotEqual"; + case CompareOp::eGreaterOrEqual: return "GreaterOrEqual"; + case CompareOp::eAlways: return "Always"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PolygonMode value) + { + switch (value) + { + case PolygonMode::eFill: return "Fill"; + case PolygonMode::eLine: return "Line"; + case PolygonMode::ePoint: return "Point"; + case PolygonMode::eFillRectangleNV: return "FillRectangleNV"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CullModeFlagBits value) + { + switch (value) + { + case CullModeFlagBits::eNone: return "None"; + case CullModeFlagBits::eFront: return "Front"; + case CullModeFlagBits::eBack: return "Back"; + case CullModeFlagBits::eFrontAndBack: return "FrontAndBack"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CullModeFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & CullModeFlagBits::eNone) result += "None | "; + if (value & CullModeFlagBits::eFront) result += "Front | "; + if (value & CullModeFlagBits::eBack) result += "Back | "; + if (value & CullModeFlagBits::eFrontAndBack) result += "FrontAndBack | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(FrontFace value) + { + switch (value) + { + case FrontFace::eCounterClockwise: return "CounterClockwise"; + case FrontFace::eClockwise: return "Clockwise"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(BlendFactor value) + { + switch (value) + { + case BlendFactor::eZero: return "Zero"; + case BlendFactor::eOne: return "One"; + case BlendFactor::eSrcColor: return "SrcColor"; + case BlendFactor::eOneMinusSrcColor: return "OneMinusSrcColor"; + case BlendFactor::eDstColor: return "DstColor"; + case BlendFactor::eOneMinusDstColor: return "OneMinusDstColor"; + case BlendFactor::eSrcAlpha: return "SrcAlpha"; + case BlendFactor::eOneMinusSrcAlpha: return "OneMinusSrcAlpha"; + case BlendFactor::eDstAlpha: return "DstAlpha"; + case BlendFactor::eOneMinusDstAlpha: return "OneMinusDstAlpha"; + case BlendFactor::eConstantColor: return "ConstantColor"; + case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor"; + case BlendFactor::eConstantAlpha: return "ConstantAlpha"; + case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha"; + case BlendFactor::eSrcAlphaSaturate: return "SrcAlphaSaturate"; + case BlendFactor::eSrc1Color: return "Src1Color"; + case BlendFactor::eOneMinusSrc1Color: return "OneMinusSrc1Color"; + case BlendFactor::eSrc1Alpha: return "Src1Alpha"; + case BlendFactor::eOneMinusSrc1Alpha: return "OneMinusSrc1Alpha"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(BlendOp value) + { + switch (value) + { + case BlendOp::eAdd: return "Add"; + case BlendOp::eSubtract: return "Subtract"; + case BlendOp::eReverseSubtract: return "ReverseSubtract"; + case BlendOp::eMin: return "Min"; + case BlendOp::eMax: return "Max"; + case BlendOp::eZeroEXT: return "ZeroEXT"; + case BlendOp::eSrcEXT: return "SrcEXT"; + case BlendOp::eDstEXT: return "DstEXT"; + case BlendOp::eSrcOverEXT: return "SrcOverEXT"; + case BlendOp::eDstOverEXT: return "DstOverEXT"; + case BlendOp::eSrcInEXT: return "SrcInEXT"; + case BlendOp::eDstInEXT: return "DstInEXT"; + case BlendOp::eSrcOutEXT: return "SrcOutEXT"; + case BlendOp::eDstOutEXT: return "DstOutEXT"; + case BlendOp::eSrcAtopEXT: return "SrcAtopEXT"; + case BlendOp::eDstAtopEXT: return "DstAtopEXT"; + case BlendOp::eXorEXT: return "XorEXT"; + case BlendOp::eMultiplyEXT: return "MultiplyEXT"; + case BlendOp::eScreenEXT: return "ScreenEXT"; + case BlendOp::eOverlayEXT: return "OverlayEXT"; + case BlendOp::eDarkenEXT: return "DarkenEXT"; + case BlendOp::eLightenEXT: return "LightenEXT"; + case BlendOp::eColordodgeEXT: return "ColordodgeEXT"; + case BlendOp::eColorburnEXT: return "ColorburnEXT"; + case BlendOp::eHardlightEXT: return "HardlightEXT"; + case BlendOp::eSoftlightEXT: return "SoftlightEXT"; + case BlendOp::eDifferenceEXT: return "DifferenceEXT"; + case BlendOp::eExclusionEXT: return "ExclusionEXT"; + case BlendOp::eInvertEXT: return "InvertEXT"; + case BlendOp::eInvertRgbEXT: return "InvertRgbEXT"; + case BlendOp::eLineardodgeEXT: return "LineardodgeEXT"; + case BlendOp::eLinearburnEXT: return "LinearburnEXT"; + case BlendOp::eVividlightEXT: return "VividlightEXT"; + case BlendOp::eLinearlightEXT: return "LinearlightEXT"; + case BlendOp::ePinlightEXT: return "PinlightEXT"; + case BlendOp::eHardmixEXT: return "HardmixEXT"; + case BlendOp::eHslHueEXT: return "HslHueEXT"; + case BlendOp::eHslSaturationEXT: return "HslSaturationEXT"; + case BlendOp::eHslColorEXT: return "HslColorEXT"; + case BlendOp::eHslLuminosityEXT: return "HslLuminosityEXT"; + case BlendOp::ePlusEXT: return "PlusEXT"; + case BlendOp::ePlusClampedEXT: return "PlusClampedEXT"; + case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT"; + case BlendOp::ePlusDarkerEXT: return "PlusDarkerEXT"; + case BlendOp::eMinusEXT: return "MinusEXT"; + case BlendOp::eMinusClampedEXT: return "MinusClampedEXT"; + case BlendOp::eContrastEXT: return "ContrastEXT"; + case BlendOp::eInvertOvgEXT: return "InvertOvgEXT"; + case BlendOp::eRedEXT: return "RedEXT"; + case BlendOp::eGreenEXT: return "GreenEXT"; + case BlendOp::eBlueEXT: return "BlueEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(StencilOp value) + { + switch (value) + { + case StencilOp::eKeep: return "Keep"; + case StencilOp::eZero: return "Zero"; + case StencilOp::eReplace: return "Replace"; + case StencilOp::eIncrementAndClamp: return "IncrementAndClamp"; + case StencilOp::eDecrementAndClamp: return "DecrementAndClamp"; + case StencilOp::eInvert: return "Invert"; + case StencilOp::eIncrementAndWrap: return "IncrementAndWrap"; + case StencilOp::eDecrementAndWrap: return "DecrementAndWrap"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(LogicOp value) + { + switch (value) + { + case LogicOp::eClear: return "Clear"; + case LogicOp::eAnd: return "And"; + case LogicOp::eAndReverse: return "AndReverse"; + case LogicOp::eCopy: return "Copy"; + case LogicOp::eAndInverted: return "AndInverted"; + case LogicOp::eNoOp: return "NoOp"; + case LogicOp::eXor: return "Xor"; + case LogicOp::eOr: return "Or"; + case LogicOp::eNor: return "Nor"; + case LogicOp::eEquivalent: return "Equivalent"; + case LogicOp::eInvert: return "Invert"; + case LogicOp::eOrReverse: return "OrReverse"; + case LogicOp::eCopyInverted: return "CopyInverted"; + case LogicOp::eOrInverted: return "OrInverted"; + case LogicOp::eNand: return "Nand"; + case LogicOp::eSet: return "Set"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(InternalAllocationType value) + { + switch (value) + { + case InternalAllocationType::eExecutable: return "Executable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SystemAllocationScope value) + { + switch (value) + { + case SystemAllocationScope::eCommand: return "Command"; + case SystemAllocationScope::eObject: return "Object"; + case SystemAllocationScope::eCache: return "Cache"; + case SystemAllocationScope::eDevice: return "Device"; + case SystemAllocationScope::eInstance: return "Instance"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PhysicalDeviceType value) + { + switch (value) + { + case PhysicalDeviceType::eOther: return "Other"; + case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu"; + case PhysicalDeviceType::eDiscreteGpu: return "DiscreteGpu"; + case PhysicalDeviceType::eVirtualGpu: return "VirtualGpu"; + case PhysicalDeviceType::eCpu: return "Cpu"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(VertexInputRate value) + { + switch (value) + { + case VertexInputRate::eVertex: return "Vertex"; + case VertexInputRate::eInstance: return "Instance"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(Format value) + { + switch (value) + { + case Format::eUndefined: return "Undefined"; + case Format::eR4G4UnormPack8: return "R4G4UnormPack8"; + case Format::eR4G4B4A4UnormPack16: return "R4G4B4A4UnormPack16"; + case Format::eB4G4R4A4UnormPack16: return "B4G4R4A4UnormPack16"; + case Format::eR5G6B5UnormPack16: return "R5G6B5UnormPack16"; + case Format::eB5G6R5UnormPack16: return "B5G6R5UnormPack16"; + case Format::eR5G5B5A1UnormPack16: return "R5G5B5A1UnormPack16"; + case Format::eB5G5R5A1UnormPack16: return "B5G5R5A1UnormPack16"; + case Format::eA1R5G5B5UnormPack16: return "A1R5G5B5UnormPack16"; + case Format::eR8Unorm: return "R8Unorm"; + case Format::eR8Snorm: return "R8Snorm"; + case Format::eR8Uscaled: return "R8Uscaled"; + case Format::eR8Sscaled: return "R8Sscaled"; + case Format::eR8Uint: return "R8Uint"; + case Format::eR8Sint: return "R8Sint"; + case Format::eR8Srgb: return "R8Srgb"; + case Format::eR8G8Unorm: return "R8G8Unorm"; + case Format::eR8G8Snorm: return "R8G8Snorm"; + case Format::eR8G8Uscaled: return "R8G8Uscaled"; + case Format::eR8G8Sscaled: return "R8G8Sscaled"; + case Format::eR8G8Uint: return "R8G8Uint"; + case Format::eR8G8Sint: return "R8G8Sint"; + case Format::eR8G8Srgb: return "R8G8Srgb"; + case Format::eR8G8B8Unorm: return "R8G8B8Unorm"; + case Format::eR8G8B8Snorm: return "R8G8B8Snorm"; + case Format::eR8G8B8Uscaled: return "R8G8B8Uscaled"; + case Format::eR8G8B8Sscaled: return "R8G8B8Sscaled"; + case Format::eR8G8B8Uint: return "R8G8B8Uint"; + case Format::eR8G8B8Sint: return "R8G8B8Sint"; + case Format::eR8G8B8Srgb: return "R8G8B8Srgb"; + case Format::eB8G8R8Unorm: return "B8G8R8Unorm"; + case Format::eB8G8R8Snorm: return "B8G8R8Snorm"; + case Format::eB8G8R8Uscaled: return "B8G8R8Uscaled"; + case Format::eB8G8R8Sscaled: return "B8G8R8Sscaled"; + case Format::eB8G8R8Uint: return "B8G8R8Uint"; + case Format::eB8G8R8Sint: return "B8G8R8Sint"; + case Format::eB8G8R8Srgb: return "B8G8R8Srgb"; + case Format::eR8G8B8A8Unorm: return "R8G8B8A8Unorm"; + case Format::eR8G8B8A8Snorm: return "R8G8B8A8Snorm"; + case Format::eR8G8B8A8Uscaled: return "R8G8B8A8Uscaled"; + case Format::eR8G8B8A8Sscaled: return "R8G8B8A8Sscaled"; + case Format::eR8G8B8A8Uint: return "R8G8B8A8Uint"; + case Format::eR8G8B8A8Sint: return "R8G8B8A8Sint"; + case Format::eR8G8B8A8Srgb: return "R8G8B8A8Srgb"; + case Format::eB8G8R8A8Unorm: return "B8G8R8A8Unorm"; + case Format::eB8G8R8A8Snorm: return "B8G8R8A8Snorm"; + case Format::eB8G8R8A8Uscaled: return "B8G8R8A8Uscaled"; + case Format::eB8G8R8A8Sscaled: return "B8G8R8A8Sscaled"; + case Format::eB8G8R8A8Uint: return "B8G8R8A8Uint"; + case Format::eB8G8R8A8Sint: return "B8G8R8A8Sint"; + case Format::eB8G8R8A8Srgb: return "B8G8R8A8Srgb"; + case Format::eA8B8G8R8UnormPack32: return "A8B8G8R8UnormPack32"; + case Format::eA8B8G8R8SnormPack32: return "A8B8G8R8SnormPack32"; + case Format::eA8B8G8R8UscaledPack32: return "A8B8G8R8UscaledPack32"; + case Format::eA8B8G8R8SscaledPack32: return "A8B8G8R8SscaledPack32"; + case Format::eA8B8G8R8UintPack32: return "A8B8G8R8UintPack32"; + case Format::eA8B8G8R8SintPack32: return "A8B8G8R8SintPack32"; + case Format::eA8B8G8R8SrgbPack32: return "A8B8G8R8SrgbPack32"; + case Format::eA2R10G10B10UnormPack32: return "A2R10G10B10UnormPack32"; + case Format::eA2R10G10B10SnormPack32: return "A2R10G10B10SnormPack32"; + case Format::eA2R10G10B10UscaledPack32: return "A2R10G10B10UscaledPack32"; + case Format::eA2R10G10B10SscaledPack32: return "A2R10G10B10SscaledPack32"; + case Format::eA2R10G10B10UintPack32: return "A2R10G10B10UintPack32"; + case Format::eA2R10G10B10SintPack32: return "A2R10G10B10SintPack32"; + case Format::eA2B10G10R10UnormPack32: return "A2B10G10R10UnormPack32"; + case Format::eA2B10G10R10SnormPack32: return "A2B10G10R10SnormPack32"; + case Format::eA2B10G10R10UscaledPack32: return "A2B10G10R10UscaledPack32"; + case Format::eA2B10G10R10SscaledPack32: return "A2B10G10R10SscaledPack32"; + case Format::eA2B10G10R10UintPack32: return "A2B10G10R10UintPack32"; + case Format::eA2B10G10R10SintPack32: return "A2B10G10R10SintPack32"; + case Format::eR16Unorm: return "R16Unorm"; + case Format::eR16Snorm: return "R16Snorm"; + case Format::eR16Uscaled: return "R16Uscaled"; + case Format::eR16Sscaled: return "R16Sscaled"; + case Format::eR16Uint: return "R16Uint"; + case Format::eR16Sint: return "R16Sint"; + case Format::eR16Sfloat: return "R16Sfloat"; + case Format::eR16G16Unorm: return "R16G16Unorm"; + case Format::eR16G16Snorm: return "R16G16Snorm"; + case Format::eR16G16Uscaled: return "R16G16Uscaled"; + case Format::eR16G16Sscaled: return "R16G16Sscaled"; + case Format::eR16G16Uint: return "R16G16Uint"; + case Format::eR16G16Sint: return "R16G16Sint"; + case Format::eR16G16Sfloat: return "R16G16Sfloat"; + case Format::eR16G16B16Unorm: return "R16G16B16Unorm"; + case Format::eR16G16B16Snorm: return "R16G16B16Snorm"; + case Format::eR16G16B16Uscaled: return "R16G16B16Uscaled"; + case Format::eR16G16B16Sscaled: return "R16G16B16Sscaled"; + case Format::eR16G16B16Uint: return "R16G16B16Uint"; + case Format::eR16G16B16Sint: return "R16G16B16Sint"; + case Format::eR16G16B16Sfloat: return "R16G16B16Sfloat"; + case Format::eR16G16B16A16Unorm: return "R16G16B16A16Unorm"; + case Format::eR16G16B16A16Snorm: return "R16G16B16A16Snorm"; + case Format::eR16G16B16A16Uscaled: return "R16G16B16A16Uscaled"; + case Format::eR16G16B16A16Sscaled: return "R16G16B16A16Sscaled"; + case Format::eR16G16B16A16Uint: return "R16G16B16A16Uint"; + case Format::eR16G16B16A16Sint: return "R16G16B16A16Sint"; + case Format::eR16G16B16A16Sfloat: return "R16G16B16A16Sfloat"; + case Format::eR32Uint: return "R32Uint"; + case Format::eR32Sint: return "R32Sint"; + case Format::eR32Sfloat: return "R32Sfloat"; + case Format::eR32G32Uint: return "R32G32Uint"; + case Format::eR32G32Sint: return "R32G32Sint"; + case Format::eR32G32Sfloat: return "R32G32Sfloat"; + case Format::eR32G32B32Uint: return "R32G32B32Uint"; + case Format::eR32G32B32Sint: return "R32G32B32Sint"; + case Format::eR32G32B32Sfloat: return "R32G32B32Sfloat"; + case Format::eR32G32B32A32Uint: return "R32G32B32A32Uint"; + case Format::eR32G32B32A32Sint: return "R32G32B32A32Sint"; + case Format::eR32G32B32A32Sfloat: return "R32G32B32A32Sfloat"; + case Format::eR64Uint: return "R64Uint"; + case Format::eR64Sint: return "R64Sint"; + case Format::eR64Sfloat: return "R64Sfloat"; + case Format::eR64G64Uint: return "R64G64Uint"; + case Format::eR64G64Sint: return "R64G64Sint"; + case Format::eR64G64Sfloat: return "R64G64Sfloat"; + case Format::eR64G64B64Uint: return "R64G64B64Uint"; + case Format::eR64G64B64Sint: return "R64G64B64Sint"; + case Format::eR64G64B64Sfloat: return "R64G64B64Sfloat"; + case Format::eR64G64B64A64Uint: return "R64G64B64A64Uint"; + case Format::eR64G64B64A64Sint: return "R64G64B64A64Sint"; + case Format::eR64G64B64A64Sfloat: return "R64G64B64A64Sfloat"; + case Format::eB10G11R11UfloatPack32: return "B10G11R11UfloatPack32"; + case Format::eE5B9G9R9UfloatPack32: return "E5B9G9R9UfloatPack32"; + case Format::eD16Unorm: return "D16Unorm"; + case Format::eX8D24UnormPack32: return "X8D24UnormPack32"; + case Format::eD32Sfloat: return "D32Sfloat"; + case Format::eS8Uint: return "S8Uint"; + case Format::eD16UnormS8Uint: return "D16UnormS8Uint"; + case Format::eD24UnormS8Uint: return "D24UnormS8Uint"; + case Format::eD32SfloatS8Uint: return "D32SfloatS8Uint"; + case Format::eBc1RgbUnormBlock: return "Bc1RgbUnormBlock"; + case Format::eBc1RgbSrgbBlock: return "Bc1RgbSrgbBlock"; + case Format::eBc1RgbaUnormBlock: return "Bc1RgbaUnormBlock"; + case Format::eBc1RgbaSrgbBlock: return "Bc1RgbaSrgbBlock"; + case Format::eBc2UnormBlock: return "Bc2UnormBlock"; + case Format::eBc2SrgbBlock: return "Bc2SrgbBlock"; + case Format::eBc3UnormBlock: return "Bc3UnormBlock"; + case Format::eBc3SrgbBlock: return "Bc3SrgbBlock"; + case Format::eBc4UnormBlock: return "Bc4UnormBlock"; + case Format::eBc4SnormBlock: return "Bc4SnormBlock"; + case Format::eBc5UnormBlock: return "Bc5UnormBlock"; + case Format::eBc5SnormBlock: return "Bc5SnormBlock"; + case Format::eBc6HUfloatBlock: return "Bc6HUfloatBlock"; + case Format::eBc6HSfloatBlock: return "Bc6HSfloatBlock"; + case Format::eBc7UnormBlock: return "Bc7UnormBlock"; + case Format::eBc7SrgbBlock: return "Bc7SrgbBlock"; + case Format::eEtc2R8G8B8UnormBlock: return "Etc2R8G8B8UnormBlock"; + case Format::eEtc2R8G8B8SrgbBlock: return "Etc2R8G8B8SrgbBlock"; + case Format::eEtc2R8G8B8A1UnormBlock: return "Etc2R8G8B8A1UnormBlock"; + case Format::eEtc2R8G8B8A1SrgbBlock: return "Etc2R8G8B8A1SrgbBlock"; + case Format::eEtc2R8G8B8A8UnormBlock: return "Etc2R8G8B8A8UnormBlock"; + case Format::eEtc2R8G8B8A8SrgbBlock: return "Etc2R8G8B8A8SrgbBlock"; + case Format::eEacR11UnormBlock: return "EacR11UnormBlock"; + case Format::eEacR11SnormBlock: return "EacR11SnormBlock"; + case Format::eEacR11G11UnormBlock: return "EacR11G11UnormBlock"; + case Format::eEacR11G11SnormBlock: return "EacR11G11SnormBlock"; + case Format::eAstc4x4UnormBlock: return "Astc4x4UnormBlock"; + case Format::eAstc4x4SrgbBlock: return "Astc4x4SrgbBlock"; + case Format::eAstc5x4UnormBlock: return "Astc5x4UnormBlock"; + case Format::eAstc5x4SrgbBlock: return "Astc5x4SrgbBlock"; + case Format::eAstc5x5UnormBlock: return "Astc5x5UnormBlock"; + case Format::eAstc5x5SrgbBlock: return "Astc5x5SrgbBlock"; + case Format::eAstc6x5UnormBlock: return "Astc6x5UnormBlock"; + case Format::eAstc6x5SrgbBlock: return "Astc6x5SrgbBlock"; + case Format::eAstc6x6UnormBlock: return "Astc6x6UnormBlock"; + case Format::eAstc6x6SrgbBlock: return "Astc6x6SrgbBlock"; + case Format::eAstc8x5UnormBlock: return "Astc8x5UnormBlock"; + case Format::eAstc8x5SrgbBlock: return "Astc8x5SrgbBlock"; + case Format::eAstc8x6UnormBlock: return "Astc8x6UnormBlock"; + case Format::eAstc8x6SrgbBlock: return "Astc8x6SrgbBlock"; + case Format::eAstc8x8UnormBlock: return "Astc8x8UnormBlock"; + case Format::eAstc8x8SrgbBlock: return "Astc8x8SrgbBlock"; + case Format::eAstc10x5UnormBlock: return "Astc10x5UnormBlock"; + case Format::eAstc10x5SrgbBlock: return "Astc10x5SrgbBlock"; + case Format::eAstc10x6UnormBlock: return "Astc10x6UnormBlock"; + case Format::eAstc10x6SrgbBlock: return "Astc10x6SrgbBlock"; + case Format::eAstc10x8UnormBlock: return "Astc10x8UnormBlock"; + case Format::eAstc10x8SrgbBlock: return "Astc10x8SrgbBlock"; + case Format::eAstc10x10UnormBlock: return "Astc10x10UnormBlock"; + case Format::eAstc10x10SrgbBlock: return "Astc10x10SrgbBlock"; + case Format::eAstc12x10UnormBlock: return "Astc12x10UnormBlock"; + case Format::eAstc12x10SrgbBlock: return "Astc12x10SrgbBlock"; + case Format::eAstc12x12UnormBlock: return "Astc12x12UnormBlock"; + case Format::eAstc12x12SrgbBlock: return "Astc12x12SrgbBlock"; + case Format::eG8B8G8R8422Unorm: return "G8B8G8R8422Unorm"; + case Format::eB8G8R8G8422Unorm: return "B8G8R8G8422Unorm"; + case Format::eG8B8R83Plane420Unorm: return "G8B8R83Plane420Unorm"; + case Format::eG8B8R82Plane420Unorm: return "G8B8R82Plane420Unorm"; + case Format::eG8B8R83Plane422Unorm: return "G8B8R83Plane422Unorm"; + case Format::eG8B8R82Plane422Unorm: return "G8B8R82Plane422Unorm"; + case Format::eG8B8R83Plane444Unorm: return "G8B8R83Plane444Unorm"; + case Format::eR10X6UnormPack16: return "R10X6UnormPack16"; + case Format::eR10X6G10X6Unorm2Pack16: return "R10X6G10X6Unorm2Pack16"; + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: return "R10X6G10X6B10X6A10X6Unorm4Pack16"; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: return "G10X6B10X6G10X6R10X6422Unorm4Pack16"; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: return "B10X6G10X6R10X6G10X6422Unorm4Pack16"; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: return "G10X6B10X6R10X63Plane420Unorm3Pack16"; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: return "G10X6B10X6R10X62Plane420Unorm3Pack16"; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: return "G10X6B10X6R10X63Plane422Unorm3Pack16"; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: return "G10X6B10X6R10X62Plane422Unorm3Pack16"; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: return "G10X6B10X6R10X63Plane444Unorm3Pack16"; + case Format::eR12X4UnormPack16: return "R12X4UnormPack16"; + case Format::eR12X4G12X4Unorm2Pack16: return "R12X4G12X4Unorm2Pack16"; + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: return "R12X4G12X4B12X4A12X4Unorm4Pack16"; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: return "G12X4B12X4G12X4R12X4422Unorm4Pack16"; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: return "B12X4G12X4R12X4G12X4422Unorm4Pack16"; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: return "G12X4B12X4R12X43Plane420Unorm3Pack16"; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: return "G12X4B12X4R12X42Plane420Unorm3Pack16"; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: return "G12X4B12X4R12X43Plane422Unorm3Pack16"; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: return "G12X4B12X4R12X42Plane422Unorm3Pack16"; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: return "G12X4B12X4R12X43Plane444Unorm3Pack16"; + case Format::eG16B16G16R16422Unorm: return "G16B16G16R16422Unorm"; + case Format::eB16G16R16G16422Unorm: return "B16G16R16G16422Unorm"; + case Format::eG16B16R163Plane420Unorm: return "G16B16R163Plane420Unorm"; + case Format::eG16B16R162Plane420Unorm: return "G16B16R162Plane420Unorm"; + case Format::eG16B16R163Plane422Unorm: return "G16B16R163Plane422Unorm"; + case Format::eG16B16R162Plane422Unorm: return "G16B16R162Plane422Unorm"; + case Format::eG16B16R163Plane444Unorm: return "G16B16R163Plane444Unorm"; + case Format::ePvrtc12BppUnormBlockIMG: return "Pvrtc12BppUnormBlockIMG"; + case Format::ePvrtc14BppUnormBlockIMG: return "Pvrtc14BppUnormBlockIMG"; + case Format::ePvrtc22BppUnormBlockIMG: return "Pvrtc22BppUnormBlockIMG"; + case Format::ePvrtc24BppUnormBlockIMG: return "Pvrtc24BppUnormBlockIMG"; + case Format::ePvrtc12BppSrgbBlockIMG: return "Pvrtc12BppSrgbBlockIMG"; + case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG"; + case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG"; + case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(StructureType value) + { + switch (value) + { + case StructureType::eApplicationInfo: return "ApplicationInfo"; + case StructureType::eInstanceCreateInfo: return "InstanceCreateInfo"; + case StructureType::eDeviceQueueCreateInfo: return "DeviceQueueCreateInfo"; + case StructureType::eDeviceCreateInfo: return "DeviceCreateInfo"; + case StructureType::eSubmitInfo: return "SubmitInfo"; + case StructureType::eMemoryAllocateInfo: return "MemoryAllocateInfo"; + case StructureType::eMappedMemoryRange: return "MappedMemoryRange"; + case StructureType::eBindSparseInfo: return "BindSparseInfo"; + case StructureType::eFenceCreateInfo: return "FenceCreateInfo"; + case StructureType::eSemaphoreCreateInfo: return "SemaphoreCreateInfo"; + case StructureType::eEventCreateInfo: return "EventCreateInfo"; + case StructureType::eQueryPoolCreateInfo: return "QueryPoolCreateInfo"; + case StructureType::eBufferCreateInfo: return "BufferCreateInfo"; + case StructureType::eBufferViewCreateInfo: return "BufferViewCreateInfo"; + case StructureType::eImageCreateInfo: return "ImageCreateInfo"; + case StructureType::eImageViewCreateInfo: return "ImageViewCreateInfo"; + case StructureType::eShaderModuleCreateInfo: return "ShaderModuleCreateInfo"; + case StructureType::ePipelineCacheCreateInfo: return "PipelineCacheCreateInfo"; + case StructureType::ePipelineShaderStageCreateInfo: return "PipelineShaderStageCreateInfo"; + case StructureType::ePipelineVertexInputStateCreateInfo: return "PipelineVertexInputStateCreateInfo"; + case StructureType::ePipelineInputAssemblyStateCreateInfo: return "PipelineInputAssemblyStateCreateInfo"; + case StructureType::ePipelineTessellationStateCreateInfo: return "PipelineTessellationStateCreateInfo"; + case StructureType::ePipelineViewportStateCreateInfo: return "PipelineViewportStateCreateInfo"; + case StructureType::ePipelineRasterizationStateCreateInfo: return "PipelineRasterizationStateCreateInfo"; + case StructureType::ePipelineMultisampleStateCreateInfo: return "PipelineMultisampleStateCreateInfo"; + case StructureType::ePipelineDepthStencilStateCreateInfo: return "PipelineDepthStencilStateCreateInfo"; + case StructureType::ePipelineColorBlendStateCreateInfo: return "PipelineColorBlendStateCreateInfo"; + case StructureType::ePipelineDynamicStateCreateInfo: return "PipelineDynamicStateCreateInfo"; + case StructureType::eGraphicsPipelineCreateInfo: return "GraphicsPipelineCreateInfo"; + case StructureType::eComputePipelineCreateInfo: return "ComputePipelineCreateInfo"; + case StructureType::ePipelineLayoutCreateInfo: return "PipelineLayoutCreateInfo"; + case StructureType::eSamplerCreateInfo: return "SamplerCreateInfo"; + case StructureType::eDescriptorSetLayoutCreateInfo: return "DescriptorSetLayoutCreateInfo"; + case StructureType::eDescriptorPoolCreateInfo: return "DescriptorPoolCreateInfo"; + case StructureType::eDescriptorSetAllocateInfo: return "DescriptorSetAllocateInfo"; + case StructureType::eWriteDescriptorSet: return "WriteDescriptorSet"; + case StructureType::eCopyDescriptorSet: return "CopyDescriptorSet"; + case StructureType::eFramebufferCreateInfo: return "FramebufferCreateInfo"; + case StructureType::eRenderPassCreateInfo: return "RenderPassCreateInfo"; + case StructureType::eCommandPoolCreateInfo: return "CommandPoolCreateInfo"; + case StructureType::eCommandBufferAllocateInfo: return "CommandBufferAllocateInfo"; + case StructureType::eCommandBufferInheritanceInfo: return "CommandBufferInheritanceInfo"; + case StructureType::eCommandBufferBeginInfo: return "CommandBufferBeginInfo"; + case StructureType::eRenderPassBeginInfo: return "RenderPassBeginInfo"; + case StructureType::eBufferMemoryBarrier: return "BufferMemoryBarrier"; + case StructureType::eImageMemoryBarrier: return "ImageMemoryBarrier"; + case StructureType::eMemoryBarrier: return "MemoryBarrier"; + case StructureType::eLoaderInstanceCreateInfo: return "LoaderInstanceCreateInfo"; + case StructureType::eLoaderDeviceCreateInfo: return "LoaderDeviceCreateInfo"; + case StructureType::ePhysicalDeviceSubgroupProperties: return "PhysicalDeviceSubgroupProperties"; + case StructureType::eBindBufferMemoryInfo: return "BindBufferMemoryInfo"; + case StructureType::eBindImageMemoryInfo: return "BindImageMemoryInfo"; + case StructureType::ePhysicalDevice16BitStorageFeatures: return "PhysicalDevice16BitStorageFeatures"; + case StructureType::eMemoryDedicatedRequirements: return "MemoryDedicatedRequirements"; + case StructureType::eMemoryDedicatedAllocateInfo: return "MemoryDedicatedAllocateInfo"; + case StructureType::eMemoryAllocateFlagsInfo: return "MemoryAllocateFlagsInfo"; + case StructureType::eDeviceGroupRenderPassBeginInfo: return "DeviceGroupRenderPassBeginInfo"; + case StructureType::eDeviceGroupCommandBufferBeginInfo: return "DeviceGroupCommandBufferBeginInfo"; + case StructureType::eDeviceGroupSubmitInfo: return "DeviceGroupSubmitInfo"; + case StructureType::eDeviceGroupBindSparseInfo: return "DeviceGroupBindSparseInfo"; + case StructureType::eBindBufferMemoryDeviceGroupInfo: return "BindBufferMemoryDeviceGroupInfo"; + case StructureType::eBindImageMemoryDeviceGroupInfo: return "BindImageMemoryDeviceGroupInfo"; + case StructureType::ePhysicalDeviceGroupProperties: return "PhysicalDeviceGroupProperties"; + case StructureType::eDeviceGroupDeviceCreateInfo: return "DeviceGroupDeviceCreateInfo"; + case StructureType::eBufferMemoryRequirementsInfo2: return "BufferMemoryRequirementsInfo2"; + case StructureType::eImageMemoryRequirementsInfo2: return "ImageMemoryRequirementsInfo2"; + case StructureType::eImageSparseMemoryRequirementsInfo2: return "ImageSparseMemoryRequirementsInfo2"; + case StructureType::eMemoryRequirements2: return "MemoryRequirements2"; + case StructureType::eSparseImageMemoryRequirements2: return "SparseImageMemoryRequirements2"; + case StructureType::ePhysicalDeviceFeatures2: return "PhysicalDeviceFeatures2"; + case StructureType::ePhysicalDeviceProperties2: return "PhysicalDeviceProperties2"; + case StructureType::eFormatProperties2: return "FormatProperties2"; + case StructureType::eImageFormatProperties2: return "ImageFormatProperties2"; + case StructureType::ePhysicalDeviceImageFormatInfo2: return "PhysicalDeviceImageFormatInfo2"; + case StructureType::eQueueFamilyProperties2: return "QueueFamilyProperties2"; + case StructureType::ePhysicalDeviceMemoryProperties2: return "PhysicalDeviceMemoryProperties2"; + case StructureType::eSparseImageFormatProperties2: return "SparseImageFormatProperties2"; + case StructureType::ePhysicalDeviceSparseImageFormatInfo2: return "PhysicalDeviceSparseImageFormatInfo2"; + case StructureType::ePhysicalDevicePointClippingProperties: return "PhysicalDevicePointClippingProperties"; + case StructureType::eRenderPassInputAttachmentAspectCreateInfo: return "RenderPassInputAttachmentAspectCreateInfo"; + case StructureType::eImageViewUsageCreateInfo: return "ImageViewUsageCreateInfo"; + case StructureType::ePipelineTessellationDomainOriginStateCreateInfo: return "PipelineTessellationDomainOriginStateCreateInfo"; + case StructureType::eRenderPassMultiviewCreateInfo: return "RenderPassMultiviewCreateInfo"; + case StructureType::ePhysicalDeviceMultiviewFeatures: return "PhysicalDeviceMultiviewFeatures"; + case StructureType::ePhysicalDeviceMultiviewProperties: return "PhysicalDeviceMultiviewProperties"; + case StructureType::ePhysicalDeviceVariablePointerFeatures: return "PhysicalDeviceVariablePointerFeatures"; + case StructureType::eProtectedSubmitInfo: return "ProtectedSubmitInfo"; + case StructureType::ePhysicalDeviceProtectedMemoryFeatures: return "PhysicalDeviceProtectedMemoryFeatures"; + case StructureType::ePhysicalDeviceProtectedMemoryProperties: return "PhysicalDeviceProtectedMemoryProperties"; + case StructureType::eDeviceQueueInfo2: return "DeviceQueueInfo2"; + case StructureType::eSamplerYcbcrConversionCreateInfo: return "SamplerYcbcrConversionCreateInfo"; + case StructureType::eSamplerYcbcrConversionInfo: return "SamplerYcbcrConversionInfo"; + case StructureType::eBindImagePlaneMemoryInfo: return "BindImagePlaneMemoryInfo"; + case StructureType::eImagePlaneMemoryRequirementsInfo: return "ImagePlaneMemoryRequirementsInfo"; + case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures: return "PhysicalDeviceSamplerYcbcrConversionFeatures"; + case StructureType::eSamplerYcbcrConversionImageFormatProperties: return "SamplerYcbcrConversionImageFormatProperties"; + case StructureType::eDescriptorUpdateTemplateCreateInfo: return "DescriptorUpdateTemplateCreateInfo"; + case StructureType::ePhysicalDeviceExternalImageFormatInfo: return "PhysicalDeviceExternalImageFormatInfo"; + case StructureType::eExternalImageFormatProperties: return "ExternalImageFormatProperties"; + case StructureType::ePhysicalDeviceExternalBufferInfo: return "PhysicalDeviceExternalBufferInfo"; + case StructureType::eExternalBufferProperties: return "ExternalBufferProperties"; + case StructureType::ePhysicalDeviceIdProperties: return "PhysicalDeviceIdProperties"; + case StructureType::eExternalMemoryBufferCreateInfo: return "ExternalMemoryBufferCreateInfo"; + case StructureType::eExternalMemoryImageCreateInfo: return "ExternalMemoryImageCreateInfo"; + case StructureType::eExportMemoryAllocateInfo: return "ExportMemoryAllocateInfo"; + case StructureType::ePhysicalDeviceExternalFenceInfo: return "PhysicalDeviceExternalFenceInfo"; + case StructureType::eExternalFenceProperties: return "ExternalFenceProperties"; + case StructureType::eExportFenceCreateInfo: return "ExportFenceCreateInfo"; + case StructureType::eExportSemaphoreCreateInfo: return "ExportSemaphoreCreateInfo"; + case StructureType::ePhysicalDeviceExternalSemaphoreInfo: return "PhysicalDeviceExternalSemaphoreInfo"; + case StructureType::eExternalSemaphoreProperties: return "ExternalSemaphoreProperties"; + case StructureType::ePhysicalDeviceMaintenance3Properties: return "PhysicalDeviceMaintenance3Properties"; + case StructureType::eDescriptorSetLayoutSupport: return "DescriptorSetLayoutSupport"; + case StructureType::ePhysicalDeviceShaderDrawParameterFeatures: return "PhysicalDeviceShaderDrawParameterFeatures"; + case StructureType::eSwapchainCreateInfoKHR: return "SwapchainCreateInfoKHR"; + case StructureType::ePresentInfoKHR: return "PresentInfoKHR"; + case StructureType::eDeviceGroupPresentCapabilitiesKHR: return "DeviceGroupPresentCapabilitiesKHR"; + case StructureType::eImageSwapchainCreateInfoKHR: return "ImageSwapchainCreateInfoKHR"; + case StructureType::eBindImageMemorySwapchainInfoKHR: return "BindImageMemorySwapchainInfoKHR"; + case StructureType::eAcquireNextImageInfoKHR: return "AcquireNextImageInfoKHR"; + case StructureType::eDeviceGroupPresentInfoKHR: return "DeviceGroupPresentInfoKHR"; + case StructureType::eDeviceGroupSwapchainCreateInfoKHR: return "DeviceGroupSwapchainCreateInfoKHR"; + case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR"; + case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR"; + case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR"; + case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR"; + case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR"; + case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR"; + case StructureType::eMirSurfaceCreateInfoKHR: return "MirSurfaceCreateInfoKHR"; + case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR"; + case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR"; + case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT"; + case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD"; + case StructureType::eDebugMarkerObjectNameInfoEXT: return "DebugMarkerObjectNameInfoEXT"; + case StructureType::eDebugMarkerObjectTagInfoEXT: return "DebugMarkerObjectTagInfoEXT"; + case StructureType::eDebugMarkerMarkerInfoEXT: return "DebugMarkerMarkerInfoEXT"; + case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV"; + case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV"; + case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV"; + case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD"; + case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV"; + case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV"; + case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV"; + case StructureType::eExportMemoryWin32HandleInfoNV: return "ExportMemoryWin32HandleInfoNV"; + case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV"; + case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT"; + case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN"; + case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR"; + case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR"; + case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR"; + case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR"; + case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR"; + case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR"; + case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR"; + case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR"; + case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR"; + case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR"; + case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR"; + case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR"; + case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR"; + case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR"; + case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR"; + case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR"; + case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX"; + case StructureType::eIndirectCommandsLayoutCreateInfoNVX: return "IndirectCommandsLayoutCreateInfoNVX"; + case StructureType::eCmdProcessCommandsInfoNVX: return "CmdProcessCommandsInfoNVX"; + case StructureType::eCmdReserveSpaceForCommandsInfoNVX: return "CmdReserveSpaceForCommandsInfoNVX"; + case StructureType::eDeviceGeneratedCommandsLimitsNVX: return "DeviceGeneratedCommandsLimitsNVX"; + case StructureType::eDeviceGeneratedCommandsFeaturesNVX: return "DeviceGeneratedCommandsFeaturesNVX"; + case StructureType::ePipelineViewportWScalingStateCreateInfoNV: return "PipelineViewportWScalingStateCreateInfoNV"; + case StructureType::eSurfaceCapabilities2EXT: return "SurfaceCapabilities2EXT"; + case StructureType::eDisplayPowerInfoEXT: return "DisplayPowerInfoEXT"; + case StructureType::eDeviceEventInfoEXT: return "DeviceEventInfoEXT"; + case StructureType::eDisplayEventInfoEXT: return "DisplayEventInfoEXT"; + case StructureType::eSwapchainCounterCreateInfoEXT: return "SwapchainCounterCreateInfoEXT"; + case StructureType::ePresentTimesInfoGOOGLE: return "PresentTimesInfoGOOGLE"; + case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"; + case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV"; + case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT"; + case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT: return "PhysicalDeviceConservativeRasterizationPropertiesEXT"; + case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT: return "PipelineRasterizationConservativeStateCreateInfoEXT"; + case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT"; + case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR"; + case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR"; + case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR"; + case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR"; + case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR"; + case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR"; + case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR"; + case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR"; + case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR"; + case StructureType::eDisplayProperties2KHR: return "DisplayProperties2KHR"; + case StructureType::eDisplayPlaneProperties2KHR: return "DisplayPlaneProperties2KHR"; + case StructureType::eDisplayModeProperties2KHR: return "DisplayModeProperties2KHR"; + case StructureType::eDisplayPlaneInfo2KHR: return "DisplayPlaneInfo2KHR"; + case StructureType::eDisplayPlaneCapabilities2KHR: return "DisplayPlaneCapabilities2KHR"; + case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK"; + case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK"; + case StructureType::eDebugUtilsObjectNameInfoEXT: return "DebugUtilsObjectNameInfoEXT"; + case StructureType::eDebugUtilsObjectTagInfoEXT: return "DebugUtilsObjectTagInfoEXT"; + case StructureType::eDebugUtilsLabelEXT: return "DebugUtilsLabelEXT"; + case StructureType::eDebugUtilsMessengerCallbackDataEXT: return "DebugUtilsMessengerCallbackDataEXT"; + case StructureType::eDebugUtilsMessengerCreateInfoEXT: return "DebugUtilsMessengerCreateInfoEXT"; + case StructureType::eAndroidHardwareBufferUsageANDROID: return "AndroidHardwareBufferUsageANDROID"; + case StructureType::eAndroidHardwareBufferPropertiesANDROID: return "AndroidHardwareBufferPropertiesANDROID"; + case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID: return "AndroidHardwareBufferFormatPropertiesANDROID"; + case StructureType::eImportAndroidHardwareBufferInfoANDROID: return "ImportAndroidHardwareBufferInfoANDROID"; + case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID: return "MemoryGetAndroidHardwareBufferInfoANDROID"; + case StructureType::eExternalFormatANDROID: return "ExternalFormatANDROID"; + case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT"; + case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT"; + case StructureType::eSampleLocationsInfoEXT: return "SampleLocationsInfoEXT"; + case StructureType::eRenderPassSampleLocationsBeginInfoEXT: return "RenderPassSampleLocationsBeginInfoEXT"; + case StructureType::ePipelineSampleLocationsStateCreateInfoEXT: return "PipelineSampleLocationsStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT: return "PhysicalDeviceSampleLocationsPropertiesEXT"; + case StructureType::eMultisamplePropertiesEXT: return "MultisamplePropertiesEXT"; + case StructureType::eImageFormatListCreateInfoKHR: return "ImageFormatListCreateInfoKHR"; + case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT"; + case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT"; + case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT"; + case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV"; + case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV"; + case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT"; + case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT"; + case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT: return "DescriptorSetLayoutBindingFlagsCreateInfoEXT"; + case StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT: return "PhysicalDeviceDescriptorIndexingFeaturesEXT"; + case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT: return "PhysicalDeviceDescriptorIndexingPropertiesEXT"; + case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT: return "DescriptorSetVariableDescriptorCountAllocateInfoEXT"; + case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT: return "DescriptorSetVariableDescriptorCountLayoutSupportEXT"; + case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT"; + case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT"; + case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT"; + case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; + case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD"; + case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; + case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SubpassContents value) + { + switch (value) + { + case SubpassContents::eInline: return "Inline"; + case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DynamicState value) + { + switch (value) + { + case DynamicState::eViewport: return "Viewport"; + case DynamicState::eScissor: return "Scissor"; + case DynamicState::eLineWidth: return "LineWidth"; + case DynamicState::eDepthBias: return "DepthBias"; + case DynamicState::eBlendConstants: return "BlendConstants"; + case DynamicState::eDepthBounds: return "DepthBounds"; + case DynamicState::eStencilCompareMask: return "StencilCompareMask"; + case DynamicState::eStencilWriteMask: return "StencilWriteMask"; + case DynamicState::eStencilReference: return "StencilReference"; + case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV"; + case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT"; + case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateType value) + { + switch (value) + { + case DescriptorUpdateTemplateType::eDescriptorSet: return "DescriptorSet"; + case DescriptorUpdateTemplateType::ePushDescriptorsKHR: return "PushDescriptorsKHR"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ObjectType value) + { + switch (value) + { + case ObjectType::eUnknown: return "Unknown"; + case ObjectType::eInstance: return "Instance"; + case ObjectType::ePhysicalDevice: return "PhysicalDevice"; + case ObjectType::eDevice: return "Device"; + case ObjectType::eQueue: return "Queue"; + case ObjectType::eSemaphore: return "Semaphore"; + case ObjectType::eCommandBuffer: return "CommandBuffer"; + case ObjectType::eFence: return "Fence"; + case ObjectType::eDeviceMemory: return "DeviceMemory"; + case ObjectType::eBuffer: return "Buffer"; + case ObjectType::eImage: return "Image"; + case ObjectType::eEvent: return "Event"; + case ObjectType::eQueryPool: return "QueryPool"; + case ObjectType::eBufferView: return "BufferView"; + case ObjectType::eImageView: return "ImageView"; + case ObjectType::eShaderModule: return "ShaderModule"; + case ObjectType::ePipelineCache: return "PipelineCache"; + case ObjectType::ePipelineLayout: return "PipelineLayout"; + case ObjectType::eRenderPass: return "RenderPass"; + case ObjectType::ePipeline: return "Pipeline"; + case ObjectType::eDescriptorSetLayout: return "DescriptorSetLayout"; + case ObjectType::eSampler: return "Sampler"; + case ObjectType::eDescriptorPool: return "DescriptorPool"; + case ObjectType::eDescriptorSet: return "DescriptorSet"; + case ObjectType::eFramebuffer: return "Framebuffer"; + case ObjectType::eCommandPool: return "CommandPool"; + case ObjectType::eSamplerYcbcrConversion: return "SamplerYcbcrConversion"; + case ObjectType::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate"; + case ObjectType::eSurfaceKHR: return "SurfaceKHR"; + case ObjectType::eSwapchainKHR: return "SwapchainKHR"; + case ObjectType::eDisplayKHR: return "DisplayKHR"; + case ObjectType::eDisplayModeKHR: return "DisplayModeKHR"; + case ObjectType::eDebugReportCallbackEXT: return "DebugReportCallbackEXT"; + case ObjectType::eObjectTableNVX: return "ObjectTableNVX"; + case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX"; + case ObjectType::eDebugUtilsMessengerEXT: return "DebugUtilsMessengerEXT"; + case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value) + { + switch (value) + { + case QueueFlagBits::eGraphics: return "Graphics"; + case QueueFlagBits::eCompute: return "Compute"; + case QueueFlagBits::eTransfer: return "Transfer"; + case QueueFlagBits::eSparseBinding: return "SparseBinding"; + case QueueFlagBits::eProtected: return "Protected"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueueFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & QueueFlagBits::eGraphics) result += "Graphics | "; + if (value & QueueFlagBits::eCompute) result += "Compute | "; + if (value & QueueFlagBits::eTransfer) result += "Transfer | "; + if (value & QueueFlagBits::eSparseBinding) result += "SparseBinding | "; + if (value & QueueFlagBits::eProtected) result += "Protected | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlagBits value) + { + switch (value) + { + case DeviceQueueCreateFlagBits::eProtected: return "Protected"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & DeviceQueueCreateFlagBits::eProtected) result += "Protected | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlagBits value) + { + switch (value) + { + case MemoryPropertyFlagBits::eDeviceLocal: return "DeviceLocal"; + case MemoryPropertyFlagBits::eHostVisible: return "HostVisible"; + case MemoryPropertyFlagBits::eHostCoherent: return "HostCoherent"; + case MemoryPropertyFlagBits::eHostCached: return "HostCached"; + case MemoryPropertyFlagBits::eLazilyAllocated: return "LazilyAllocated"; + case MemoryPropertyFlagBits::eProtected: return "Protected"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & MemoryPropertyFlagBits::eDeviceLocal) result += "DeviceLocal | "; + if (value & MemoryPropertyFlagBits::eHostVisible) result += "HostVisible | "; + if (value & MemoryPropertyFlagBits::eHostCoherent) result += "HostCoherent | "; + if (value & MemoryPropertyFlagBits::eHostCached) result += "HostCached | "; + if (value & MemoryPropertyFlagBits::eLazilyAllocated) result += "LazilyAllocated | "; + if (value & MemoryPropertyFlagBits::eProtected) result += "Protected | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlagBits value) + { + switch (value) + { + case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal"; + case MemoryHeapFlagBits::eMultiInstance: return "MultiInstance"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | "; + if (value & MemoryHeapFlagBits::eMultiInstance) result += "MultiInstance | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(AccessFlagBits value) + { + switch (value) + { + case AccessFlagBits::eIndirectCommandRead: return "IndirectCommandRead"; + case AccessFlagBits::eIndexRead: return "IndexRead"; + case AccessFlagBits::eVertexAttributeRead: return "VertexAttributeRead"; + case AccessFlagBits::eUniformRead: return "UniformRead"; + case AccessFlagBits::eInputAttachmentRead: return "InputAttachmentRead"; + case AccessFlagBits::eShaderRead: return "ShaderRead"; + case AccessFlagBits::eShaderWrite: return "ShaderWrite"; + case AccessFlagBits::eColorAttachmentRead: return "ColorAttachmentRead"; + case AccessFlagBits::eColorAttachmentWrite: return "ColorAttachmentWrite"; + case AccessFlagBits::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead"; + case AccessFlagBits::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite"; + case AccessFlagBits::eTransferRead: return "TransferRead"; + case AccessFlagBits::eTransferWrite: return "TransferWrite"; + case AccessFlagBits::eHostRead: return "HostRead"; + case AccessFlagBits::eHostWrite: return "HostWrite"; + case AccessFlagBits::eMemoryRead: return "MemoryRead"; + case AccessFlagBits::eMemoryWrite: return "MemoryWrite"; + case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX"; + case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX"; + case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(AccessFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & AccessFlagBits::eIndirectCommandRead) result += "IndirectCommandRead | "; + if (value & AccessFlagBits::eIndexRead) result += "IndexRead | "; + if (value & AccessFlagBits::eVertexAttributeRead) result += "VertexAttributeRead | "; + if (value & AccessFlagBits::eUniformRead) result += "UniformRead | "; + if (value & AccessFlagBits::eInputAttachmentRead) result += "InputAttachmentRead | "; + if (value & AccessFlagBits::eShaderRead) result += "ShaderRead | "; + if (value & AccessFlagBits::eShaderWrite) result += "ShaderWrite | "; + if (value & AccessFlagBits::eColorAttachmentRead) result += "ColorAttachmentRead | "; + if (value & AccessFlagBits::eColorAttachmentWrite) result += "ColorAttachmentWrite | "; + if (value & AccessFlagBits::eDepthStencilAttachmentRead) result += "DepthStencilAttachmentRead | "; + if (value & AccessFlagBits::eDepthStencilAttachmentWrite) result += "DepthStencilAttachmentWrite | "; + if (value & AccessFlagBits::eTransferRead) result += "TransferRead | "; + if (value & AccessFlagBits::eTransferWrite) result += "TransferWrite | "; + if (value & AccessFlagBits::eHostRead) result += "HostRead | "; + if (value & AccessFlagBits::eHostWrite) result += "HostWrite | "; + if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | "; + if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | "; + if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | "; + if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | "; + if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(BufferUsageFlagBits value) + { + switch (value) + { + case BufferUsageFlagBits::eTransferSrc: return "TransferSrc"; + case BufferUsageFlagBits::eTransferDst: return "TransferDst"; + case BufferUsageFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer"; + case BufferUsageFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer"; + case BufferUsageFlagBits::eUniformBuffer: return "UniformBuffer"; + case BufferUsageFlagBits::eStorageBuffer: return "StorageBuffer"; + case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer"; + case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer"; + case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(BufferUsageFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & BufferUsageFlagBits::eTransferSrc) result += "TransferSrc | "; + if (value & BufferUsageFlagBits::eTransferDst) result += "TransferDst | "; + if (value & BufferUsageFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | "; + if (value & BufferUsageFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | "; + if (value & BufferUsageFlagBits::eUniformBuffer) result += "UniformBuffer | "; + if (value & BufferUsageFlagBits::eStorageBuffer) result += "StorageBuffer | "; + if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | "; + if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | "; + if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(BufferCreateFlagBits value) + { + switch (value) + { + case BufferCreateFlagBits::eSparseBinding: return "SparseBinding"; + case BufferCreateFlagBits::eSparseResidency: return "SparseResidency"; + case BufferCreateFlagBits::eSparseAliased: return "SparseAliased"; + case BufferCreateFlagBits::eProtected: return "Protected"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(BufferCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & BufferCreateFlagBits::eSparseBinding) result += "SparseBinding | "; + if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | "; + if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | "; + if (value & BufferCreateFlagBits::eProtected) result += "Protected | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ShaderStageFlagBits value) + { + switch (value) + { + case ShaderStageFlagBits::eVertex: return "Vertex"; + case ShaderStageFlagBits::eTessellationControl: return "TessellationControl"; + case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation"; + case ShaderStageFlagBits::eGeometry: return "Geometry"; + case ShaderStageFlagBits::eFragment: return "Fragment"; + case ShaderStageFlagBits::eCompute: return "Compute"; + case ShaderStageFlagBits::eAllGraphics: return "AllGraphics"; + case ShaderStageFlagBits::eAll: return "All"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ShaderStageFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ShaderStageFlagBits::eVertex) result += "Vertex | "; + if (value & ShaderStageFlagBits::eTessellationControl) result += "TessellationControl | "; + if (value & ShaderStageFlagBits::eTessellationEvaluation) result += "TessellationEvaluation | "; + if (value & ShaderStageFlagBits::eGeometry) result += "Geometry | "; + if (value & ShaderStageFlagBits::eFragment) result += "Fragment | "; + if (value & ShaderStageFlagBits::eCompute) result += "Compute | "; + if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | "; + if (value & ShaderStageFlagBits::eAll) result += "All | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ImageUsageFlagBits value) + { + switch (value) + { + case ImageUsageFlagBits::eTransferSrc: return "TransferSrc"; + case ImageUsageFlagBits::eTransferDst: return "TransferDst"; + case ImageUsageFlagBits::eSampled: return "Sampled"; + case ImageUsageFlagBits::eStorage: return "Storage"; + case ImageUsageFlagBits::eColorAttachment: return "ColorAttachment"; + case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment"; + case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment"; + case ImageUsageFlagBits::eInputAttachment: return "InputAttachment"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ImageUsageFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ImageUsageFlagBits::eTransferSrc) result += "TransferSrc | "; + if (value & ImageUsageFlagBits::eTransferDst) result += "TransferDst | "; + if (value & ImageUsageFlagBits::eSampled) result += "Sampled | "; + if (value & ImageUsageFlagBits::eStorage) result += "Storage | "; + if (value & ImageUsageFlagBits::eColorAttachment) result += "ColorAttachment | "; + if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | "; + if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | "; + if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ImageCreateFlagBits value) + { + switch (value) + { + case ImageCreateFlagBits::eSparseBinding: return "SparseBinding"; + case ImageCreateFlagBits::eSparseResidency: return "SparseResidency"; + case ImageCreateFlagBits::eSparseAliased: return "SparseAliased"; + case ImageCreateFlagBits::eMutableFormat: return "MutableFormat"; + case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible"; + case ImageCreateFlagBits::eAlias: return "Alias"; + case ImageCreateFlagBits::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; + case ImageCreateFlagBits::e2DArrayCompatible: return "2DArrayCompatible"; + case ImageCreateFlagBits::eBlockTexelViewCompatible: return "BlockTexelViewCompatible"; + case ImageCreateFlagBits::eExtendedUsage: return "ExtendedUsage"; + case ImageCreateFlagBits::eProtected: return "Protected"; + case ImageCreateFlagBits::eDisjoint: return "Disjoint"; + case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ImageCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ImageCreateFlagBits::eSparseBinding) result += "SparseBinding | "; + if (value & ImageCreateFlagBits::eSparseResidency) result += "SparseResidency | "; + if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | "; + if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | "; + if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | "; + if (value & ImageCreateFlagBits::eAlias) result += "Alias | "; + if (value & ImageCreateFlagBits::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | "; + if (value & ImageCreateFlagBits::e2DArrayCompatible) result += "2DArrayCompatible | "; + if (value & ImageCreateFlagBits::eBlockTexelViewCompatible) result += "BlockTexelViewCompatible | "; + if (value & ImageCreateFlagBits::eExtendedUsage) result += "ExtendedUsage | "; + if (value & ImageCreateFlagBits::eProtected) result += "Protected | "; + if (value & ImageCreateFlagBits::eDisjoint) result += "Disjoint | "; + if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlagBits value) + { + switch (value) + { + case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization"; + case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives"; + case PipelineCreateFlagBits::eDerivative: return "Derivative"; + case PipelineCreateFlagBits::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex"; + case PipelineCreateFlagBits::eDispatchBase: return "DispatchBase"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | "; + if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | "; + if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | "; + if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex) result += "ViewIndexFromDeviceIndex | "; + if (value & PipelineCreateFlagBits::eDispatchBase) result += "DispatchBase | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ColorComponentFlagBits value) + { + switch (value) + { + case ColorComponentFlagBits::eR: return "R"; + case ColorComponentFlagBits::eG: return "G"; + case ColorComponentFlagBits::eB: return "B"; + case ColorComponentFlagBits::eA: return "A"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ColorComponentFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ColorComponentFlagBits::eR) result += "R | "; + if (value & ColorComponentFlagBits::eG) result += "G | "; + if (value & ColorComponentFlagBits::eB) result += "B | "; + if (value & ColorComponentFlagBits::eA) result += "A | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(FenceCreateFlagBits value) + { + switch (value) + { + case FenceCreateFlagBits::eSignaled: return "Signaled"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(FenceCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & FenceCreateFlagBits::eSignaled) result += "Signaled | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlagBits value) + { + switch (value) + { + case FormatFeatureFlagBits::eSampledImage: return "SampledImage"; + case FormatFeatureFlagBits::eStorageImage: return "StorageImage"; + case FormatFeatureFlagBits::eStorageImageAtomic: return "StorageImageAtomic"; + case FormatFeatureFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer"; + case FormatFeatureFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer"; + case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "StorageTexelBufferAtomic"; + case FormatFeatureFlagBits::eVertexBuffer: return "VertexBuffer"; + case FormatFeatureFlagBits::eColorAttachment: return "ColorAttachment"; + case FormatFeatureFlagBits::eColorAttachmentBlend: return "ColorAttachmentBlend"; + case FormatFeatureFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment"; + case FormatFeatureFlagBits::eBlitSrc: return "BlitSrc"; + case FormatFeatureFlagBits::eBlitDst: return "BlitDst"; + case FormatFeatureFlagBits::eSampledImageFilterLinear: return "SampledImageFilterLinear"; + case FormatFeatureFlagBits::eTransferSrc: return "TransferSrc"; + case FormatFeatureFlagBits::eTransferDst: return "TransferDst"; + case FormatFeatureFlagBits::eMidpointChromaSamples: return "MidpointChromaSamples"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter: return "SampledImageYcbcrConversionLinearFilter"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable"; + case FormatFeatureFlagBits::eDisjoint: return "Disjoint"; + case FormatFeatureFlagBits::eCositedChromaSamples: return "CositedChromaSamples"; + case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG"; + case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & FormatFeatureFlagBits::eSampledImage) result += "SampledImage | "; + if (value & FormatFeatureFlagBits::eStorageImage) result += "StorageImage | "; + if (value & FormatFeatureFlagBits::eStorageImageAtomic) result += "StorageImageAtomic | "; + if (value & FormatFeatureFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | "; + if (value & FormatFeatureFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | "; + if (value & FormatFeatureFlagBits::eStorageTexelBufferAtomic) result += "StorageTexelBufferAtomic | "; + if (value & FormatFeatureFlagBits::eVertexBuffer) result += "VertexBuffer | "; + if (value & FormatFeatureFlagBits::eColorAttachment) result += "ColorAttachment | "; + if (value & FormatFeatureFlagBits::eColorAttachmentBlend) result += "ColorAttachmentBlend | "; + if (value & FormatFeatureFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | "; + if (value & FormatFeatureFlagBits::eBlitSrc) result += "BlitSrc | "; + if (value & FormatFeatureFlagBits::eBlitDst) result += "BlitDst | "; + if (value & FormatFeatureFlagBits::eSampledImageFilterLinear) result += "SampledImageFilterLinear | "; + if (value & FormatFeatureFlagBits::eTransferSrc) result += "TransferSrc | "; + if (value & FormatFeatureFlagBits::eTransferDst) result += "TransferDst | "; + if (value & FormatFeatureFlagBits::eMidpointChromaSamples) result += "MidpointChromaSamples | "; + if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) result += "SampledImageYcbcrConversionLinearFilter | "; + if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) result += "SampledImageYcbcrConversionSeparateReconstructionFilter | "; + if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) result += "SampledImageYcbcrConversionChromaReconstructionExplicit | "; + if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | "; + if (value & FormatFeatureFlagBits::eDisjoint) result += "Disjoint | "; + if (value & FormatFeatureFlagBits::eCositedChromaSamples) result += "CositedChromaSamples | "; + if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | "; + if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(QueryControlFlagBits value) + { + switch (value) + { + case QueryControlFlagBits::ePrecise: return "Precise"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueryControlFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & QueryControlFlagBits::ePrecise) result += "Precise | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(QueryResultFlagBits value) + { + switch (value) + { + case QueryResultFlagBits::e64: return "64"; + case QueryResultFlagBits::eWait: return "Wait"; + case QueryResultFlagBits::eWithAvailability: return "WithAvailability"; + case QueryResultFlagBits::ePartial: return "Partial"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueryResultFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & QueryResultFlagBits::e64) result += "64 | "; + if (value & QueryResultFlagBits::eWait) result += "Wait | "; + if (value & QueryResultFlagBits::eWithAvailability) result += "WithAvailability | "; + if (value & QueryResultFlagBits::ePartial) result += "Partial | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlagBits value) + { + switch (value) + { + case CommandBufferUsageFlagBits::eOneTimeSubmit: return "OneTimeSubmit"; + case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue"; + case CommandBufferUsageFlagBits::eSimultaneousUse: return "SimultaneousUse"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & CommandBufferUsageFlagBits::eOneTimeSubmit) result += "OneTimeSubmit | "; + if (value & CommandBufferUsageFlagBits::eRenderPassContinue) result += "RenderPassContinue | "; + if (value & CommandBufferUsageFlagBits::eSimultaneousUse) result += "SimultaneousUse | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlagBits value) + { + switch (value) + { + case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "InputAssemblyVertices"; + case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "InputAssemblyPrimitives"; + case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "VertexShaderInvocations"; + case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "GeometryShaderInvocations"; + case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "GeometryShaderPrimitives"; + case QueryPipelineStatisticFlagBits::eClippingInvocations: return "ClippingInvocations"; + case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "ClippingPrimitives"; + case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "FragmentShaderInvocations"; + case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches"; + case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations"; + case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices) result += "InputAssemblyVertices | "; + if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) result += "InputAssemblyPrimitives | "; + if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations) result += "VertexShaderInvocations | "; + if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) result += "GeometryShaderInvocations | "; + if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) result += "GeometryShaderPrimitives | "; + if (value & QueryPipelineStatisticFlagBits::eClippingInvocations) result += "ClippingInvocations | "; + if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives) result += "ClippingPrimitives | "; + if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) result += "FragmentShaderInvocations | "; + if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) result += "TessellationControlShaderPatches | "; + if (value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) result += "TessellationEvaluationShaderInvocations | "; + if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations) result += "ComputeShaderInvocations | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ImageAspectFlagBits value) + { + switch (value) + { + case ImageAspectFlagBits::eColor: return "Color"; + case ImageAspectFlagBits::eDepth: return "Depth"; + case ImageAspectFlagBits::eStencil: return "Stencil"; + case ImageAspectFlagBits::eMetadata: return "Metadata"; + case ImageAspectFlagBits::ePlane0: return "Plane0"; + case ImageAspectFlagBits::ePlane1: return "Plane1"; + case ImageAspectFlagBits::ePlane2: return "Plane2"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ImageAspectFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ImageAspectFlagBits::eColor) result += "Color | "; + if (value & ImageAspectFlagBits::eDepth) result += "Depth | "; + if (value & ImageAspectFlagBits::eStencil) result += "Stencil | "; + if (value & ImageAspectFlagBits::eMetadata) result += "Metadata | "; + if (value & ImageAspectFlagBits::ePlane0) result += "Plane0 | "; + if (value & ImageAspectFlagBits::ePlane1) result += "Plane1 | "; + if (value & ImageAspectFlagBits::ePlane2) result += "Plane2 | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlagBits value) + { + switch (value) + { + case SparseImageFormatFlagBits::eSingleMiptail: return "SingleMiptail"; + case SparseImageFormatFlagBits::eAlignedMipSize: return "AlignedMipSize"; + case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & SparseImageFormatFlagBits::eSingleMiptail) result += "SingleMiptail | "; + if (value & SparseImageFormatFlagBits::eAlignedMipSize) result += "AlignedMipSize | "; + if (value & SparseImageFormatFlagBits::eNonstandardBlockSize) result += "NonstandardBlockSize | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlagBits value) + { + switch (value) + { + case SparseMemoryBindFlagBits::eMetadata: return "Metadata"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & SparseMemoryBindFlagBits::eMetadata) result += "Metadata | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits value) + { + switch (value) + { + case PipelineStageFlagBits::eTopOfPipe: return "TopOfPipe"; + case PipelineStageFlagBits::eDrawIndirect: return "DrawIndirect"; + case PipelineStageFlagBits::eVertexInput: return "VertexInput"; + case PipelineStageFlagBits::eVertexShader: return "VertexShader"; + case PipelineStageFlagBits::eTessellationControlShader: return "TessellationControlShader"; + case PipelineStageFlagBits::eTessellationEvaluationShader: return "TessellationEvaluationShader"; + case PipelineStageFlagBits::eGeometryShader: return "GeometryShader"; + case PipelineStageFlagBits::eFragmentShader: return "FragmentShader"; + case PipelineStageFlagBits::eEarlyFragmentTests: return "EarlyFragmentTests"; + case PipelineStageFlagBits::eLateFragmentTests: return "LateFragmentTests"; + case PipelineStageFlagBits::eColorAttachmentOutput: return "ColorAttachmentOutput"; + case PipelineStageFlagBits::eComputeShader: return "ComputeShader"; + case PipelineStageFlagBits::eTransfer: return "Transfer"; + case PipelineStageFlagBits::eBottomOfPipe: return "BottomOfPipe"; + case PipelineStageFlagBits::eHost: return "Host"; + case PipelineStageFlagBits::eAllGraphics: return "AllGraphics"; + case PipelineStageFlagBits::eAllCommands: return "AllCommands"; + case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PipelineStageFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & PipelineStageFlagBits::eTopOfPipe) result += "TopOfPipe | "; + if (value & PipelineStageFlagBits::eDrawIndirect) result += "DrawIndirect | "; + if (value & PipelineStageFlagBits::eVertexInput) result += "VertexInput | "; + if (value & PipelineStageFlagBits::eVertexShader) result += "VertexShader | "; + if (value & PipelineStageFlagBits::eTessellationControlShader) result += "TessellationControlShader | "; + if (value & PipelineStageFlagBits::eTessellationEvaluationShader) result += "TessellationEvaluationShader | "; + if (value & PipelineStageFlagBits::eGeometryShader) result += "GeometryShader | "; + if (value & PipelineStageFlagBits::eFragmentShader) result += "FragmentShader | "; + if (value & PipelineStageFlagBits::eEarlyFragmentTests) result += "EarlyFragmentTests | "; + if (value & PipelineStageFlagBits::eLateFragmentTests) result += "LateFragmentTests | "; + if (value & PipelineStageFlagBits::eColorAttachmentOutput) result += "ColorAttachmentOutput | "; + if (value & PipelineStageFlagBits::eComputeShader) result += "ComputeShader | "; + if (value & PipelineStageFlagBits::eTransfer) result += "Transfer | "; + if (value & PipelineStageFlagBits::eBottomOfPipe) result += "BottomOfPipe | "; + if (value & PipelineStageFlagBits::eHost) result += "Host | "; + if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | "; + if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | "; + if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlagBits value) + { + switch (value) + { + case CommandPoolCreateFlagBits::eTransient: return "Transient"; + case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer"; + case CommandPoolCreateFlagBits::eProtected: return "Protected"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & CommandPoolCreateFlagBits::eTransient) result += "Transient | "; + if (value & CommandPoolCreateFlagBits::eResetCommandBuffer) result += "ResetCommandBuffer | "; + if (value & CommandPoolCreateFlagBits::eProtected) result += "Protected | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlagBits value) + { + switch (value) + { + case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & CommandPoolResetFlagBits::eReleaseResources) result += "ReleaseResources | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlagBits value) + { + switch (value) + { + case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & CommandBufferResetFlagBits::eReleaseResources) result += "ReleaseResources | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SampleCountFlagBits value) + { + switch (value) + { + case SampleCountFlagBits::e1: return "1"; + case SampleCountFlagBits::e2: return "2"; + case SampleCountFlagBits::e4: return "4"; + case SampleCountFlagBits::e8: return "8"; + case SampleCountFlagBits::e16: return "16"; + case SampleCountFlagBits::e32: return "32"; + case SampleCountFlagBits::e64: return "64"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SampleCountFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & SampleCountFlagBits::e1) result += "1 | "; + if (value & SampleCountFlagBits::e2) result += "2 | "; + if (value & SampleCountFlagBits::e4) result += "4 | "; + if (value & SampleCountFlagBits::e8) result += "8 | "; + if (value & SampleCountFlagBits::e16) result += "16 | "; + if (value & SampleCountFlagBits::e32) result += "32 | "; + if (value & SampleCountFlagBits::e64) result += "64 | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlagBits value) + { + switch (value) + { + case AttachmentDescriptionFlagBits::eMayAlias: return "MayAlias"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & AttachmentDescriptionFlagBits::eMayAlias) result += "MayAlias | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(StencilFaceFlagBits value) + { + switch (value) + { + case StencilFaceFlagBits::eFront: return "Front"; + case StencilFaceFlagBits::eBack: return "Back"; + case StencilFaceFlagBits::eVkStencilFrontAndBack: return "VkStencilFrontAndBack"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(StencilFaceFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & StencilFaceFlagBits::eFront) result += "Front | "; + if (value & StencilFaceFlagBits::eBack) result += "Back | "; + if (value & StencilFaceFlagBits::eVkStencilFrontAndBack) result += "VkStencilFrontAndBack | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlagBits value) + { + switch (value) + { + case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet"; + case DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT: return "UpdateAfterBindEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet) result += "FreeDescriptorSet | "; + if (value & DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT) result += "UpdateAfterBindEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DependencyFlagBits value) + { + switch (value) + { + case DependencyFlagBits::eByRegion: return "ByRegion"; + case DependencyFlagBits::eDeviceGroup: return "DeviceGroup"; + case DependencyFlagBits::eViewLocal: return "ViewLocal"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DependencyFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & DependencyFlagBits::eByRegion) result += "ByRegion | "; + if (value & DependencyFlagBits::eDeviceGroup) result += "DeviceGroup | "; + if (value & DependencyFlagBits::eViewLocal) result += "ViewLocal | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(PresentModeKHR value) + { + switch (value) + { + case PresentModeKHR::eImmediate: return "Immediate"; + case PresentModeKHR::eMailbox: return "Mailbox"; + case PresentModeKHR::eFifo: return "Fifo"; + case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed"; + case PresentModeKHR::eSharedDemandRefresh: return "SharedDemandRefresh"; + case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ColorSpaceKHR value) + { + switch (value) + { + case ColorSpaceKHR::eSrgbNonlinear: return "SrgbNonlinear"; + case ColorSpaceKHR::eDisplayP3NonlinearEXT: return "DisplayP3NonlinearEXT"; + case ColorSpaceKHR::eExtendedSrgbLinearEXT: return "ExtendedSrgbLinearEXT"; + case ColorSpaceKHR::eDciP3LinearEXT: return "DciP3LinearEXT"; + case ColorSpaceKHR::eDciP3NonlinearEXT: return "DciP3NonlinearEXT"; + case ColorSpaceKHR::eBt709LinearEXT: return "Bt709LinearEXT"; + case ColorSpaceKHR::eBt709NonlinearEXT: return "Bt709NonlinearEXT"; + case ColorSpaceKHR::eBt2020LinearEXT: return "Bt2020LinearEXT"; + case ColorSpaceKHR::eHdr10St2084EXT: return "Hdr10St2084EXT"; + case ColorSpaceKHR::eDolbyvisionEXT: return "DolbyvisionEXT"; + case ColorSpaceKHR::eHdr10HlgEXT: return "Hdr10HlgEXT"; + case ColorSpaceKHR::eAdobergbLinearEXT: return "AdobergbLinearEXT"; + case ColorSpaceKHR::eAdobergbNonlinearEXT: return "AdobergbNonlinearEXT"; + case ColorSpaceKHR::ePassThroughEXT: return "PassThroughEXT"; + case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagBitsKHR value) + { + switch (value) + { + case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "Opaque"; + case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "Global"; + case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "PerPixel"; + case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque) result += "Opaque | "; + if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal) result += "Global | "; + if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel) result += "PerPixel | "; + if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) result += "PerPixelPremultiplied | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagBitsKHR value) + { + switch (value) + { + case CompositeAlphaFlagBitsKHR::eOpaque: return "Opaque"; + case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "PreMultiplied"; + case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied"; + case CompositeAlphaFlagBitsKHR::eInherit: return "Inherit"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & CompositeAlphaFlagBitsKHR::eOpaque) result += "Opaque | "; + if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied) result += "PreMultiplied | "; + if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied) result += "PostMultiplied | "; + if (value & CompositeAlphaFlagBitsKHR::eInherit) result += "Inherit | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagBitsKHR value) + { + switch (value) + { + case SurfaceTransformFlagBitsKHR::eIdentity: return "Identity"; + case SurfaceTransformFlagBitsKHR::eRotate90: return "Rotate90"; + case SurfaceTransformFlagBitsKHR::eRotate180: return "Rotate180"; + case SurfaceTransformFlagBitsKHR::eRotate270: return "Rotate270"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "HorizontalMirror"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "HorizontalMirrorRotate90"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270"; + case SurfaceTransformFlagBitsKHR::eInherit: return "Inherit"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & SurfaceTransformFlagBitsKHR::eIdentity) result += "Identity | "; + if (value & SurfaceTransformFlagBitsKHR::eRotate90) result += "Rotate90 | "; + if (value & SurfaceTransformFlagBitsKHR::eRotate180) result += "Rotate180 | "; + if (value & SurfaceTransformFlagBitsKHR::eRotate270) result += "Rotate270 | "; + if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror) result += "HorizontalMirror | "; + if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) result += "HorizontalMirrorRotate90 | "; + if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) result += "HorizontalMirrorRotate180 | "; + if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) result += "HorizontalMirrorRotate270 | "; + if (value & SurfaceTransformFlagBitsKHR::eInherit) result += "Inherit | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value) + { + switch (value) + { + case DebugReportFlagBitsEXT::eInformation: return "Information"; + case DebugReportFlagBitsEXT::eWarning: return "Warning"; + case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning"; + case DebugReportFlagBitsEXT::eError: return "Error"; + case DebugReportFlagBitsEXT::eDebug: return "Debug"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DebugReportFlagsEXT value) + { + if (!value) return "{}"; + std::string result; + if (value & DebugReportFlagBitsEXT::eInformation) result += "Information | "; + if (value & DebugReportFlagBitsEXT::eWarning) result += "Warning | "; + if (value & DebugReportFlagBitsEXT::ePerformanceWarning) result += "PerformanceWarning | "; + if (value & DebugReportFlagBitsEXT::eError) result += "Error | "; + if (value & DebugReportFlagBitsEXT::eDebug) result += "Debug | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DebugReportObjectTypeEXT value) + { + switch (value) + { + case DebugReportObjectTypeEXT::eUnknown: return "Unknown"; + case DebugReportObjectTypeEXT::eInstance: return "Instance"; + case DebugReportObjectTypeEXT::ePhysicalDevice: return "PhysicalDevice"; + case DebugReportObjectTypeEXT::eDevice: return "Device"; + case DebugReportObjectTypeEXT::eQueue: return "Queue"; + case DebugReportObjectTypeEXT::eSemaphore: return "Semaphore"; + case DebugReportObjectTypeEXT::eCommandBuffer: return "CommandBuffer"; + case DebugReportObjectTypeEXT::eFence: return "Fence"; + case DebugReportObjectTypeEXT::eDeviceMemory: return "DeviceMemory"; + case DebugReportObjectTypeEXT::eBuffer: return "Buffer"; + case DebugReportObjectTypeEXT::eImage: return "Image"; + case DebugReportObjectTypeEXT::eEvent: return "Event"; + case DebugReportObjectTypeEXT::eQueryPool: return "QueryPool"; + case DebugReportObjectTypeEXT::eBufferView: return "BufferView"; + case DebugReportObjectTypeEXT::eImageView: return "ImageView"; + case DebugReportObjectTypeEXT::eShaderModule: return "ShaderModule"; + case DebugReportObjectTypeEXT::ePipelineCache: return "PipelineCache"; + case DebugReportObjectTypeEXT::ePipelineLayout: return "PipelineLayout"; + case DebugReportObjectTypeEXT::eRenderPass: return "RenderPass"; + case DebugReportObjectTypeEXT::ePipeline: return "Pipeline"; + case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DescriptorSetLayout"; + case DebugReportObjectTypeEXT::eSampler: return "Sampler"; + case DebugReportObjectTypeEXT::eDescriptorPool: return "DescriptorPool"; + case DebugReportObjectTypeEXT::eDescriptorSet: return "DescriptorSet"; + case DebugReportObjectTypeEXT::eFramebuffer: return "Framebuffer"; + case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool"; + case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr"; + case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr"; + case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt"; + case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr"; + case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr"; + case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx"; + case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNvx: return "IndirectCommandsLayoutNvx"; + case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt"; + case DebugReportObjectTypeEXT::eSamplerYcbcrConversion: return "SamplerYcbcrConversion"; + case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value) + { + switch (value) + { + case RasterizationOrderAMD::eStrict: return "Strict"; + case RasterizationOrderAMD::eRelaxed: return "Relaxed"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsNV value) + { + switch (value) + { + case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32: return "OpaqueWin32"; + case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image: return "D3D11Image"; + case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt: return "D3D11ImageKmt"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsNV value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) result += "D3D11Image | "; + if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) result += "D3D11ImageKmt | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsNV value) + { + switch (value) + { + case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly"; + case ExternalMemoryFeatureFlagBitsNV::eExportable: return "Exportable"; + case ExternalMemoryFeatureFlagBitsNV::eImportable: return "Importable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsNV value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) result += "DedicatedOnly | "; + if (value & ExternalMemoryFeatureFlagBitsNV::eExportable) result += "Exportable | "; + if (value & ExternalMemoryFeatureFlagBitsNV::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ValidationCheckEXT value) + { + switch (value) + { + case ValidationCheckEXT::eAll: return "All"; + case ValidationCheckEXT::eShaders: return "Shaders"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlagBits value) + { + switch (value) + { + case SubgroupFeatureFlagBits::eBasic: return "Basic"; + case SubgroupFeatureFlagBits::eVote: return "Vote"; + case SubgroupFeatureFlagBits::eArithmetic: return "Arithmetic"; + case SubgroupFeatureFlagBits::eBallot: return "Ballot"; + case SubgroupFeatureFlagBits::eShuffle: return "Shuffle"; + case SubgroupFeatureFlagBits::eShuffleRelative: return "ShuffleRelative"; + case SubgroupFeatureFlagBits::eClustered: return "Clustered"; + case SubgroupFeatureFlagBits::eQuad: return "Quad"; + case SubgroupFeatureFlagBits::ePartitionedNV: return "PartitionedNV"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & SubgroupFeatureFlagBits::eBasic) result += "Basic | "; + if (value & SubgroupFeatureFlagBits::eVote) result += "Vote | "; + if (value & SubgroupFeatureFlagBits::eArithmetic) result += "Arithmetic | "; + if (value & SubgroupFeatureFlagBits::eBallot) result += "Ballot | "; + if (value & SubgroupFeatureFlagBits::eShuffle) result += "Shuffle | "; + if (value & SubgroupFeatureFlagBits::eShuffleRelative) result += "ShuffleRelative | "; + if (value & SubgroupFeatureFlagBits::eClustered) result += "Clustered | "; + if (value & SubgroupFeatureFlagBits::eQuad) result += "Quad | "; + if (value & SubgroupFeatureFlagBits::ePartitionedNV) result += "PartitionedNV | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagBitsNVX value) + { + switch (value) + { + case IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences: return "UnorderedSequences"; + case IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences: return "SparseSequences"; + case IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions: return "EmptyExecutions"; + case IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences: return "IndexedSequences"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagsNVX value) + { + if (!value) return "{}"; + std::string result; + if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) result += "UnorderedSequences | "; + if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) result += "SparseSequences | "; + if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) result += "EmptyExecutions | "; + if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) result += "IndexedSequences | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagBitsNVX value) + { + switch (value) + { + case ObjectEntryUsageFlagBitsNVX::eGraphics: return "Graphics"; + case ObjectEntryUsageFlagBitsNVX::eCompute: return "Compute"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagsNVX value) + { + if (!value) return "{}"; + std::string result; + if (value & ObjectEntryUsageFlagBitsNVX::eGraphics) result += "Graphics | "; + if (value & ObjectEntryUsageFlagBitsNVX::eCompute) result += "Compute | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(IndirectCommandsTokenTypeNVX value) + { + switch (value) + { + case IndirectCommandsTokenTypeNVX::ePipeline: return "Pipeline"; + case IndirectCommandsTokenTypeNVX::eDescriptorSet: return "DescriptorSet"; + case IndirectCommandsTokenTypeNVX::eIndexBuffer: return "IndexBuffer"; + case IndirectCommandsTokenTypeNVX::eVertexBuffer: return "VertexBuffer"; + case IndirectCommandsTokenTypeNVX::ePushConstant: return "PushConstant"; + case IndirectCommandsTokenTypeNVX::eDrawIndexed: return "DrawIndexed"; + case IndirectCommandsTokenTypeNVX::eDraw: return "Draw"; + case IndirectCommandsTokenTypeNVX::eDispatch: return "Dispatch"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ObjectEntryTypeNVX value) + { + switch (value) + { + case ObjectEntryTypeNVX::eDescriptorSet: return "DescriptorSet"; + case ObjectEntryTypeNVX::ePipeline: return "Pipeline"; + case ObjectEntryTypeNVX::eIndexBuffer: return "IndexBuffer"; + case ObjectEntryTypeNVX::eVertexBuffer: return "VertexBuffer"; + case ObjectEntryTypeNVX::ePushConstant: return "PushConstant"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlagBits value) + { + switch (value) + { + case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR"; + case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT: return "UpdateAfterBindPoolEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) result += "PushDescriptorKHR | "; + if (value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT) result += "UpdateAfterBindPoolEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBits value) + { + switch (value) + { + case ExternalMemoryHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd"; + case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32"; + case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalMemoryHandleTypeFlagBits::eD3D11Texture: return "D3D11Texture"; + case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt: return "D3D11TextureKmt"; + case ExternalMemoryHandleTypeFlagBits::eD3D12Heap: return "D3D12Heap"; + case ExternalMemoryHandleTypeFlagBits::eD3D12Resource: return "D3D12Resource"; + case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT: return "DmaBufEXT"; + case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID: return "AndroidHardwareBufferANDROID"; + case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT: return "HostAllocationEXT"; + case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture) result += "D3D11Texture | "; + if (value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) result += "D3D11TextureKmt | "; + if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap) result += "D3D12Heap | "; + if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource) result += "D3D12Resource | "; + if (value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) result += "DmaBufEXT | "; + if (value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) result += "AndroidHardwareBufferANDROID | "; + if (value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) result += "HostAllocationEXT | "; + if (value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT) result += "HostMappedForeignMemoryEXT | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBits value) + { + switch (value) + { + case ExternalMemoryFeatureFlagBits::eDedicatedOnly: return "DedicatedOnly"; + case ExternalMemoryFeatureFlagBits::eExportable: return "Exportable"; + case ExternalMemoryFeatureFlagBits::eImportable: return "Importable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalMemoryFeatureFlagBits::eDedicatedOnly) result += "DedicatedOnly | "; + if (value & ExternalMemoryFeatureFlagBits::eExportable) result += "Exportable | "; + if (value & ExternalMemoryFeatureFlagBits::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBits value) + { + switch (value) + { + case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd"; + case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32"; + case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence: return "D3D12Fence"; + case ExternalSemaphoreHandleTypeFlagBits::eSyncFd: return "SyncFd"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) result += "D3D12Fence | "; + if (value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd) result += "SyncFd | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBits value) + { + switch (value) + { + case ExternalSemaphoreFeatureFlagBits::eExportable: return "Exportable"; + case ExternalSemaphoreFeatureFlagBits::eImportable: return "Importable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalSemaphoreFeatureFlagBits::eExportable) result += "Exportable | "; + if (value & ExternalSemaphoreFeatureFlagBits::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBits value) + { + switch (value) + { + case SemaphoreImportFlagBits::eTemporary: return "Temporary"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & SemaphoreImportFlagBits::eTemporary) result += "Temporary | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBits value) + { + switch (value) + { + case ExternalFenceHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd"; + case ExternalFenceHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32"; + case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalFenceHandleTypeFlagBits::eSyncFd: return "SyncFd"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalFenceHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalFenceHandleTypeFlagBits::eSyncFd) result += "SyncFd | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBits value) + { + switch (value) + { + case ExternalFenceFeatureFlagBits::eExportable: return "Exportable"; + case ExternalFenceFeatureFlagBits::eImportable: return "Importable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalFenceFeatureFlagBits::eExportable) result += "Exportable | "; + if (value & ExternalFenceFeatureFlagBits::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBits value) + { + switch (value) + { + case FenceImportFlagBits::eTemporary: return "Temporary"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(FenceImportFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & FenceImportFlagBits::eTemporary) result += "Temporary | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value) + { + switch (value) + { + case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagsEXT value) + { + if (!value) return "{}"; + std::string result; + if (value & SurfaceCounterFlagBitsEXT::eVblank) result += "Vblank | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DisplayPowerStateEXT value) + { + switch (value) + { + case DisplayPowerStateEXT::eOff: return "Off"; + case DisplayPowerStateEXT::eSuspend: return "Suspend"; + case DisplayPowerStateEXT::eOn: return "On"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DeviceEventTypeEXT value) + { + switch (value) + { + case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DisplayEventTypeEXT value) + { + switch (value) + { + case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBits value) + { + switch (value) + { + case PeerMemoryFeatureFlagBits::eCopySrc: return "CopySrc"; + case PeerMemoryFeatureFlagBits::eCopyDst: return "CopyDst"; + case PeerMemoryFeatureFlagBits::eGenericSrc: return "GenericSrc"; + case PeerMemoryFeatureFlagBits::eGenericDst: return "GenericDst"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & PeerMemoryFeatureFlagBits::eCopySrc) result += "CopySrc | "; + if (value & PeerMemoryFeatureFlagBits::eCopyDst) result += "CopyDst | "; + if (value & PeerMemoryFeatureFlagBits::eGenericSrc) result += "GenericSrc | "; + if (value & PeerMemoryFeatureFlagBits::eGenericDst) result += "GenericDst | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBits value) + { + switch (value) + { + case MemoryAllocateFlagBits::eDeviceMask: return "DeviceMask"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & MemoryAllocateFlagBits::eDeviceMask) result += "DeviceMask | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagBitsKHR value) + { + switch (value) + { + case DeviceGroupPresentModeFlagBitsKHR::eLocal: return "Local"; + case DeviceGroupPresentModeFlagBitsKHR::eRemote: return "Remote"; + case DeviceGroupPresentModeFlagBitsKHR::eSum: return "Sum"; + case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice: return "LocalMultiDevice"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & DeviceGroupPresentModeFlagBitsKHR::eLocal) result += "Local | "; + if (value & DeviceGroupPresentModeFlagBitsKHR::eRemote) result += "Remote | "; + if (value & DeviceGroupPresentModeFlagBitsKHR::eSum) result += "Sum | "; + if (value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice) result += "LocalMultiDevice | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagBitsKHR value) + { + switch (value) + { + case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; + case SwapchainCreateFlagBitsKHR::eProtected: return "Protected"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | "; + if (value & SwapchainCreateFlagBitsKHR::eProtected) result += "Protected | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value) + { + switch (value) + { + case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX"; + case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX"; + case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY"; + case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY"; + case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ"; + case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ"; + case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW"; + case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value) + { + switch (value) + { + case DiscardRectangleModeEXT::eInclusive: return "Inclusive"; + case DiscardRectangleModeEXT::eExclusive: return "Exclusive"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value) + { + switch (value) + { + case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX"; + case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value) + { + if (!value) return "{}"; + std::string result; + if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX) result += "PerViewAttributesNVX | "; + if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) result += "PerViewPositionXOnlyNVX | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(PointClippingBehavior value) + { + switch (value) + { + case PointClippingBehavior::eAllClipPlanes: return "AllClipPlanes"; + case PointClippingBehavior::eUserClipPlanesOnly: return "UserClipPlanesOnly"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SamplerReductionModeEXT value) + { + switch (value) + { + case SamplerReductionModeEXT::eWeightedAverage: return "WeightedAverage"; + case SamplerReductionModeEXT::eMin: return "Min"; + case SamplerReductionModeEXT::eMax: return "Max"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(TessellationDomainOrigin value) + { + switch (value) + { + case TessellationDomainOrigin::eUpperLeft: return "UpperLeft"; + case TessellationDomainOrigin::eLowerLeft: return "LowerLeft"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrModelConversion value) + { + switch (value) + { + case SamplerYcbcrModelConversion::eRgbIdentity: return "RgbIdentity"; + case SamplerYcbcrModelConversion::eYcbcrIdentity: return "YcbcrIdentity"; + case SamplerYcbcrModelConversion::eYcbcr709: return "Ycbcr709"; + case SamplerYcbcrModelConversion::eYcbcr601: return "Ycbcr601"; + case SamplerYcbcrModelConversion::eYcbcr2020: return "Ycbcr2020"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrRange value) + { + switch (value) + { + case SamplerYcbcrRange::eItuFull: return "ItuFull"; + case SamplerYcbcrRange::eItuNarrow: return "ItuNarrow"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ChromaLocation value) + { + switch (value) + { + case ChromaLocation::eCositedEven: return "CositedEven"; + case ChromaLocation::eMidpoint: return "Midpoint"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value) + { + switch (value) + { + case BlendOverlapEXT::eUncorrelated: return "Uncorrelated"; + case BlendOverlapEXT::eDisjoint: return "Disjoint"; + case BlendOverlapEXT::eConjoint: return "Conjoint"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value) + { + switch (value) + { + case CoverageModulationModeNV::eNone: return "None"; + case CoverageModulationModeNV::eRgb: return "Rgb"; + case CoverageModulationModeNV::eAlpha: return "Alpha"; + case CoverageModulationModeNV::eRgba: return "Rgba"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ValidationCacheHeaderVersionEXT value) + { + switch (value) + { + case ValidationCacheHeaderVersionEXT::eOne: return "One"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value) + { + switch (value) + { + case ShaderInfoTypeAMD::eStatistics: return "Statistics"; + case ShaderInfoTypeAMD::eBinary: return "Binary"; + case ShaderInfoTypeAMD::eDisassembly: return "Disassembly"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value) + { + switch (value) + { + case QueueGlobalPriorityEXT::eLow: return "Low"; + case QueueGlobalPriorityEXT::eMedium: return "Medium"; + case QueueGlobalPriorityEXT::eHigh: return "High"; + case QueueGlobalPriorityEXT::eRealtime: return "Realtime"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageSeverityFlagBitsEXT value) + { + switch (value) + { + case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose: return "Verbose"; + case DebugUtilsMessageSeverityFlagBitsEXT::eInfo: return "Info"; + case DebugUtilsMessageSeverityFlagBitsEXT::eWarning: return "Warning"; + case DebugUtilsMessageSeverityFlagBitsEXT::eError: return "Error"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageSeverityFlagsEXT value) + { + if (!value) return "{}"; + std::string result; + if (value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) result += "Verbose | "; + if (value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo) result += "Info | "; + if (value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning) result += "Warning | "; + if (value & DebugUtilsMessageSeverityFlagBitsEXT::eError) result += "Error | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagBitsEXT value) + { + switch (value) + { + case DebugUtilsMessageTypeFlagBitsEXT::eGeneral: return "General"; + case DebugUtilsMessageTypeFlagBitsEXT::eValidation: return "Validation"; + case DebugUtilsMessageTypeFlagBitsEXT::ePerformance: return "Performance"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagsEXT value) + { + if (!value) return "{}"; + std::string result; + if (value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral) result += "General | "; + if (value & DebugUtilsMessageTypeFlagBitsEXT::eValidation) result += "Validation | "; + if (value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance) result += "Performance | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ConservativeRasterizationModeEXT value) + { + switch (value) + { + case ConservativeRasterizationModeEXT::eDisabled: return "Disabled"; + case ConservativeRasterizationModeEXT::eOverestimate: return "Overestimate"; + case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagBitsEXT value) + { + switch (value) + { + case DescriptorBindingFlagBitsEXT::eUpdateAfterBind: return "UpdateAfterBind"; + case DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending: return "UpdateUnusedWhilePending"; + case DescriptorBindingFlagBitsEXT::ePartiallyBound: return "PartiallyBound"; + case DescriptorBindingFlagBitsEXT::eVariableDescriptorCount: return "VariableDescriptorCount"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagsEXT value) + { + if (!value) return "{}"; + std::string result; + if (value & DescriptorBindingFlagBitsEXT::eUpdateAfterBind) result += "UpdateAfterBind | "; + if (value & DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) result += "UpdateUnusedWhilePending | "; + if (value & DescriptorBindingFlagBitsEXT::ePartiallyBound) result += "PartiallyBound | "; + if (value & DescriptorBindingFlagBitsEXT::eVariableDescriptorCount) result += "VariableDescriptorCount | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(VendorId value) + { + switch (value) + { + case VendorId::eViv: return "Viv"; + case VendorId::eVsi: return "Vsi"; + case VendorId::eKazan: return "Kazan"; + default: return "invalid"; + } + } + + class DispatchLoaderDynamic + { + public: + PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; + PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; + PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; + PFN_vkAllocateMemory vkAllocateMemory = 0; + PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; + PFN_vkBindBufferMemory vkBindBufferMemory = 0; + PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; + PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; + PFN_vkBindImageMemory vkBindImageMemory = 0; + PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; + PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; + PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; + PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; + PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; + PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; + PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; + PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; + PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; + PFN_vkCmdBlitImage vkCmdBlitImage = 0; + PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; + PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; + PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; + PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; + PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; + PFN_vkCmdCopyImage vkCmdCopyImage = 0; + PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; + PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; + PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; + PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; + PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; + PFN_vkCmdDispatch vkCmdDispatch = 0; + PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; + PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; + PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; + PFN_vkCmdDraw vkCmdDraw = 0; + PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; + PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; + PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; + PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; + PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; + PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; + PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; + PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; + PFN_vkCmdEndQuery vkCmdEndQuery = 0; + PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; + PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; + PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; + PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; + PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; + PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; + PFN_vkCmdProcessCommandsNVX vkCmdProcessCommandsNVX = 0; + PFN_vkCmdPushConstants vkCmdPushConstants = 0; + PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; + PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; + PFN_vkCmdReserveSpaceForCommandsNVX vkCmdReserveSpaceForCommandsNVX = 0; + PFN_vkCmdResetEvent vkCmdResetEvent = 0; + PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; + PFN_vkCmdResolveImage vkCmdResolveImage = 0; + PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; + PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; + PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; + PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; + PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; + PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; + PFN_vkCmdSetEvent vkCmdSetEvent = 0; + PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; + PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; + PFN_vkCmdSetScissor vkCmdSetScissor = 0; + PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; + PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; + PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; + PFN_vkCmdSetViewport vkCmdSetViewport = 0; + PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; + PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; + PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; + PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; + PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + PFN_vkCreateBuffer vkCreateBuffer = 0; + PFN_vkCreateBufferView vkCreateBufferView = 0; + PFN_vkCreateCommandPool vkCreateCommandPool = 0; + PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; + PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; + PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; + PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; + PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; + PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; + PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; + PFN_vkCreateDevice vkCreateDevice = 0; + PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; + PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; + PFN_vkCreateEvent vkCreateEvent = 0; + PFN_vkCreateFence vkCreateFence = 0; + PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; + PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; +#ifdef VK_USE_PLATFORM_IOS_MVK + PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + PFN_vkCreateImage vkCreateImage = 0; + PFN_vkCreateImageView vkCreateImageView = 0; + PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX = 0; + PFN_vkCreateInstance vkCreateInstance = 0; +#ifdef VK_USE_PLATFORM_MACOS_MVK + PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ +#ifdef VK_USE_PLATFORM_MIR_KHR + PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR = 0; +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX = 0; + PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; + PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; + PFN_vkCreateQueryPool vkCreateQueryPool = 0; + PFN_vkCreateRenderPass vkCreateRenderPass = 0; + PFN_vkCreateSampler vkCreateSampler = 0; + PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; + PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; + PFN_vkCreateSemaphore vkCreateSemaphore = 0; + PFN_vkCreateShaderModule vkCreateShaderModule = 0; + PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; + PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; + PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; +#ifdef VK_USE_PLATFORM_VI_NN + PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; +#endif /*VK_USE_PLATFORM_VI_NN*/ +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; + PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; + PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; + PFN_vkDestroyBuffer vkDestroyBuffer = 0; + PFN_vkDestroyBufferView vkDestroyBufferView = 0; + PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; + PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; + PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; + PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; + PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; + PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; + PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; + PFN_vkDestroyDevice vkDestroyDevice = 0; + PFN_vkDestroyEvent vkDestroyEvent = 0; + PFN_vkDestroyFence vkDestroyFence = 0; + PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; + PFN_vkDestroyImage vkDestroyImage = 0; + PFN_vkDestroyImageView vkDestroyImageView = 0; + PFN_vkDestroyIndirectCommandsLayoutNVX vkDestroyIndirectCommandsLayoutNVX = 0; + PFN_vkDestroyInstance vkDestroyInstance = 0; + PFN_vkDestroyObjectTableNVX vkDestroyObjectTableNVX = 0; + PFN_vkDestroyPipeline vkDestroyPipeline = 0; + PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; + PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; + PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; + PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; + PFN_vkDestroySampler vkDestroySampler = 0; + PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; + PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; + PFN_vkDestroySemaphore vkDestroySemaphore = 0; + PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; + PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; + PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; + PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; + PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; + PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; + PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; + PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; + PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; + PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; + PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; + PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; + PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; + PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; + PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; + PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; + PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; + PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; + PFN_vkFreeMemory vkFreeMemory = 0; +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; + PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; + PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; + PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; + PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; + PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; + PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; + PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; + PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; + PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; + PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; + PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; + PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; + PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; + PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; + PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; + PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; + PFN_vkGetEventStatus vkGetEventStatus = 0; + PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; + PFN_vkGetFenceStatus vkGetFenceStatus = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; + PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; + PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; + PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; + PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; + PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; + PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; + PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; + PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_NV + PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; +#endif /*VK_USE_PLATFORM_WIN32_NV*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; + PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; + PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; + PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; + PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; + PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; + PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; + PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; + PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; + PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; + PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; +#ifdef VK_USE_PLATFORM_MIR_KHR + PFN_vkGetPhysicalDeviceMirPresentationSupportKHR vkGetPhysicalDeviceMirPresentationSupportKHR = 0; +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; + PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; + PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; + PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; + PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; + PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; + PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; + PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; + PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; + PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; + PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; + PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; + PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; + PFN_vkMapMemory vkMapMemory = 0; + PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; + PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; + PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; + PFN_vkQueueBindSparse vkQueueBindSparse = 0; + PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; + PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; + PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; + PFN_vkQueueSubmit vkQueueSubmit = 0; + PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; + PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; + PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; + PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX = 0; + PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; + PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; + PFN_vkResetCommandPool vkResetCommandPool = 0; + PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; + PFN_vkResetEvent vkResetEvent = 0; + PFN_vkResetFences vkResetFences = 0; + PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; + PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; + PFN_vkSetEvent vkSetEvent = 0; + PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; + PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; + PFN_vkTrimCommandPool vkTrimCommandPool = 0; + PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; + PFN_vkUnmapMemory vkUnmapMemory = 0; + PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX = 0; + PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; + PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; + PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; + PFN_vkWaitForFences vkWaitForFences = 0; + public: + DispatchLoaderDynamic(Instance instance = Instance(), Device device = Device()) + { + if (instance) + { + init(instance, device); + } + } + + void init(Instance instance, Device device = Device()) + { + vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(device ? device.getProcAddr( "vkAcquireNextImage2KHR") : instance.getProcAddr( "vkAcquireNextImage2KHR")); + vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(device ? device.getProcAddr( "vkAcquireNextImageKHR") : instance.getProcAddr( "vkAcquireNextImageKHR")); +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(device ? device.getProcAddr( "vkAcquireXlibDisplayEXT") : instance.getProcAddr( "vkAcquireXlibDisplayEXT")); +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(device ? device.getProcAddr( "vkAllocateCommandBuffers") : instance.getProcAddr( "vkAllocateCommandBuffers")); + vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(device ? device.getProcAddr( "vkAllocateDescriptorSets") : instance.getProcAddr( "vkAllocateDescriptorSets")); + vkAllocateMemory = PFN_vkAllocateMemory(device ? device.getProcAddr( "vkAllocateMemory") : instance.getProcAddr( "vkAllocateMemory")); + vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(device ? device.getProcAddr( "vkBeginCommandBuffer") : instance.getProcAddr( "vkBeginCommandBuffer")); + vkBindBufferMemory = PFN_vkBindBufferMemory(device ? device.getProcAddr( "vkBindBufferMemory") : instance.getProcAddr( "vkBindBufferMemory")); + vkBindBufferMemory2 = PFN_vkBindBufferMemory2(device ? device.getProcAddr( "vkBindBufferMemory2") : instance.getProcAddr( "vkBindBufferMemory2")); + vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(device ? device.getProcAddr( "vkBindBufferMemory2KHR") : instance.getProcAddr( "vkBindBufferMemory2KHR")); + vkBindImageMemory = PFN_vkBindImageMemory(device ? device.getProcAddr( "vkBindImageMemory") : instance.getProcAddr( "vkBindImageMemory")); + vkBindImageMemory2 = PFN_vkBindImageMemory2(device ? device.getProcAddr( "vkBindImageMemory2") : instance.getProcAddr( "vkBindImageMemory2")); + vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(device ? device.getProcAddr( "vkBindImageMemory2KHR") : instance.getProcAddr( "vkBindImageMemory2KHR")); + vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT")); + vkCmdBeginQuery = PFN_vkCmdBeginQuery(device ? device.getProcAddr( "vkCmdBeginQuery") : instance.getProcAddr( "vkCmdBeginQuery")); + vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(device ? device.getProcAddr( "vkCmdBeginRenderPass") : instance.getProcAddr( "vkCmdBeginRenderPass")); + vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(device ? device.getProcAddr( "vkCmdBindDescriptorSets") : instance.getProcAddr( "vkCmdBindDescriptorSets")); + vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(device ? device.getProcAddr( "vkCmdBindIndexBuffer") : instance.getProcAddr( "vkCmdBindIndexBuffer")); + vkCmdBindPipeline = PFN_vkCmdBindPipeline(device ? device.getProcAddr( "vkCmdBindPipeline") : instance.getProcAddr( "vkCmdBindPipeline")); + vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(device ? device.getProcAddr( "vkCmdBindVertexBuffers") : instance.getProcAddr( "vkCmdBindVertexBuffers")); + vkCmdBlitImage = PFN_vkCmdBlitImage(device ? device.getProcAddr( "vkCmdBlitImage") : instance.getProcAddr( "vkCmdBlitImage")); + vkCmdClearAttachments = PFN_vkCmdClearAttachments(device ? device.getProcAddr( "vkCmdClearAttachments") : instance.getProcAddr( "vkCmdClearAttachments")); + vkCmdClearColorImage = PFN_vkCmdClearColorImage(device ? device.getProcAddr( "vkCmdClearColorImage") : instance.getProcAddr( "vkCmdClearColorImage")); + vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(device ? device.getProcAddr( "vkCmdClearDepthStencilImage") : instance.getProcAddr( "vkCmdClearDepthStencilImage")); + vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(device ? device.getProcAddr( "vkCmdCopyBuffer") : instance.getProcAddr( "vkCmdCopyBuffer")); + vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(device ? device.getProcAddr( "vkCmdCopyBufferToImage") : instance.getProcAddr( "vkCmdCopyBufferToImage")); + vkCmdCopyImage = PFN_vkCmdCopyImage(device ? device.getProcAddr( "vkCmdCopyImage") : instance.getProcAddr( "vkCmdCopyImage")); + vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(device ? device.getProcAddr( "vkCmdCopyImageToBuffer") : instance.getProcAddr( "vkCmdCopyImageToBuffer")); + vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(device ? device.getProcAddr( "vkCmdCopyQueryPoolResults") : instance.getProcAddr( "vkCmdCopyQueryPoolResults")); + vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(device ? device.getProcAddr( "vkCmdDebugMarkerBeginEXT") : instance.getProcAddr( "vkCmdDebugMarkerBeginEXT")); + vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(device ? device.getProcAddr( "vkCmdDebugMarkerEndEXT") : instance.getProcAddr( "vkCmdDebugMarkerEndEXT")); + vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(device ? device.getProcAddr( "vkCmdDebugMarkerInsertEXT") : instance.getProcAddr( "vkCmdDebugMarkerInsertEXT")); + vkCmdDispatch = PFN_vkCmdDispatch(device ? device.getProcAddr( "vkCmdDispatch") : instance.getProcAddr( "vkCmdDispatch")); + vkCmdDispatchBase = PFN_vkCmdDispatchBase(device ? device.getProcAddr( "vkCmdDispatchBase") : instance.getProcAddr( "vkCmdDispatchBase")); + vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(device ? device.getProcAddr( "vkCmdDispatchBaseKHR") : instance.getProcAddr( "vkCmdDispatchBaseKHR")); + vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(device ? device.getProcAddr( "vkCmdDispatchIndirect") : instance.getProcAddr( "vkCmdDispatchIndirect")); + vkCmdDraw = PFN_vkCmdDraw(device ? device.getProcAddr( "vkCmdDraw") : instance.getProcAddr( "vkCmdDraw")); + vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(device ? device.getProcAddr( "vkCmdDrawIndexed") : instance.getProcAddr( "vkCmdDrawIndexed")); + vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(device ? device.getProcAddr( "vkCmdDrawIndexedIndirect") : instance.getProcAddr( "vkCmdDrawIndexedIndirect")); + vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD")); + vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR")); + vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(device ? device.getProcAddr( "vkCmdDrawIndirect") : instance.getProcAddr( "vkCmdDrawIndirect")); + vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndirectCountAMD")); + vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndirectCountKHR")); + vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdEndDebugUtilsLabelEXT")); + vkCmdEndQuery = PFN_vkCmdEndQuery(device ? device.getProcAddr( "vkCmdEndQuery") : instance.getProcAddr( "vkCmdEndQuery")); + vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(device ? device.getProcAddr( "vkCmdEndRenderPass") : instance.getProcAddr( "vkCmdEndRenderPass")); + vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(device ? device.getProcAddr( "vkCmdExecuteCommands") : instance.getProcAddr( "vkCmdExecuteCommands")); + vkCmdFillBuffer = PFN_vkCmdFillBuffer(device ? device.getProcAddr( "vkCmdFillBuffer") : instance.getProcAddr( "vkCmdFillBuffer")); + vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT")); + vkCmdNextSubpass = PFN_vkCmdNextSubpass(device ? device.getProcAddr( "vkCmdNextSubpass") : instance.getProcAddr( "vkCmdNextSubpass")); + vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(device ? device.getProcAddr( "vkCmdPipelineBarrier") : instance.getProcAddr( "vkCmdPipelineBarrier")); + vkCmdProcessCommandsNVX = PFN_vkCmdProcessCommandsNVX(device ? device.getProcAddr( "vkCmdProcessCommandsNVX") : instance.getProcAddr( "vkCmdProcessCommandsNVX")); + vkCmdPushConstants = PFN_vkCmdPushConstants(device ? device.getProcAddr( "vkCmdPushConstants") : instance.getProcAddr( "vkCmdPushConstants")); + vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(device ? device.getProcAddr( "vkCmdPushDescriptorSetKHR") : instance.getProcAddr( "vkCmdPushDescriptorSetKHR")); + vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkCmdPushDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkCmdPushDescriptorSetWithTemplateKHR")); + vkCmdReserveSpaceForCommandsNVX = PFN_vkCmdReserveSpaceForCommandsNVX(device ? device.getProcAddr( "vkCmdReserveSpaceForCommandsNVX") : instance.getProcAddr( "vkCmdReserveSpaceForCommandsNVX")); + vkCmdResetEvent = PFN_vkCmdResetEvent(device ? device.getProcAddr( "vkCmdResetEvent") : instance.getProcAddr( "vkCmdResetEvent")); + vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(device ? device.getProcAddr( "vkCmdResetQueryPool") : instance.getProcAddr( "vkCmdResetQueryPool")); + vkCmdResolveImage = PFN_vkCmdResolveImage(device ? device.getProcAddr( "vkCmdResolveImage") : instance.getProcAddr( "vkCmdResolveImage")); + vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(device ? device.getProcAddr( "vkCmdSetBlendConstants") : instance.getProcAddr( "vkCmdSetBlendConstants")); + vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(device ? device.getProcAddr( "vkCmdSetDepthBias") : instance.getProcAddr( "vkCmdSetDepthBias")); + vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(device ? device.getProcAddr( "vkCmdSetDepthBounds") : instance.getProcAddr( "vkCmdSetDepthBounds")); + vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(device ? device.getProcAddr( "vkCmdSetDeviceMask") : instance.getProcAddr( "vkCmdSetDeviceMask")); + vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(device ? device.getProcAddr( "vkCmdSetDeviceMaskKHR") : instance.getProcAddr( "vkCmdSetDeviceMaskKHR")); + vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(device ? device.getProcAddr( "vkCmdSetDiscardRectangleEXT") : instance.getProcAddr( "vkCmdSetDiscardRectangleEXT")); + vkCmdSetEvent = PFN_vkCmdSetEvent(device ? device.getProcAddr( "vkCmdSetEvent") : instance.getProcAddr( "vkCmdSetEvent")); + vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(device ? device.getProcAddr( "vkCmdSetLineWidth") : instance.getProcAddr( "vkCmdSetLineWidth")); + vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(device ? device.getProcAddr( "vkCmdSetSampleLocationsEXT") : instance.getProcAddr( "vkCmdSetSampleLocationsEXT")); + vkCmdSetScissor = PFN_vkCmdSetScissor(device ? device.getProcAddr( "vkCmdSetScissor") : instance.getProcAddr( "vkCmdSetScissor")); + vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(device ? device.getProcAddr( "vkCmdSetStencilCompareMask") : instance.getProcAddr( "vkCmdSetStencilCompareMask")); + vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(device ? device.getProcAddr( "vkCmdSetStencilReference") : instance.getProcAddr( "vkCmdSetStencilReference")); + vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(device ? device.getProcAddr( "vkCmdSetStencilWriteMask") : instance.getProcAddr( "vkCmdSetStencilWriteMask")); + vkCmdSetViewport = PFN_vkCmdSetViewport(device ? device.getProcAddr( "vkCmdSetViewport") : instance.getProcAddr( "vkCmdSetViewport")); + vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(device ? device.getProcAddr( "vkCmdSetViewportWScalingNV") : instance.getProcAddr( "vkCmdSetViewportWScalingNV")); + vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(device ? device.getProcAddr( "vkCmdUpdateBuffer") : instance.getProcAddr( "vkCmdUpdateBuffer")); + vkCmdWaitEvents = PFN_vkCmdWaitEvents(device ? device.getProcAddr( "vkCmdWaitEvents") : instance.getProcAddr( "vkCmdWaitEvents")); + vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(device ? device.getProcAddr( "vkCmdWriteBufferMarkerAMD") : instance.getProcAddr( "vkCmdWriteBufferMarkerAMD")); + vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(device ? device.getProcAddr( "vkCmdWriteTimestamp") : instance.getProcAddr( "vkCmdWriteTimestamp")); +#ifdef VK_USE_PLATFORM_ANDROID_KHR + vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR")); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + vkCreateBuffer = PFN_vkCreateBuffer(device ? device.getProcAddr( "vkCreateBuffer") : instance.getProcAddr( "vkCreateBuffer")); + vkCreateBufferView = PFN_vkCreateBufferView(device ? device.getProcAddr( "vkCreateBufferView") : instance.getProcAddr( "vkCreateBufferView")); + vkCreateCommandPool = PFN_vkCreateCommandPool(device ? device.getProcAddr( "vkCreateCommandPool") : instance.getProcAddr( "vkCreateCommandPool")); + vkCreateComputePipelines = PFN_vkCreateComputePipelines(device ? device.getProcAddr( "vkCreateComputePipelines") : instance.getProcAddr( "vkCreateComputePipelines")); + vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(instance.getProcAddr( "vkCreateDebugReportCallbackEXT")); + vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(instance.getProcAddr( "vkCreateDebugUtilsMessengerEXT")); + vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(device ? device.getProcAddr( "vkCreateDescriptorPool") : instance.getProcAddr( "vkCreateDescriptorPool")); + vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(device ? device.getProcAddr( "vkCreateDescriptorSetLayout") : instance.getProcAddr( "vkCreateDescriptorSetLayout")); + vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplate") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplate")); + vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR")); + vkCreateDevice = PFN_vkCreateDevice(device ? device.getProcAddr( "vkCreateDevice") : instance.getProcAddr( "vkCreateDevice")); + vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(device ? device.getProcAddr( "vkCreateDisplayModeKHR") : instance.getProcAddr( "vkCreateDisplayModeKHR")); + vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(instance.getProcAddr( "vkCreateDisplayPlaneSurfaceKHR")); + vkCreateEvent = PFN_vkCreateEvent(device ? device.getProcAddr( "vkCreateEvent") : instance.getProcAddr( "vkCreateEvent")); + vkCreateFence = PFN_vkCreateFence(device ? device.getProcAddr( "vkCreateFence") : instance.getProcAddr( "vkCreateFence")); + vkCreateFramebuffer = PFN_vkCreateFramebuffer(device ? device.getProcAddr( "vkCreateFramebuffer") : instance.getProcAddr( "vkCreateFramebuffer")); + vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(device ? device.getProcAddr( "vkCreateGraphicsPipelines") : instance.getProcAddr( "vkCreateGraphicsPipelines")); +#ifdef VK_USE_PLATFORM_IOS_MVK + vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(instance.getProcAddr( "vkCreateIOSSurfaceMVK")); +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + vkCreateImage = PFN_vkCreateImage(device ? device.getProcAddr( "vkCreateImage") : instance.getProcAddr( "vkCreateImage")); + vkCreateImageView = PFN_vkCreateImageView(device ? device.getProcAddr( "vkCreateImageView") : instance.getProcAddr( "vkCreateImageView")); + vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkCreateIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkCreateIndirectCommandsLayoutNVX")); + vkCreateInstance = PFN_vkCreateInstance(instance.getProcAddr( "vkCreateInstance")); +#ifdef VK_USE_PLATFORM_MACOS_MVK + vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(instance.getProcAddr( "vkCreateMacOSSurfaceMVK")); +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ +#ifdef VK_USE_PLATFORM_MIR_KHR + vkCreateMirSurfaceKHR = PFN_vkCreateMirSurfaceKHR(instance.getProcAddr( "vkCreateMirSurfaceKHR")); +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX(device ? device.getProcAddr( "vkCreateObjectTableNVX") : instance.getProcAddr( "vkCreateObjectTableNVX")); + vkCreatePipelineCache = PFN_vkCreatePipelineCache(device ? device.getProcAddr( "vkCreatePipelineCache") : instance.getProcAddr( "vkCreatePipelineCache")); + vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(device ? device.getProcAddr( "vkCreatePipelineLayout") : instance.getProcAddr( "vkCreatePipelineLayout")); + vkCreateQueryPool = PFN_vkCreateQueryPool(device ? device.getProcAddr( "vkCreateQueryPool") : instance.getProcAddr( "vkCreateQueryPool")); + vkCreateRenderPass = PFN_vkCreateRenderPass(device ? device.getProcAddr( "vkCreateRenderPass") : instance.getProcAddr( "vkCreateRenderPass")); + vkCreateSampler = PFN_vkCreateSampler(device ? device.getProcAddr( "vkCreateSampler") : instance.getProcAddr( "vkCreateSampler")); + vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(device ? device.getProcAddr( "vkCreateSamplerYcbcrConversion") : instance.getProcAddr( "vkCreateSamplerYcbcrConversion")); + vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(device ? device.getProcAddr( "vkCreateSamplerYcbcrConversionKHR") : instance.getProcAddr( "vkCreateSamplerYcbcrConversionKHR")); + vkCreateSemaphore = PFN_vkCreateSemaphore(device ? device.getProcAddr( "vkCreateSemaphore") : instance.getProcAddr( "vkCreateSemaphore")); + vkCreateShaderModule = PFN_vkCreateShaderModule(device ? device.getProcAddr( "vkCreateShaderModule") : instance.getProcAddr( "vkCreateShaderModule")); + vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(device ? device.getProcAddr( "vkCreateSharedSwapchainsKHR") : instance.getProcAddr( "vkCreateSharedSwapchainsKHR")); + vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(device ? device.getProcAddr( "vkCreateSwapchainKHR") : instance.getProcAddr( "vkCreateSwapchainKHR")); + vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(device ? device.getProcAddr( "vkCreateValidationCacheEXT") : instance.getProcAddr( "vkCreateValidationCacheEXT")); +#ifdef VK_USE_PLATFORM_VI_NN + vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(instance.getProcAddr( "vkCreateViSurfaceNN")); +#endif /*VK_USE_PLATFORM_VI_NN*/ +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(instance.getProcAddr( "vkCreateWaylandSurfaceKHR")); +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(instance.getProcAddr( "vkCreateWin32SurfaceKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(instance.getProcAddr( "vkCreateXcbSurfaceKHR")); +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(instance.getProcAddr( "vkCreateXlibSurfaceKHR")); +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectNameEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectNameEXT")); + vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectTagEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectTagEXT")); + vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(instance.getProcAddr( "vkDebugReportMessageEXT")); + vkDestroyBuffer = PFN_vkDestroyBuffer(device ? device.getProcAddr( "vkDestroyBuffer") : instance.getProcAddr( "vkDestroyBuffer")); + vkDestroyBufferView = PFN_vkDestroyBufferView(device ? device.getProcAddr( "vkDestroyBufferView") : instance.getProcAddr( "vkDestroyBufferView")); + vkDestroyCommandPool = PFN_vkDestroyCommandPool(device ? device.getProcAddr( "vkDestroyCommandPool") : instance.getProcAddr( "vkDestroyCommandPool")); + vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(instance.getProcAddr( "vkDestroyDebugReportCallbackEXT")); + vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(instance.getProcAddr( "vkDestroyDebugUtilsMessengerEXT")); + vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(device ? device.getProcAddr( "vkDestroyDescriptorPool") : instance.getProcAddr( "vkDestroyDescriptorPool")); + vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(device ? device.getProcAddr( "vkDestroyDescriptorSetLayout") : instance.getProcAddr( "vkDestroyDescriptorSetLayout")); + vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(device ? device.getProcAddr( "vkDestroyDescriptorUpdateTemplate") : instance.getProcAddr( "vkDestroyDescriptorUpdateTemplate")); + vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkDestroyDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkDestroyDescriptorUpdateTemplateKHR")); + vkDestroyDevice = PFN_vkDestroyDevice(device ? device.getProcAddr( "vkDestroyDevice") : instance.getProcAddr( "vkDestroyDevice")); + vkDestroyEvent = PFN_vkDestroyEvent(device ? device.getProcAddr( "vkDestroyEvent") : instance.getProcAddr( "vkDestroyEvent")); + vkDestroyFence = PFN_vkDestroyFence(device ? device.getProcAddr( "vkDestroyFence") : instance.getProcAddr( "vkDestroyFence")); + vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(device ? device.getProcAddr( "vkDestroyFramebuffer") : instance.getProcAddr( "vkDestroyFramebuffer")); + vkDestroyImage = PFN_vkDestroyImage(device ? device.getProcAddr( "vkDestroyImage") : instance.getProcAddr( "vkDestroyImage")); + vkDestroyImageView = PFN_vkDestroyImageView(device ? device.getProcAddr( "vkDestroyImageView") : instance.getProcAddr( "vkDestroyImageView")); + vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX")); + vkDestroyInstance = PFN_vkDestroyInstance(instance.getProcAddr( "vkDestroyInstance")); + vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX(device ? device.getProcAddr( "vkDestroyObjectTableNVX") : instance.getProcAddr( "vkDestroyObjectTableNVX")); + vkDestroyPipeline = PFN_vkDestroyPipeline(device ? device.getProcAddr( "vkDestroyPipeline") : instance.getProcAddr( "vkDestroyPipeline")); + vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(device ? device.getProcAddr( "vkDestroyPipelineCache") : instance.getProcAddr( "vkDestroyPipelineCache")); + vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(device ? device.getProcAddr( "vkDestroyPipelineLayout") : instance.getProcAddr( "vkDestroyPipelineLayout")); + vkDestroyQueryPool = PFN_vkDestroyQueryPool(device ? device.getProcAddr( "vkDestroyQueryPool") : instance.getProcAddr( "vkDestroyQueryPool")); + vkDestroyRenderPass = PFN_vkDestroyRenderPass(device ? device.getProcAddr( "vkDestroyRenderPass") : instance.getProcAddr( "vkDestroyRenderPass")); + vkDestroySampler = PFN_vkDestroySampler(device ? device.getProcAddr( "vkDestroySampler") : instance.getProcAddr( "vkDestroySampler")); + vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(device ? device.getProcAddr( "vkDestroySamplerYcbcrConversion") : instance.getProcAddr( "vkDestroySamplerYcbcrConversion")); + vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(device ? device.getProcAddr( "vkDestroySamplerYcbcrConversionKHR") : instance.getProcAddr( "vkDestroySamplerYcbcrConversionKHR")); + vkDestroySemaphore = PFN_vkDestroySemaphore(device ? device.getProcAddr( "vkDestroySemaphore") : instance.getProcAddr( "vkDestroySemaphore")); + vkDestroyShaderModule = PFN_vkDestroyShaderModule(device ? device.getProcAddr( "vkDestroyShaderModule") : instance.getProcAddr( "vkDestroyShaderModule")); + vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(instance.getProcAddr( "vkDestroySurfaceKHR")); + vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(device ? device.getProcAddr( "vkDestroySwapchainKHR") : instance.getProcAddr( "vkDestroySwapchainKHR")); + vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(device ? device.getProcAddr( "vkDestroyValidationCacheEXT") : instance.getProcAddr( "vkDestroyValidationCacheEXT")); + vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(device ? device.getProcAddr( "vkDeviceWaitIdle") : instance.getProcAddr( "vkDeviceWaitIdle")); + vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(device ? device.getProcAddr( "vkDisplayPowerControlEXT") : instance.getProcAddr( "vkDisplayPowerControlEXT")); + vkEndCommandBuffer = PFN_vkEndCommandBuffer(device ? device.getProcAddr( "vkEndCommandBuffer") : instance.getProcAddr( "vkEndCommandBuffer")); + vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(device ? device.getProcAddr( "vkEnumerateDeviceExtensionProperties") : instance.getProcAddr( "vkEnumerateDeviceExtensionProperties")); + vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(device ? device.getProcAddr( "vkEnumerateDeviceLayerProperties") : instance.getProcAddr( "vkEnumerateDeviceLayerProperties")); + vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties(instance.getProcAddr( "vkEnumerateInstanceExtensionProperties")); + vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(instance.getProcAddr( "vkEnumerateInstanceLayerProperties")); + vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(instance.getProcAddr( "vkEnumerateInstanceVersion")); + vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroups")); + vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroupsKHR")); + vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(instance.getProcAddr( "vkEnumeratePhysicalDevices")); + vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(device ? device.getProcAddr( "vkFlushMappedMemoryRanges") : instance.getProcAddr( "vkFlushMappedMemoryRanges")); + vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(device ? device.getProcAddr( "vkFreeCommandBuffers") : instance.getProcAddr( "vkFreeCommandBuffers")); + vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(device ? device.getProcAddr( "vkFreeDescriptorSets") : instance.getProcAddr( "vkFreeDescriptorSets")); + vkFreeMemory = PFN_vkFreeMemory(device ? device.getProcAddr( "vkFreeMemory") : instance.getProcAddr( "vkFreeMemory")); +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(device ? device.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID") : instance.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID")); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(device ? device.getProcAddr( "vkGetBufferMemoryRequirements") : instance.getProcAddr( "vkGetBufferMemoryRequirements")); + vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2") : instance.getProcAddr( "vkGetBufferMemoryRequirements2")); + vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2KHR") : instance.getProcAddr( "vkGetBufferMemoryRequirements2KHR")); + vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupport") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupport")); + vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR")); + vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(device ? device.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures") : instance.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures")); + vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(device ? device.getProcAddr( "vkGetDeviceGroupPeerMemoryFeaturesKHR") : instance.getProcAddr( "vkGetDeviceGroupPeerMemoryFeaturesKHR")); + vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR(device ? device.getProcAddr( "vkGetDeviceGroupPresentCapabilitiesKHR") : instance.getProcAddr( "vkGetDeviceGroupPresentCapabilitiesKHR")); + vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR(device ? device.getProcAddr( "vkGetDeviceGroupSurfacePresentModesKHR") : instance.getProcAddr( "vkGetDeviceGroupSurfacePresentModesKHR")); + vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(device ? device.getProcAddr( "vkGetDeviceMemoryCommitment") : instance.getProcAddr( "vkGetDeviceMemoryCommitment")); + vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(device ? device.getProcAddr( "vkGetDeviceProcAddr") : instance.getProcAddr( "vkGetDeviceProcAddr")); + vkGetDeviceQueue = PFN_vkGetDeviceQueue(device ? device.getProcAddr( "vkGetDeviceQueue") : instance.getProcAddr( "vkGetDeviceQueue")); + vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(device ? device.getProcAddr( "vkGetDeviceQueue2") : instance.getProcAddr( "vkGetDeviceQueue2")); + vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(device ? device.getProcAddr( "vkGetDisplayModeProperties2KHR") : instance.getProcAddr( "vkGetDisplayModeProperties2KHR")); + vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(device ? device.getProcAddr( "vkGetDisplayModePropertiesKHR") : instance.getProcAddr( "vkGetDisplayModePropertiesKHR")); + vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(device ? device.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR") : instance.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR")); + vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(device ? device.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR") : instance.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR")); + vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(device ? device.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR") : instance.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR")); + vkGetEventStatus = PFN_vkGetEventStatus(device ? device.getProcAddr( "vkGetEventStatus") : instance.getProcAddr( "vkGetEventStatus")); + vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(device ? device.getProcAddr( "vkGetFenceFdKHR") : instance.getProcAddr( "vkGetFenceFdKHR")); + vkGetFenceStatus = PFN_vkGetFenceStatus(device ? device.getProcAddr( "vkGetFenceStatus") : instance.getProcAddr( "vkGetFenceStatus")); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(device ? device.getProcAddr( "vkGetFenceWin32HandleKHR") : instance.getProcAddr( "vkGetFenceWin32HandleKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(device ? device.getProcAddr( "vkGetImageMemoryRequirements") : instance.getProcAddr( "vkGetImageMemoryRequirements")); + vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(device ? device.getProcAddr( "vkGetImageMemoryRequirements2") : instance.getProcAddr( "vkGetImageMemoryRequirements2")); + vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageMemoryRequirements2KHR")); + vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements")); + vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2")); + vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR")); + vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(device ? device.getProcAddr( "vkGetImageSubresourceLayout") : instance.getProcAddr( "vkGetImageSubresourceLayout")); + vkGetInstanceProcAddr = PFN_vkGetInstanceProcAddr(instance.getProcAddr( "vkGetInstanceProcAddr")); +#ifdef VK_USE_PLATFORM_ANDROID_ANDROID + vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID(device ? device.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID") : instance.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID")); +#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ + vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(device ? device.getProcAddr( "vkGetMemoryFdKHR") : instance.getProcAddr( "vkGetMemoryFdKHR")); + vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(device ? device.getProcAddr( "vkGetMemoryFdPropertiesKHR") : instance.getProcAddr( "vkGetMemoryFdPropertiesKHR")); + vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(device ? device.getProcAddr( "vkGetMemoryHostPointerPropertiesEXT") : instance.getProcAddr( "vkGetMemoryHostPointerPropertiesEXT")); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandleKHR") : instance.getProcAddr( "vkGetMemoryWin32HandleKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_NV + vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(device ? device.getProcAddr( "vkGetMemoryWin32HandleNV") : instance.getProcAddr( "vkGetMemoryWin32HandleNV")); +#endif /*VK_USE_PLATFORM_WIN32_NV*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR") : instance.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(device ? device.getProcAddr( "vkGetPastPresentationTimingGOOGLE") : instance.getProcAddr( "vkGetPastPresentationTimingGOOGLE")); + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); + vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR")); + vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR")); + vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties")); + vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR")); + vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties")); + vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR")); + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalImageFormatPropertiesNV") : instance.getProcAddr( "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); + vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties")); + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); + vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures")); + vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures2") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures2")); + vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR")); + vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties")); + vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2")); + vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR")); + vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(device ? device.getProcAddr( "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX") : instance.getProcAddr( "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX")); + vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties")); + vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2")); + vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR")); + vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties")); + vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2")); + vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR")); +#ifdef VK_USE_PLATFORM_MIR_KHR + vkGetPhysicalDeviceMirPresentationSupportKHR = PFN_vkGetPhysicalDeviceMirPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceMirPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceMirPresentationSupportKHR")); +#endif /*VK_USE_PLATFORM_MIR_KHR*/ + vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(device ? device.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT") : instance.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT")); + vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR(device ? device.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR") : instance.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR")); + vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties") : instance.getProcAddr( "vkGetPhysicalDeviceProperties")); + vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceProperties2")); + vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceProperties2KHR")); + vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties")); + vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2")); + vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR")); + vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties")); + vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2")); + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); + vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); + vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR")); + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); + vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR")); + vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR")); + vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR")); + vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR")); +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR")); +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR")); +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(device ? device.getProcAddr( "vkGetPipelineCacheData") : instance.getProcAddr( "vkGetPipelineCacheData")); + vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(device ? device.getProcAddr( "vkGetQueryPoolResults") : instance.getProcAddr( "vkGetQueryPoolResults")); +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV + vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(device ? device.getProcAddr( "vkGetRandROutputDisplayEXT") : instance.getProcAddr( "vkGetRandROutputDisplayEXT")); +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ + vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(device ? device.getProcAddr( "vkGetRefreshCycleDurationGOOGLE") : instance.getProcAddr( "vkGetRefreshCycleDurationGOOGLE")); + vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(device ? device.getProcAddr( "vkGetRenderAreaGranularity") : instance.getProcAddr( "vkGetRenderAreaGranularity")); + vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(device ? device.getProcAddr( "vkGetSemaphoreFdKHR") : instance.getProcAddr( "vkGetSemaphoreFdKHR")); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkGetSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkGetSemaphoreWin32HandleKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(device ? device.getProcAddr( "vkGetShaderInfoAMD") : instance.getProcAddr( "vkGetShaderInfoAMD")); + vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(device ? device.getProcAddr( "vkGetSwapchainCounterEXT") : instance.getProcAddr( "vkGetSwapchainCounterEXT")); + vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(device ? device.getProcAddr( "vkGetSwapchainImagesKHR") : instance.getProcAddr( "vkGetSwapchainImagesKHR")); + vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(device ? device.getProcAddr( "vkGetSwapchainStatusKHR") : instance.getProcAddr( "vkGetSwapchainStatusKHR")); + vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(device ? device.getProcAddr( "vkGetValidationCacheDataEXT") : instance.getProcAddr( "vkGetValidationCacheDataEXT")); + vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(device ? device.getProcAddr( "vkImportFenceFdKHR") : instance.getProcAddr( "vkImportFenceFdKHR")); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(device ? device.getProcAddr( "vkImportFenceWin32HandleKHR") : instance.getProcAddr( "vkImportFenceWin32HandleKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(device ? device.getProcAddr( "vkImportSemaphoreFdKHR") : instance.getProcAddr( "vkImportSemaphoreFdKHR")); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkImportSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkImportSemaphoreWin32HandleKHR")); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(device ? device.getProcAddr( "vkInvalidateMappedMemoryRanges") : instance.getProcAddr( "vkInvalidateMappedMemoryRanges")); + vkMapMemory = PFN_vkMapMemory(device ? device.getProcAddr( "vkMapMemory") : instance.getProcAddr( "vkMapMemory")); + vkMergePipelineCaches = PFN_vkMergePipelineCaches(device ? device.getProcAddr( "vkMergePipelineCaches") : instance.getProcAddr( "vkMergePipelineCaches")); + vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(device ? device.getProcAddr( "vkMergeValidationCachesEXT") : instance.getProcAddr( "vkMergeValidationCachesEXT")); + vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT")); + vkQueueBindSparse = PFN_vkQueueBindSparse(device ? device.getProcAddr( "vkQueueBindSparse") : instance.getProcAddr( "vkQueueBindSparse")); + vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueEndDebugUtilsLabelEXT")); + vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueInsertDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueInsertDebugUtilsLabelEXT")); + vkQueuePresentKHR = PFN_vkQueuePresentKHR(device ? device.getProcAddr( "vkQueuePresentKHR") : instance.getProcAddr( "vkQueuePresentKHR")); + vkQueueSubmit = PFN_vkQueueSubmit(device ? device.getProcAddr( "vkQueueSubmit") : instance.getProcAddr( "vkQueueSubmit")); + vkQueueWaitIdle = PFN_vkQueueWaitIdle(device ? device.getProcAddr( "vkQueueWaitIdle") : instance.getProcAddr( "vkQueueWaitIdle")); + vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(device ? device.getProcAddr( "vkRegisterDeviceEventEXT") : instance.getProcAddr( "vkRegisterDeviceEventEXT")); + vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(device ? device.getProcAddr( "vkRegisterDisplayEventEXT") : instance.getProcAddr( "vkRegisterDisplayEventEXT")); + vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX(device ? device.getProcAddr( "vkRegisterObjectsNVX") : instance.getProcAddr( "vkRegisterObjectsNVX")); + vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(device ? device.getProcAddr( "vkReleaseDisplayEXT") : instance.getProcAddr( "vkReleaseDisplayEXT")); + vkResetCommandBuffer = PFN_vkResetCommandBuffer(device ? device.getProcAddr( "vkResetCommandBuffer") : instance.getProcAddr( "vkResetCommandBuffer")); + vkResetCommandPool = PFN_vkResetCommandPool(device ? device.getProcAddr( "vkResetCommandPool") : instance.getProcAddr( "vkResetCommandPool")); + vkResetDescriptorPool = PFN_vkResetDescriptorPool(device ? device.getProcAddr( "vkResetDescriptorPool") : instance.getProcAddr( "vkResetDescriptorPool")); + vkResetEvent = PFN_vkResetEvent(device ? device.getProcAddr( "vkResetEvent") : instance.getProcAddr( "vkResetEvent")); + vkResetFences = PFN_vkResetFences(device ? device.getProcAddr( "vkResetFences") : instance.getProcAddr( "vkResetFences")); + vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectNameEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectNameEXT")); + vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectTagEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectTagEXT")); + vkSetEvent = PFN_vkSetEvent(device ? device.getProcAddr( "vkSetEvent") : instance.getProcAddr( "vkSetEvent")); + vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(device ? device.getProcAddr( "vkSetHdrMetadataEXT") : instance.getProcAddr( "vkSetHdrMetadataEXT")); + vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(instance.getProcAddr( "vkSubmitDebugUtilsMessageEXT")); + vkTrimCommandPool = PFN_vkTrimCommandPool(device ? device.getProcAddr( "vkTrimCommandPool") : instance.getProcAddr( "vkTrimCommandPool")); + vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(device ? device.getProcAddr( "vkTrimCommandPoolKHR") : instance.getProcAddr( "vkTrimCommandPoolKHR")); + vkUnmapMemory = PFN_vkUnmapMemory(device ? device.getProcAddr( "vkUnmapMemory") : instance.getProcAddr( "vkUnmapMemory")); + vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX(device ? device.getProcAddr( "vkUnregisterObjectsNVX") : instance.getProcAddr( "vkUnregisterObjectsNVX")); + vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplate") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplate")); + vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR")); + vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(device ? device.getProcAddr( "vkUpdateDescriptorSets") : instance.getProcAddr( "vkUpdateDescriptorSets")); + vkWaitForFences = PFN_vkWaitForFences(device ? device.getProcAddr( "vkWaitForFences") : instance.getProcAddr( "vkWaitForFences")); + } + }; +} // namespace VULKAN_HPP_NAMESPACE + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_android.h b/generator/Vulkan-Headers/include/vulkan/vulkan_android.h new file mode 100644 index 0000000..07aaeda --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_android.h @@ -0,0 +1,126 @@ +#ifndef VULKAN_ANDROID_H_ +#define VULKAN_ANDROID_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_android_surface 1 +struct ANativeWindow; + +#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 +#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" + +typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + +typedef struct VkAndroidSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAndroidSurfaceCreateFlagsKHR flags; + struct ANativeWindow* window; +} VkAndroidSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#define VK_ANDROID_external_memory_android_hardware_buffer 1 +struct AHardwareBuffer; + +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3 +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" + +typedef struct VkAndroidHardwareBufferUsageANDROID { + VkStructureType sType; + void* pNext; + uint64_t androidHardwareBufferUsage; +} VkAndroidHardwareBufferUsageANDROID; + +typedef struct VkAndroidHardwareBufferPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; +} VkAndroidHardwareBufferPropertiesANDROID; + +typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkAndroidHardwareBufferFormatPropertiesANDROID; + +typedef struct VkImportAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + struct AHardwareBuffer* buffer; +} VkImportAndroidHardwareBufferInfoANDROID; + +typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkMemoryGetAndroidHardwareBufferInfoANDROID; + +typedef struct VkExternalFormatANDROID { + VkStructureType sType; + void* pNext; + uint64_t externalFormat; +} VkExternalFormatANDROID; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_core.h b/generator/Vulkan-Headers/include/vulkan/vulkan_core.h new file mode 100644 index 0000000..93aa65b --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_core.h @@ -0,0 +1,7586 @@ +#ifndef VULKAN_CORE_H_ +#define VULKAN_CORE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_MAKE_VERSION(major, minor, patch) \ + (((major) << 22) | ((minor) << 12) | (patch)) + +// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 + +// Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 + +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) +// Version of this file +#define VK_HEADER_VERSION 79 + + +#define VK_NULL_HANDLE 0 + + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +#else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +#endif +#endif + + + +typedef uint32_t VkFlags; +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkSampleMask; + +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + +#define VK_LOD_CLAMP_NONE 1000.0f +#define VK_REMAINING_MIP_LEVELS (~0U) +#define VK_REMAINING_ARRAY_LAYERS (~0U) +#define VK_WHOLE_SIZE (~0ULL) +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_TRUE 1 +#define VK_FALSE 0 +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 +#define VK_UUID_SIZE 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME_SIZE 256 +#define VK_MAX_DESCRIPTION_SIZE 256 + + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_FRAGMENTATION_EXT = -1000161000, + VK_ERROR_NOT_PERMITTED_EXT = -1000174001, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, + VK_RESULT_END_RANGE = VK_INCOMPLETE, + VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, + VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, + VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, + VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, + VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, + VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, + VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, + VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, + VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, + VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, + VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, + VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, + VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, + VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, + VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, + VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, + VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, + VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, + VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, + VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, + VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, + VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, + VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, + VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, + VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, + VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, + VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, + VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, + VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, + VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, + VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, + VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, + VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, + VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, + VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_IMG = 1000015000, + VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, + VK_FILTER_END_RANGE = VK_FILTER_LINEAR, + VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, + VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, + VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, + VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, + VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, + VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, + VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, + VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, + VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, + VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, + VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, + VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, + VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL, + VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1), + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef enum VkVendorId { + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_BEGIN_RANGE = VK_VENDOR_ID_VIV, + VK_VENDOR_ID_END_RANGE = VK_VENDOR_ID_KAZAN, + VK_VENDOR_ID_RANGE_SIZE = (VK_VENDOR_ID_KAZAN - VK_VENDOR_ID_VIV + 1), + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} VkVendorId; + +typedef VkFlags VkInstanceCreateFlags; + +typedef enum VkFormatFeatureFlagBits { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, + VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum VkImageUsageFlagBits { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum VkImageCreateFlagBits { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, + VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, + VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, + VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum VkSampleCountFlagBits { + VK_SAMPLE_COUNT_1_BIT = 0x00000001, + VK_SAMPLE_COUNT_2_BIT = 0x00000002, + VK_SAMPLE_COUNT_4_BIT = 0x00000004, + VK_SAMPLE_COUNT_8_BIT = 0x00000008, + VK_SAMPLE_COUNT_16_BIT = 0x00000010, + VK_SAMPLE_COUNT_32_BIT = 0x00000020, + VK_SAMPLE_COUNT_64_BIT = 0x00000040, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum VkQueueFlagBits { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + VK_QUEUE_PROTECTED_BIT = 0x00000010, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; + +typedef enum VkMemoryPropertyFlagBits { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; +typedef VkFlags VkDeviceCreateFlags; + +typedef enum VkDeviceQueueCreateFlagBits { + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDeviceQueueCreateFlagBits; +typedef VkFlags VkDeviceQueueCreateFlags; + +typedef enum VkPipelineStageFlagBits { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum VkImageAspectFlagBits { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum VkSparseImageFormatFlagBits { + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; +typedef VkFlags VkEventCreateFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum VkQueryResultFlagBits { + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum VkBufferCreateFlagBits { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum VkBufferUsageFlagBits { + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; +typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; +typedef VkFlags VkPipelineCacheCreateFlags; + +typedef enum VkPipelineCreateFlagBits { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, + VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; +typedef VkFlags VkPipelineShaderStageCreateFlags; + +typedef enum VkShaderStageFlagBits { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkShaderStageFlagBits; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; + +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; +typedef VkFlags VkSamplerCreateFlags; + +typedef enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetLayoutCreateFlagBits; +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +typedef enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolCreateFlagBits; +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; +typedef VkFlags VkFramebufferCreateFlags; +typedef VkFlags VkRenderPassCreateFlags; + +typedef enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum VkAccessFlagBits { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, + VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAccessFlagBits; +typedef VkFlags VkAccessFlags; + +typedef enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, + VK_STENCIL_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkSparseImageFormatProperties { + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements { + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct VkSparseMemoryBind { + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind; + +typedef struct VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseBufferMemoryBindInfo; + +typedef struct VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseImageOpaqueMemoryBindInfo; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkSparseImageMemoryBind { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind; + +typedef struct VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseImageMemoryBind* pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + +typedef struct VkBaseOutStructure { + VkStructureType sType; + struct VkBaseOutStructure* pNext; +} VkBaseOutStructure; + +typedef struct VkBaseInStructure { + VkStructureType sType; + const struct VkBaseInStructure* pNext; +} VkBaseInStructure; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR void VKAPI_CALL vkFreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); +#endif + +#define VK_VERSION_1_1 1 +// Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 + + +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) + +#define VK_MAX_DEVICE_GROUP_SIZE 32 +#define VK_LUID_SIZE 8 +#define VK_QUEUE_FAMILY_EXTERNAL (~0U-1) + + +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_END_RANGE = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES + 1), + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; + +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT + 1), + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; + +typedef enum VkSamplerYcbcrModelConversion { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY + 1), + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrModelConversion; + +typedef enum VkSamplerYcbcrRange { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + VK_SAMPLER_YCBCR_RANGE_END_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - VK_SAMPLER_YCBCR_RANGE_ITU_FULL + 1), + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrRange; + +typedef enum VkChromaLocation { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, + VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, + VK_CHROMA_LOCATION_BEGIN_RANGE = VK_CHROMA_LOCATION_COSITED_EVEN, + VK_CHROMA_LOCATION_END_RANGE = VK_CHROMA_LOCATION_MIDPOINT, + VK_CHROMA_LOCATION_RANGE_SIZE = (VK_CHROMA_LOCATION_MIDPOINT - VK_CHROMA_LOCATION_COSITED_EVEN + 1), + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} VkChromaLocation; + +typedef enum VkDescriptorUpdateTemplateType { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET + 1), + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorUpdateTemplateType; + + +typedef enum VkSubgroupFeatureFlagBits { + VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, + VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, + VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, + VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubgroupFeatureFlagBits; +typedef VkFlags VkSubgroupFeatureFlags; + +typedef enum VkPeerMemoryFeatureFlagBits { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPeerMemoryFeatureFlagBits; +typedef VkFlags VkPeerMemoryFeatureFlags; + +typedef enum VkMemoryAllocateFlagBits { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryAllocateFlagBits; +typedef VkFlags VkMemoryAllocateFlags; +typedef VkFlags VkCommandPoolTrimFlags; +typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + +typedef enum VkExternalMemoryHandleTypeFlagBits { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBits; +typedef VkFlags VkExternalMemoryHandleTypeFlags; + +typedef enum VkExternalMemoryFeatureFlagBits { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBits; +typedef VkFlags VkExternalMemoryFeatureFlags; + +typedef enum VkExternalFenceHandleTypeFlagBits { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBits; +typedef VkFlags VkExternalFenceHandleTypeFlags; + +typedef enum VkExternalFenceFeatureFlagBits { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBits; +typedef VkFlags VkExternalFenceFeatureFlags; + +typedef enum VkFenceImportFlagBits { + VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceImportFlagBits; +typedef VkFlags VkFenceImportFlags; + +typedef enum VkSemaphoreImportFlagBits { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreImportFlagBits; +typedef VkFlags VkSemaphoreImportFlags; + +typedef enum VkExternalSemaphoreHandleTypeFlagBits { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBits; +typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + +typedef enum VkExternalSemaphoreFeatureFlagBits { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBits; +typedef VkFlags VkExternalSemaphoreFeatureFlags; + +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + +typedef struct VkBindBufferMemoryInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfo; + +typedef struct VkBindImageMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfo; + +typedef struct VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + +typedef struct VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkMemoryAllocateFlagsInfo { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + +typedef struct VkDeviceGroupBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D* pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + +typedef struct VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2; + +typedef struct VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2; + +typedef struct VkImageSparseMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2; + +typedef struct VkMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2; + +typedef struct VkSparseImageMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2; + +typedef struct VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2; + +typedef struct VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2; + +typedef struct VkFormatProperties2 { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; + +typedef struct VkImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; + +typedef struct VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; + +typedef struct VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + +typedef struct VkSparseImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties2; + +typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} VkPhysicalDeviceSparseImageFormatInfo2; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkImageViewUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceVariablePointerFeatures { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + +typedef struct VkDeviceQueueInfo2 { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + +typedef struct VkProtectedSubmitInfo { + VkStructureType sType; + const void* pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkBindImagePlaneMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + +typedef struct VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkDescriptorUpdateTemplateEntry { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntry; + +typedef struct VkDescriptorUpdateTemplateCreateInfo { + VkStructureType sType; + void* pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfo; + +typedef struct VkExternalMemoryProperties { + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + +typedef struct VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkExternalBufferProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkExternalMemoryImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + +typedef struct VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExportMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkExternalFenceProperties { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; + +typedef struct VkExportFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkPhysicalDeviceShaderDrawParameterFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParameterFeatures; + + +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( + uint32_t* pApiVersion); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" +#define VK_COLORSPACE_SRGB_NONLINEAR_KHR VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, + VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + + +typedef enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSurfaceTransformFlagBitsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; + +typedef enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCompositeAlphaFlagBitsKHR; +typedef VkFlags VkCompositeAlphaFlagsKHR; + +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + + +typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, + VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSwapchainCreateFlagBitsKHR; +typedef VkFlags VkSwapchainCreateFlagsKHR; + +typedef enum VkDeviceGroupPresentModeFlagBitsKHR { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceGroupPresentModeFlagBitsKHR; +typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; + +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + +typedef struct VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHR; + +typedef struct VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; + +typedef struct VkAcquireNextImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + const void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); +#endif + +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + +#define VK_KHR_DISPLAY_SPEC_VERSION 21 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" + + +typedef enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDisplayPlaneAlphaFlagBitsKHR; +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplayModeCreateFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" + +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif + +#define VK_KHR_sampler_mirror_clamp_to_edge 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" + + +#define VK_KHR_multiview 1 +#define VK_KHR_MULTIVIEW_SPEC_VERSION 1 +#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" + +typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; + +typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; + +typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; + + + +#define VK_KHR_get_physical_device_properties2 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" + +typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; + +typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; + +typedef VkFormatProperties2 VkFormatProperties2KHR; + +typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; + +typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; + +typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; + +typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; + +typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; + +typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); +#endif + +#define VK_KHR_device_group 1 +#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3 +#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" + +typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; + +typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; + +typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; + +typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; + + +typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; + +typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; + +typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; + +typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; + +typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; + +typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; + +typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); +#endif + +#define VK_KHR_shader_draw_parameters 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" + + +#define VK_KHR_maintenance1 1 +#define VK_KHR_MAINTENANCE1_SPEC_VERSION 2 +#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" + +typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; + + +typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); +#endif + +#define VK_KHR_device_group_creation 1 +#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 +#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" +#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE + +typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; + +typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +#endif + +#define VK_KHR_external_memory_capabilities 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" +#define VK_LUID_SIZE_KHR VK_LUID_SIZE + +typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; + +typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; + +typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; + + +typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; + +typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; + +typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; + +typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; + +typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); +#endif + +#define VK_KHR_external_memory 1 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL + +typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; + +typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; + +typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; + + + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" + +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + +#define VK_KHR_external_semaphore_capabilities 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" + +typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; + +typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; + + +typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +#endif + +#define VK_KHR_external_semaphore 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" + +typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; + +typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; + + +typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; + + + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" + +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#define VK_KHR_push_descriptor 1 +#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 +#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" + +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); +#endif + +#define VK_KHR_16bit_storage 1 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" + +typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; + + + +#define VK_KHR_incremental_present 1 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" + +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR* pRegions; +} VkPresentRegionsKHR; + + + +#define VK_KHR_descriptor_update_template 1 +typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; + + +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" + +typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; + + +typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; + + +typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; + +typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); +#endif + +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" + +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + +#define VK_KHR_external_fence_capabilities 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" + +typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; + +typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; + +typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; + + +typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; + +typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); +#endif + +#define VK_KHR_external_fence 1 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" + +typedef VkFenceImportFlags VkFenceImportFlagsKHR; + +typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; + + +typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; + + + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" + +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#define VK_KHR_maintenance2 1 +#define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" + +typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; + +typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; + + +typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; + +typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; + +typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; + +typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; + +typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; + + + +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" + +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif + +#define VK_KHR_variable_pointers 1 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" + +typedef VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; + + + +#define VK_KHR_get_display_properties2 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" + +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); +#endif + +#define VK_KHR_dedicated_allocation 1 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" + +typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; + +typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; + + + +#define VK_KHR_storage_buffer_storage_class 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" + + +#define VK_KHR_relaxed_block_layout 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" + + +#define VK_KHR_get_memory_requirements2 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" + +typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; + +typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; + +typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; + +typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; + +typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +#endif + +#define VK_KHR_image_format_list 1 +#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 +#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" + +typedef struct VkImageFormatListCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkImageFormatListCreateInfoKHR; + + + +#define VK_KHR_sampler_ycbcr_conversion 1 +typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; + + +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" + +typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; + +typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; + +typedef VkChromaLocation VkChromaLocationKHR; + + +typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; + +typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; + +typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; + +typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; + +typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; + +typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); +#endif + +#define VK_KHR_bind_memory2 1 +#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" + +typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; + +typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); +#endif + +#define VK_KHR_maintenance3 1 +#define VK_KHR_MAINTENANCE3_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3" + +typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; + +typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + +#define VK_KHR_draw_indirect_count 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#define VK_EXT_debug_report 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9 +#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" +#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT +#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT + + +typedef enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, + VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1), + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportObjectTypeEXT; + + +typedef enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportFlagBitsEXT; +typedef VkFlags VkDebugReportFlagsEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + +typedef struct VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; +} VkDebugReportCallbackCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); +#endif + +#define VK_NV_glsl_shader 1 +#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 +#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" + + +#define VK_EXT_depth_range_unrestricted 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" + + +#define VK_IMG_filter_cubic 1 +#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 +#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" + + +#define VK_AMD_rasterization_order 1 +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" + + +typedef enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, + VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, + VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF +} VkRasterizationOrderAMD; + +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; + + + +#define VK_AMD_shader_trinary_minmax 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" + + +#define VK_AMD_shader_explicit_vertex_parameter 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" + + +#define VK_EXT_debug_marker 1 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" + +typedef struct VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; +} VkDebugMarkerObjectNameInfoEXT; + +typedef struct VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugMarkerObjectTagInfoEXT; + +typedef struct VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext; + const char* pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif + +#define VK_AMD_gcn_shader 1 +#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 +#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" + + +#define VK_NV_dedicated_allocation 1 +#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" + +typedef struct VkDedicatedAllocationImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV; + +typedef struct VkDedicatedAllocationBufferCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; + +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + + + +#define VK_AMD_draw_indirect_count 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#define VK_AMD_negative_viewport_height 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" + + +#define VK_AMD_gpu_shader_half_float 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" + + +#define VK_AMD_shader_ballot 1 +#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 +#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" + + +#define VK_AMD_texture_gather_bias_lod 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" + +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + + + +#define VK_AMD_shader_info 1 +#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 +#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" + + +typedef enum VkShaderInfoTypeAMD { + VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, + VK_SHADER_INFO_TYPE_BINARY_AMD = 1, + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, + VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD, + VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, + VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1), + VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderInfoTypeAMD; + +typedef struct VkShaderResourceUsageAMD { + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; + +typedef struct VkShaderStatisticsInfoAMD { + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo); +#endif + +#define VK_AMD_shader_image_load_store_lod 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" + + +#define VK_IMG_format_pvrtc 1 +#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 +#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" + + +#define VK_NV_external_memory_capabilities 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" + + +typedef enum VkExternalMemoryHandleTypeFlagBitsNV { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsNV; +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + +typedef enum VkExternalMemoryFeatureFlagBitsNV { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsNV; +typedef VkFlags VkExternalMemoryFeatureFlagsNV; + +typedef struct VkExternalImageFormatPropertiesNV { + VkImageFormatProperties imageFormatProperties; + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; +} VkExternalImageFormatPropertiesNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); +#endif + +#define VK_NV_external_memory 1 +#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" + +typedef struct VkExternalMemoryImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExternalMemoryImageCreateInfoNV; + +typedef struct VkExportMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; + + + +#define VK_EXT_validation_flags 1 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" + + +typedef enum VkValidationCheckEXT { + VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, + VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, + VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, + VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCheckEXT; + +typedef struct VkValidationFlagsEXT { + VkStructureType sType; + const void* pNext; + uint32_t disabledValidationCheckCount; + VkValidationCheckEXT* pDisabledValidationChecks; +} VkValidationFlagsEXT; + + + +#define VK_EXT_shader_subgroup_ballot 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" + + +#define VK_EXT_shader_subgroup_vote 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" + + +#define VK_NVX_device_generated_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) + +#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 +#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" + + +typedef enum VkIndirectCommandsTokenTypeNVX { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeNVX; + +typedef enum VkObjectEntryTypeNVX { + VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, + VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, + VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, + VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, + VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, + VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, + VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), + VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkObjectEntryTypeNVX; + + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsNVX; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; + +typedef enum VkObjectEntryUsageFlagBitsNVX { + VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, + VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, + VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkObjectEntryUsageFlagBitsNVX; +typedef VkFlags VkObjectEntryUsageFlagsNVX; + +typedef struct VkDeviceGeneratedCommandsFeaturesNVX { + VkStructureType sType; + const void* pNext; + VkBool32 computeBindingPointSupport; +} VkDeviceGeneratedCommandsFeaturesNVX; + +typedef struct VkDeviceGeneratedCommandsLimitsNVX { + VkStructureType sType; + const void* pNext; + uint32_t maxIndirectCommandsLayoutTokenCount; + uint32_t maxObjectEntryCounts; + uint32_t minSequenceCountBufferOffsetAlignment; + uint32_t minSequenceIndexBufferOffsetAlignment; + uint32_t minCommandsTokenBufferOffsetAlignment; +} VkDeviceGeneratedCommandsLimitsNVX; + +typedef struct VkIndirectCommandsTokenNVX { + VkIndirectCommandsTokenTypeNVX tokenType; + VkBuffer buffer; + VkDeviceSize offset; +} VkIndirectCommandsTokenNVX; + +typedef struct VkIndirectCommandsLayoutTokenNVX { + VkIndirectCommandsTokenTypeNVX tokenType; + uint32_t bindingUnit; + uint32_t dynamicCount; + uint32_t divisor; +} VkIndirectCommandsLayoutTokenNVX; + +typedef struct VkIndirectCommandsLayoutCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkIndirectCommandsLayoutUsageFlagsNVX flags; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenNVX* pTokens; +} VkIndirectCommandsLayoutCreateInfoNVX; + +typedef struct VkCmdProcessCommandsInfoNVX { + VkStructureType sType; + const void* pNext; + VkObjectTableNVX objectTable; + VkIndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t indirectCommandsTokenCount; + const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; + uint32_t maxSequencesCount; + VkCommandBuffer targetCommandBuffer; + VkBuffer sequencesCountBuffer; + VkDeviceSize sequencesCountOffset; + VkBuffer sequencesIndexBuffer; + VkDeviceSize sequencesIndexOffset; +} VkCmdProcessCommandsInfoNVX; + +typedef struct VkCmdReserveSpaceForCommandsInfoNVX { + VkStructureType sType; + const void* pNext; + VkObjectTableNVX objectTable; + VkIndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t maxSequencesCount; +} VkCmdReserveSpaceForCommandsInfoNVX; + +typedef struct VkObjectTableCreateInfoNVX { + VkStructureType sType; + const void* pNext; + uint32_t objectCount; + const VkObjectEntryTypeNVX* pObjectEntryTypes; + const uint32_t* pObjectEntryCounts; + const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; + uint32_t maxUniformBuffersPerDescriptor; + uint32_t maxStorageBuffersPerDescriptor; + uint32_t maxStorageImagesPerDescriptor; + uint32_t maxSampledImagesPerDescriptor; + uint32_t maxPipelineLayouts; +} VkObjectTableCreateInfoNVX; + +typedef struct VkObjectTableEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; +} VkObjectTableEntryNVX; + +typedef struct VkObjectTablePipelineEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipeline pipeline; +} VkObjectTablePipelineEntryNVX; + +typedef struct VkObjectTableDescriptorSetEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipelineLayout pipelineLayout; + VkDescriptorSet descriptorSet; +} VkObjectTableDescriptorSetEntryNVX; + +typedef struct VkObjectTableVertexBufferEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkBuffer buffer; +} VkObjectTableVertexBufferEntryNVX; + +typedef struct VkObjectTableIndexBufferEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkBuffer buffer; + VkIndexType indexType; +} VkObjectTableIndexBufferEntryNVX; + +typedef struct VkObjectTablePushConstantEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipelineLayout pipelineLayout; + VkShaderStageFlags stageFlags; +} VkObjectTablePushConstantEntryNVX; + + +typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable); +typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices); +typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX( + VkDevice device, + VkIndirectCommandsLayoutNVX indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX( + VkDevice device, + const VkObjectTableCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkObjectTableNVX* pObjectTable); + +VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX( + VkDevice device, + VkObjectTableNVX objectTable, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX( + VkDevice device, + VkObjectTableNVX objectTable, + uint32_t objectCount, + const VkObjectTableEntryNVX* const* ppObjectTableEntries, + const uint32_t* pObjectIndices); + +VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX( + VkDevice device, + VkObjectTableNVX objectTable, + uint32_t objectCount, + const VkObjectEntryTypeNVX* pObjectEntryTypes, + const uint32_t* pObjectIndices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( + VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, + VkDeviceGeneratedCommandsLimitsNVX* pLimits); +#endif + +#define VK_NV_clip_space_w_scaling 1 +#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 +#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" + +typedef struct VkViewportWScalingNV { + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); +#endif + +#define VK_EXT_direct_mode_display 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif + +#define VK_EXT_display_surface_counter 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" +#define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT + + +typedef enum VkSurfaceCounterFlagBitsEXT { + VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, + VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSurfaceCounterFlagBitsEXT; +typedef VkFlags VkSurfaceCounterFlagsEXT; + +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +#endif + +#define VK_EXT_display_control 1 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" + + +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT, + VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT, + VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1), + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, + VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, + VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1), + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, + VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, + VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1), + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; + +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); +#endif + +#define VK_GOOGLE_display_timing 1 +#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 +#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" + +typedef struct VkRefreshCycleDurationGOOGLE { + uint64_t refreshDuration; +} VkRefreshCycleDurationGOOGLE; + +typedef struct VkPastPresentationTimingGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; +} VkPastPresentationTimingGOOGLE; + +typedef struct VkPresentTimeGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; +} VkPresentTimeGOOGLE; + +typedef struct VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes; +} VkPresentTimesInfoGOOGLE; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); +#endif + +#define VK_NV_sample_mask_override_coverage 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" + + +#define VK_NV_geometry_shader_passthrough 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" + + +#define VK_NV_viewport_array2 1 +#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" + + +#define VK_NVX_multiview_per_view_attributes 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" + +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext; + VkBool32 perViewPositionAllComponents; +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + + +#define VK_NV_viewport_swizzle 1 +#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" + + +typedef enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1), + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF +} VkViewportCoordinateSwizzleNV; + +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + +typedef struct VkViewportSwizzleNV { + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; + + + +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1), + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; + +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); +#endif + +#define VK_EXT_conservative_rasterization 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" + + +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1), + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; + +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + +#define VK_EXT_swapchain_colorspace 1 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" + + +#define VK_EXT_hdr_metadata 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 1 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" + +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + + +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); +#endif + +#define VK_EXT_external_memory_dma_buf 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" + + +#define VK_EXT_queue_family_foreign 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" +#define VK_QUEUE_FAMILY_FOREIGN_EXT (~0U-2) + + +#define VK_EXT_debug_utils 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) + +#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 1 +#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" + +typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; +typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; + +typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageSeverityFlagBitsEXT; +typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; + +typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, + VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageTypeFlagBitsEXT; +typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; + +typedef struct VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; +} VkDebugUtilsObjectNameInfoEXT; + +typedef struct VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugUtilsObjectTagInfoEXT; + +typedef struct VkDebugUtilsLabelEXT { + VkStructureType sType; + const void* pNext; + const char* pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT; + +typedef struct VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + VkDebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + VkDebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + VkDebugUtilsObjectNameInfoEXT* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; +} VkDebugUtilsMessengerCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); +typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( + VkQueue queue); + +VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +#endif + +#define VK_EXT_sampler_filter_minmax 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" + + +typedef enum VkSamplerReductionModeEXT { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, + VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, + VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSamplerReductionModeEXT; + +typedef struct VkSamplerReductionModeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSamplerReductionModeEXT reductionMode; +} VkSamplerReductionModeCreateInfoEXT; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + + +#define VK_AMD_gpu_shader_int16 1 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" + + +#define VK_AMD_mixed_attachment_samples 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" + + +#define VK_AMD_shader_fragment_mask 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" + + +#define VK_EXT_shader_stencil_export 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" + + +#define VK_EXT_sample_locations 1 +#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 +#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" + +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +#endif + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, + VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_NV_fragment_coverage_to_color 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" + +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + + + +#define VK_NV_framebuffer_mixed_samples 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" + + +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, + VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, + VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; + +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + + + +#define VK_NV_fill_rectangle 1 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" + + +#define VK_EXT_post_depth_coverage 1 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" + + +#define VK_EXT_validation_cache 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) + +#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" +#define VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT + + +typedef enum VkValidationCacheHeaderVersionEXT { + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, + VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, + VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1), + VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCacheHeaderVersionEXT; + +typedef VkFlags VkValidationCacheCreateFlagsEXT; + +typedef struct VkValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; +} VkValidationCacheCreateInfoEXT; + +typedef struct VkShaderModuleValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheEXT validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData); +#endif + +#define VK_EXT_descriptor_indexing 1 +#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 +#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" + + +typedef enum VkDescriptorBindingFlagBitsEXT { + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 0x00000001, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 0x00000002, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 0x00000008, + VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDescriptorBindingFlagBitsEXT; +typedef VkFlags VkDescriptorBindingFlagsEXT; + +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkDescriptorBindingFlagsEXT* pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; + +typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeaturesEXT; + +typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingPropertiesEXT; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; + + + +#define VK_EXT_shader_viewport_index_layer 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" + + +#define VK_EXT_global_priority 1 +#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 +#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" + + +typedef enum VkQueueGlobalPriorityEXT { + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, + VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, + VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, + VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1), + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF +} VkQueueGlobalPriorityEXT; + +typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkQueueGlobalPriorityEXT globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + +#define VK_EXT_external_memory_host 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" + +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +#endif + +#define VK_AMD_buffer_marker 1 +#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 +#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" + +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); +#endif + +#define VK_AMD_shader_core_properties 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" + +typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { + VkStructureType sType; + void* pNext; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; +} VkPhysicalDeviceShaderCorePropertiesAMD; + + + +#define VK_EXT_vertex_attribute_divisor 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" + +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +typedef struct VkVertexInputBindingDivisorDescriptionEXT { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; + +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; + + + +#define VK_NV_shader_subgroup_partitioned 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_ios.h b/generator/Vulkan-Headers/include/vulkan/vulkan_ios.h new file mode 100644 index 0000000..a092481 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_ios.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_IOS_H_ +#define VULKAN_IOS_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_MVK_ios_surface 1 +#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" + +typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + +typedef struct VkIOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkIOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkIOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_macos.h b/generator/Vulkan-Headers/include/vulkan/vulkan_macos.h new file mode 100644 index 0000000..ff0b701 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_macos.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_MACOS_H_ +#define VULKAN_MACOS_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_MVK_macos_surface 1 +#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" + +typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + +typedef struct VkMacOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkMacOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkMacOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_mir.h b/generator/Vulkan-Headers/include/vulkan/vulkan_mir.h new file mode 100644 index 0000000..7d24ed2 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_mir.h @@ -0,0 +1,65 @@ +#ifndef VULKAN_MIR_H_ +#define VULKAN_MIR_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_mir_surface 1 +#define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 +#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" + +typedef VkFlags VkMirSurfaceCreateFlagsKHR; + +typedef struct VkMirSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkMirSurfaceCreateFlagsKHR flags; + MirConnection* connection; + MirSurface* mirSurface; +} VkMirSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( + VkInstance instance, + const VkMirSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + MirConnection* connection); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_vi.h b/generator/Vulkan-Headers/include/vulkan/vulkan_vi.h new file mode 100644 index 0000000..015166b --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_vi.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_VI_H_ +#define VULKAN_VI_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_NN_vi_surface 1 +#define VK_NN_VI_SURFACE_SPEC_VERSION 1 +#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" + +typedef VkFlags VkViSurfaceCreateFlagsNN; + +typedef struct VkViSurfaceCreateInfoNN { + VkStructureType sType; + const void* pNext; + VkViSurfaceCreateFlagsNN flags; + void* window; +} VkViSurfaceCreateInfoNN; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h b/generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h new file mode 100644 index 0000000..5ba0827 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h @@ -0,0 +1,65 @@ +#ifndef VULKAN_WAYLAND_H_ +#define VULKAN_WAYLAND_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_wayland_surface 1 +#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" + +typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + +typedef struct VkWaylandSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; +} VkWaylandSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_win32.h b/generator/Vulkan-Headers/include/vulkan/vulkan_win32.h new file mode 100644 index 0000000..6a85409 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_win32.h @@ -0,0 +1,276 @@ +#ifndef VULKAN_WIN32_H_ +#define VULKAN_WIN32_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_win32_surface 1 +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" + +typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + +typedef struct VkWin32SurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWin32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; +} VkWin32SurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif + +#define VK_KHR_external_memory_win32 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR; + +typedef struct VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR; + +typedef struct VkMemoryWin32HandlePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR; + +typedef struct VkMemoryGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif + +#define VK_KHR_win32_keyed_mutex 1 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoKHR; + + + +#define VK_KHR_external_semaphore_win32 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" + +typedef struct VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportSemaphoreWin32HandleInfoKHR; + +typedef struct VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHR; + +typedef struct VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHR; + +typedef struct VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif + +#define VK_KHR_external_fence_win32 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" + +typedef struct VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + +typedef struct VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + +typedef struct VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif + +#define VK_NV_external_memory_win32 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; +} VkImportMemoryWin32HandleInfoNV; + +typedef struct VkExportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; +} VkExportMemoryWin32HandleInfoNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle); +#endif + +#define VK_NV_win32_keyed_mutex 1 +#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoNV; + + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h b/generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h new file mode 100644 index 0000000..ba03600 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h @@ -0,0 +1,66 @@ +#ifndef VULKAN_XCB_H_ +#define VULKAN_XCB_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_xcb_surface 1 +#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" + +typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + +typedef struct VkXcbSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; +} VkXcbSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h b/generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h new file mode 100644 index 0000000..e1d967e --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h @@ -0,0 +1,66 @@ +#ifndef VULKAN_XLIB_H_ +#define VULKAN_XLIB_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_xlib_surface 1 +#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" + +typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + +typedef struct VkXlibSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; +} VkXlibSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h b/generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h new file mode 100644 index 0000000..117d017 --- /dev/null +++ b/generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h @@ -0,0 +1,54 @@ +#ifndef VULKAN_XLIB_XRANDR_H_ +#define VULKAN_XLIB_XRANDR_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_EXT_acquire_xlib_display 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" + +typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/generator/Vulkan-Headers/registry/cgenerator.py b/generator/Vulkan-Headers/registry/cgenerator.py new file mode 100644 index 0000000..a370970 --- /dev/null +++ b/generator/Vulkan-Headers/registry/cgenerator.py @@ -0,0 +1,417 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2013-2018 The Khronos Group Inc. +# +# 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. + +import os,re,sys,pdb +from generator import * + +# CGeneratorOptions - subclass of GeneratorOptions. +# +# Adds options used by COutputGenerator objects during C language header +# generation. +# +# Additional members +# prefixText - list of strings to prefix generated header with +# (usually a copyright statement + calling convention macros). +# protectFile - True if multiple inclusion protection should be +# generated (based on the filename) around the entire header. +# protectFeature - True if #ifndef..#endif protection should be +# generated around a feature interface in the header file. +# genFuncPointers - True if function pointer typedefs should be +# generated +# protectProto - If conditional protection should be generated +# around prototype declarations, set to either '#ifdef' +# to require opt-in (#ifdef protectProtoStr) or '#ifndef' +# to require opt-out (#ifndef protectProtoStr). Otherwise +# set to None. +# protectProtoStr - #ifdef/#ifndef symbol to use around prototype +# declarations, if protectProto is set +# apicall - string to use for the function declaration prefix, +# such as APICALL on Windows. +# apientry - string to use for the calling convention macro, +# in typedefs, such as APIENTRY. +# apientryp - string to use for the calling convention macro +# in function pointer typedefs, such as APIENTRYP. +# directory - directory into which to generate include files +# indentFuncProto - True if prototype declarations should put each +# parameter on a separate line +# indentFuncPointer - True if typedefed function pointers should put each +# parameter on a separate line +# alignFuncParam - if nonzero and parameters are being put on a +# separate line, align parameter names at the specified column +class CGeneratorOptions(GeneratorOptions): + """Represents options during C interface generation for headers""" + def __init__(self, + filename = None, + directory = '.', + apiname = None, + profile = None, + versions = '.*', + emitversions = '.*', + defaultExtensions = None, + addExtensions = None, + removeExtensions = None, + emitExtensions = None, + sortProcedure = regSortFeatures, + prefixText = "", + genFuncPointers = True, + protectFile = True, + protectFeature = True, + protectProto = None, + protectProtoStr = None, + apicall = '', + apientry = '', + apientryp = '', + indentFuncProto = True, + indentFuncPointer = False, + alignFuncParam = 0): + GeneratorOptions.__init__(self, filename, directory, apiname, profile, + versions, emitversions, defaultExtensions, + addExtensions, removeExtensions, + emitExtensions, sortProcedure) + self.prefixText = prefixText + self.genFuncPointers = genFuncPointers + self.protectFile = protectFile + self.protectFeature = protectFeature + self.protectProto = protectProto + self.protectProtoStr = protectProtoStr + self.apicall = apicall + self.apientry = apientry + self.apientryp = apientryp + self.indentFuncProto = indentFuncProto + self.indentFuncPointer = indentFuncPointer + self.alignFuncParam = alignFuncParam + +# COutputGenerator - subclass of OutputGenerator. +# Generates C-language API interfaces. +# +# ---- methods ---- +# COutputGenerator(errFile, warnFile, diagFile) - args as for +# OutputGenerator. Defines additional internal state. +# ---- methods overriding base class ---- +# beginFile(genOpts) +# endFile() +# beginFeature(interface, emit) +# endFeature() +# genType(typeinfo,name) +# genStruct(typeinfo,name) +# genGroup(groupinfo,name) +# genEnum(enuminfo, name) +# genCmd(cmdinfo) +class COutputGenerator(OutputGenerator): + """Generate specified API interfaces in a specific style, such as a C header""" + # This is an ordered list of sections in the header file. + TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum', + 'group', 'bitmask', 'funcpointer', 'struct'] + ALL_SECTIONS = TYPE_SECTIONS + ['commandPointer', 'command'] + def __init__(self, + errFile = sys.stderr, + warnFile = sys.stderr, + diagFile = sys.stdout): + OutputGenerator.__init__(self, errFile, warnFile, diagFile) + # Internal state - accumulators for different inner block text + self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) + # + def beginFile(self, genOpts): + OutputGenerator.beginFile(self, genOpts) + # C-specific + # + # Multiple inclusion protection & C++ wrappers. + if (genOpts.protectFile and self.genOpts.filename): + headerSym = re.sub('\.h', '_h_', + os.path.basename(self.genOpts.filename)).upper() + write('#ifndef', headerSym, file=self.outFile) + write('#define', headerSym, '1', file=self.outFile) + self.newline() + write('#ifdef __cplusplus', file=self.outFile) + write('extern "C" {', file=self.outFile) + write('#endif', file=self.outFile) + self.newline() + # + # User-supplied prefix text, if any (list of strings) + if (genOpts.prefixText): + for s in genOpts.prefixText: + write(s, file=self.outFile) + # + # Some boilerplate describing what was generated - this + # will probably be removed later since the extensions + # pattern may be very long. + # write('/* Generated C header for:', file=self.outFile) + # write(' * API:', genOpts.apiname, file=self.outFile) + # if (genOpts.profile): + # write(' * Profile:', genOpts.profile, file=self.outFile) + # write(' * Versions considered:', genOpts.versions, file=self.outFile) + # write(' * Versions emitted:', genOpts.emitversions, file=self.outFile) + # write(' * Default extensions included:', genOpts.defaultExtensions, file=self.outFile) + # write(' * Additional extensions included:', genOpts.addExtensions, file=self.outFile) + # write(' * Extensions removed:', genOpts.removeExtensions, file=self.outFile) + # write(' * Extensions emitted:', genOpts.emitExtensions, file=self.outFile) + # write(' */', file=self.outFile) + def endFile(self): + # C-specific + # Finish C++ wrapper and multiple inclusion protection + self.newline() + write('#ifdef __cplusplus', file=self.outFile) + write('}', file=self.outFile) + write('#endif', file=self.outFile) + if (self.genOpts.protectFile and self.genOpts.filename): + self.newline() + write('#endif', file=self.outFile) + # Finish processing in superclass + OutputGenerator.endFile(self) + def beginFeature(self, interface, emit): + # Start processing in superclass + OutputGenerator.beginFeature(self, interface, emit) + # C-specific + # Accumulate includes, defines, types, enums, function pointer typedefs, + # end function prototypes separately for this feature. They're only + # printed in endFeature(). + self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) + def endFeature(self): + # C-specific + # Actually write the interface to the output file. + if (self.emit): + self.newline() + if (self.genOpts.protectFeature): + write('#ifndef', self.featureName, file=self.outFile) + # If type declarations are needed by other features based on + # this one, it may be necessary to suppress the ExtraProtect, + # or move it below the 'for section...' loop. + if (self.featureExtraProtect != None): + write('#ifdef', self.featureExtraProtect, file=self.outFile) + write('#define', self.featureName, '1', file=self.outFile) + for section in self.TYPE_SECTIONS: + contents = self.sections[section] + if contents: + write('\n'.join(contents), file=self.outFile) + self.newline() + if (self.genOpts.genFuncPointers and self.sections['commandPointer']): + write('\n'.join(self.sections['commandPointer']), file=self.outFile) + self.newline() + if (self.sections['command']): + if (self.genOpts.protectProto): + write(self.genOpts.protectProto, + self.genOpts.protectProtoStr, file=self.outFile) + write('\n'.join(self.sections['command']), end='', file=self.outFile) + if (self.genOpts.protectProto): + write('#endif', file=self.outFile) + else: + self.newline() + if (self.featureExtraProtect != None): + write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile) + if (self.genOpts.protectFeature): + write('#endif /*', self.featureName, '*/', file=self.outFile) + # Finish processing in superclass + OutputGenerator.endFeature(self) + # + # Append a definition to the specified section + def appendSection(self, section, text): + # self.sections[section].append('SECTION: ' + section + '\n') + self.sections[section].append(text) + # self.logMsg('diag', 'appendSection(section =', section, 'text =', text) + # + # Type generation + def genType(self, typeinfo, name, alias): + OutputGenerator.genType(self, typeinfo, name, alias) + typeElem = typeinfo.elem + + # Determine the category of the type, and the type section to add + # its definition to. + # 'funcpointer' is added to the 'struct' section as a workaround for + # internal issue #877, since structures and function pointer types + # can have cross-dependencies. + category = typeElem.get('category') + if category == 'funcpointer': + section = 'struct' + else: + section = category + + if category == 'struct' or category == 'union': + # If the type is a struct type, generate it using the + # special-purpose generator. + self.genStruct(typeinfo, name, alias) + else: + if alias: + # If the type is an alias, just emit a typedef declaration + body = 'typedef ' + alias + ' ' + name + ';\n' + else: + # Replace tags with an APIENTRY-style string + # (from self.genOpts). Copy other text through unchanged. + # If the resulting text is an empty string, don't emit it. + body = noneStr(typeElem.text) + for elem in typeElem: + if (elem.tag == 'apientry'): + body += self.genOpts.apientry + noneStr(elem.tail) + else: + body += noneStr(elem.text) + noneStr(elem.tail) + + if body: + # Add extra newline after multi-line entries. + if '\n' in body[0:-1]: + body += '\n' + self.appendSection(section, body) + # + # Struct (e.g. C "struct" type) generation. + # This is a special case of the tag where the contents are + # interpreted as a set of tags instead of freeform C + # C type declarations. The tags are just like + # tags - they are a declaration of a struct or union member. + # Only simple member declarations are supported (no nested + # structs etc.) + # If alias != None, then this struct aliases another; just + # generate a typedef of that alias. + def genStruct(self, typeinfo, typeName, alias): + OutputGenerator.genStruct(self, typeinfo, typeName, alias) + + typeElem = typeinfo.elem + + if alias: + body = 'typedef ' + alias + ' ' + typeName + ';\n' + else: + body = 'typedef ' + typeElem.get('category') + ' ' + typeName + ' {\n' + + targetLen = 0; + for member in typeElem.findall('.//member'): + targetLen = max(targetLen, self.getCParamTypeLength(member)) + for member in typeElem.findall('.//member'): + body += self.makeCParamDecl(member, targetLen + 4) + body += ';\n' + body += '} ' + typeName + ';\n' + + self.appendSection('struct', body) + # + # Group (e.g. C "enum" type) generation. + # These are concatenated together with other types. + # If alias != None, it is the name of another group type + # which aliases this type; just generate that alias. + def genGroup(self, groupinfo, groupName, alias = None): + OutputGenerator.genGroup(self, groupinfo, groupName, alias) + groupElem = groupinfo.elem + + if alias: + # If the group name is aliased, just emit a typedef declaration + # for the alias. + body = 'typedef ' + alias + ' ' + groupName + ';\n' + else: + self.logMsg('diag', 'CGenerator.genGroup group =', groupName, 'alias =', alias) + + # Otherwise, emit an actual enumerated type declaration + expandName = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2',groupName).upper() + + expandPrefix = expandName + expandSuffix = '' + expandSuffixMatch = re.search(r'[A-Z][A-Z]+$',groupName) + if expandSuffixMatch: + expandSuffix = '_' + expandSuffixMatch.group() + # Strip off the suffix from the prefix + expandPrefix = expandName.rsplit(expandSuffix, 1)[0] + + # Prefix + body = "\ntypedef enum " + groupName + " {\n" + + # @@ Should use the type="bitmask" attribute instead + isEnum = ('FLAG_BITS' not in expandPrefix) + + # Get a list of nested 'enum' tags. + enums = groupElem.findall('enum') + + # Check for and report duplicates, and return a list with them + # removed. + enums = self.checkDuplicateEnums(enums) + + # Loop over the nested 'enum' tags. Keep track of the minimum and + # maximum numeric values, if they can be determined; but only for + # core API enumerants, not extension enumerants. This is inferred + # by looking for 'extends' attributes. + minName = None + + # Accumulate non-numeric enumerant values separately and append + # them following the numeric values, to allow for aliases. + # NOTE: this doesn't do a topological sort yet, so aliases of + # aliases can still get in the wrong order. + aliasText = "" + + for elem in enums: + # Convert the value to an integer and use that to track min/max. + (numVal,strVal) = self.enumToValue(elem, True) + name = elem.get('name') + + # Extension enumerants are only included if they are required + if self.isEnumRequired(elem): + decl = " " + name + " = " + strVal + ",\n" + if numVal != None: + body += decl + else: + aliasText += decl + + # Don't track min/max for non-numbers (numVal == None) + if isEnum and numVal != None and elem.get('extends') is None: + if minName == None: + minName = maxName = name + minValue = maxValue = numVal + elif numVal < minValue: + minName = name + minValue = numVal + elif numVal > maxValue: + maxName = name + maxValue = numVal + + # Now append the non-numeric enumerant values + body += aliasText + + # Generate min/max value tokens and a range-padding enum. Need some + # additional padding to generate correct names... + if isEnum: + body += " " + expandPrefix + "_BEGIN_RANGE" + expandSuffix + " = " + minName + ",\n" + body += " " + expandPrefix + "_END_RANGE" + expandSuffix + " = " + maxName + ",\n" + body += " " + expandPrefix + "_RANGE_SIZE" + expandSuffix + " = (" + maxName + " - " + minName + " + 1),\n" + + body += " " + expandPrefix + "_MAX_ENUM" + expandSuffix + " = 0x7FFFFFFF\n" + + # Postfix + body += "} " + groupName + ";" + + # After either enumerated type or alias paths, add the declaration + # to the appropriate section for the group being defined. + if groupElem.get('type') == 'bitmask': + section = 'bitmask' + else: + section = 'group' + self.appendSection(section, body) + + # Enumerant generation + # tags may specify their values in several ways, but are usually + # just integers. + def genEnum(self, enuminfo, name, alias): + OutputGenerator.genEnum(self, enuminfo, name, alias) + (numVal,strVal) = self.enumToValue(enuminfo.elem, False) + body = '#define ' + name.ljust(33) + ' ' + strVal + self.appendSection('enum', body) + + # + # Command generation + def genCmd(self, cmdinfo, name, alias): + OutputGenerator.genCmd(self, cmdinfo, name, alias) + + # if alias: + # prefix = '// ' + name + ' is an alias of command ' + alias + '\n' + # else: + # prefix = '' + + prefix = '' + decls = self.makeCDecls(cmdinfo.elem) + self.appendSection('command', prefix + decls[0] + '\n') + if (self.genOpts.genFuncPointers): + self.appendSection('commandPointer', decls[1]) diff --git a/generator/Vulkan-Headers/registry/generator.py b/generator/Vulkan-Headers/registry/generator.py new file mode 100644 index 0000000..a0f79ac --- /dev/null +++ b/generator/Vulkan-Headers/registry/generator.py @@ -0,0 +1,595 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2013-2018 The Khronos Group Inc. +# +# 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. + +from __future__ import unicode_literals +import io,os,re,sys,pdb + +def write( *args, **kwargs ): + file = kwargs.pop('file',sys.stdout) + end = kwargs.pop('end','\n') + file.write(' '.join([str(arg) for arg in args])) + file.write(end) + +# noneStr - returns string argument, or "" if argument is None. +# Used in converting etree Elements into text. +# str - string to convert +def noneStr(str): + if (str): + return str + else: + return "" + +# enquote - returns string argument with surrounding quotes, +# for serialization into Python code. +def enquote(str): + if (str): + return "'" + str + "'" + else: + return None + +# apiName - returns True if name is a Vulkan name (vk/Vk/VK prefix, or a +# function pointer type), False otherwise. +def apiName(str): + return str[0:2].lower() == 'vk' or str[0:3] == 'PFN' + +# Primary sort key for regSortFeatures. +# Sorts by category of the feature name string: +# Core API features (those defined with a tag) +# ARB/KHR/OES (Khronos extensions) +# other (EXT/vendor extensions) +# This will need changing for Vulkan! +def regSortCategoryKey(feature): + if (feature.elem.tag == 'feature'): + return 0 + elif (feature.category == 'ARB' or + feature.category == 'KHR' or + feature.category == 'OES'): + return 1 + else: + return 2 + +# Secondary sort key for regSortFeatures. +# Sorts by extension name. +def regSortNameKey(feature): + return feature.name + +# Second sort key for regSortFeatures. +# Sorts by feature version. elements all have version number "0" +def regSortFeatureVersionKey(feature): + return float(feature.versionNumber) + +# Tertiary sort key for regSortFeatures. +# Sorts by extension number. elements all have extension number 0. +def regSortExtensionNumberKey(feature): + return int(feature.number) + +# regSortFeatures - default sort procedure for features. +# Sorts by primary key of feature category ('feature' or 'extension') +# then by version number (for features) +# then by extension number (for extensions) +def regSortFeatures(featureList): + featureList.sort(key = regSortExtensionNumberKey) + featureList.sort(key = regSortFeatureVersionKey) + featureList.sort(key = regSortCategoryKey) + +# GeneratorOptions - base class for options used during header production +# These options are target language independent, and used by +# Registry.apiGen() and by base OutputGenerator objects. +# +# Members +# filename - basename of file to generate, or None to write to stdout. +# directory - directory in which to generate filename +# apiname - string matching 'apiname' attribute, e.g. 'gl'. +# profile - string specifying API profile , e.g. 'core', or None. +# versions - regex matching API versions to process interfaces for. +# Normally '.*' or '[0-9]\.[0-9]' to match all defined versions. +# emitversions - regex matching API versions to actually emit +# interfaces for (though all requested versions are considered +# when deciding which interfaces to generate). For GL 4.3 glext.h, +# this might be '1\.[2-5]|[2-4]\.[0-9]'. +# defaultExtensions - If not None, a string which must in its +# entirety match the pattern in the "supported" attribute of +# the . Defaults to None. Usually the same as apiname. +# addExtensions - regex matching names of additional extensions +# to include. Defaults to None. +# removeExtensions - regex matching names of extensions to +# remove (after defaultExtensions and addExtensions). Defaults +# to None. +# emitExtensions - regex matching names of extensions to actually emit +# interfaces for (though all requested versions are considered when +# deciding which interfaces to generate). +# sortProcedure - takes a list of FeatureInfo objects and sorts +# them in place to a preferred order in the generated output. +# Default is core API versions, ARB/KHR/OES extensions, all +# other extensions, alphabetically within each group. +# The regex patterns can be None or empty, in which case they match +# nothing. +class GeneratorOptions: + """Represents options during header production from an API registry""" + def __init__(self, + filename = None, + directory = '.', + apiname = None, + profile = None, + versions = '.*', + emitversions = '.*', + defaultExtensions = None, + addExtensions = None, + removeExtensions = None, + emitExtensions = None, + sortProcedure = regSortFeatures): + self.filename = filename + self.directory = directory + self.apiname = apiname + self.profile = profile + self.versions = self.emptyRegex(versions) + self.emitversions = self.emptyRegex(emitversions) + self.defaultExtensions = defaultExtensions + self.addExtensions = self.emptyRegex(addExtensions) + self.removeExtensions = self.emptyRegex(removeExtensions) + self.emitExtensions = self.emptyRegex(emitExtensions) + self.sortProcedure = sortProcedure + # + # Substitute a regular expression which matches no version + # or extension names for None or the empty string. + def emptyRegex(self,pat): + if (pat == None or pat == ''): + return '_nomatch_^' + else: + return pat + +# OutputGenerator - base class for generating API interfaces. +# Manages basic logic, logging, and output file control +# Derived classes actually generate formatted output. +# +# ---- methods ---- +# OutputGenerator(errFile, warnFile, diagFile) +# errFile, warnFile, diagFile - file handles to write errors, +# warnings, diagnostics to. May be None to not write. +# logMsg(level, *args) - log messages of different categories +# level - 'error', 'warn', or 'diag'. 'error' will also +# raise a UserWarning exception +# *args - print()-style arguments +# setExtMap(map) - specify a dictionary map from extension names to +# numbers, used in creating values for extension enumerants. +# makeDir(directory) - create a directory, if not already done. +# Generally called from derived generators creating hierarchies. +# beginFile(genOpts) - start a new interface file +# genOpts - GeneratorOptions controlling what's generated and how +# endFile() - finish an interface file, closing it when done +# beginFeature(interface, emit) - write interface for a feature +# and tag generated features as having been done. +# interface - element for the / to generate +# emit - actually write to the header only when True +# endFeature() - finish an interface. +# genType(typeinfo,name,alias) - generate interface for a type +# typeinfo - TypeInfo for a type +# genStruct(typeinfo,name,alias) - generate interface for a C "struct" type. +# typeinfo - TypeInfo for a type interpreted as a struct +# genGroup(groupinfo,name,alias) - generate interface for a group of enums (C "enum") +# groupinfo - GroupInfo for a group +# genEnum(enuminfo,name,alias) - generate interface for an enum (constant) +# enuminfo - EnumInfo for an enum +# name - enum name +# genCmd(cmdinfo,name,alias) - generate interface for a command +# cmdinfo - CmdInfo for a command +# isEnumRequired(enumElem) - return True if this element is required +# elem - element to test +# makeCDecls(cmd) - return C prototype and function pointer typedef for a +# Element, as a list of two strings +# cmd - Element for the +# newline() - print a newline to the output file (utility function) +# +class OutputGenerator: + """Generate specified API interfaces in a specific style, such as a C header""" + # + # categoryToPath - map XML 'category' to include file directory name + categoryToPath = { + 'bitmask' : 'flags', + 'enum' : 'enums', + 'funcpointer' : 'funcpointers', + 'handle' : 'handles', + 'define' : 'defines', + 'basetype' : 'basetypes', + } + # + # Constructor + def __init__(self, + errFile = sys.stderr, + warnFile = sys.stderr, + diagFile = sys.stdout): + self.outFile = None + self.errFile = errFile + self.warnFile = warnFile + self.diagFile = diagFile + # Internal state + self.featureName = None + self.genOpts = None + self.registry = None + # Used for extension enum value generation + self.extBase = 1000000000 + self.extBlockSize = 1000 + self.madeDirs = {} + # + # logMsg - write a message of different categories to different + # destinations. + # level - + # 'diag' (diagnostic, voluminous) + # 'warn' (warning) + # 'error' (fatal error - raises exception after logging) + # *args - print()-style arguments to direct to corresponding log + def logMsg(self, level, *args): + """Log a message at the given level. Can be ignored or log to a file""" + if (level == 'error'): + strfile = io.StringIO() + write('ERROR:', *args, file=strfile) + if (self.errFile != None): + write(strfile.getvalue(), file=self.errFile) + raise UserWarning(strfile.getvalue()) + elif (level == 'warn'): + if (self.warnFile != None): + write('WARNING:', *args, file=self.warnFile) + elif (level == 'diag'): + if (self.diagFile != None): + write('DIAG:', *args, file=self.diagFile) + else: + raise UserWarning( + '*** FATAL ERROR in Generator.logMsg: unknown level:' + level) + # + # enumToValue - parses and converts an tag into a value. + # Returns a list + # first element - integer representation of the value, or None + # if needsNum is False. The value must be a legal number + # if needsNum is True. + # second element - string representation of the value + # There are several possible representations of values. + # A 'value' attribute simply contains the value. + # A 'bitpos' attribute defines a value by specifying the bit + # position which is set in that value. + # A 'offset','extbase','extends' triplet specifies a value + # as an offset to a base value defined by the specified + # 'extbase' extension name, which is then cast to the + # typename specified by 'extends'. This requires probing + # the registry database, and imbeds knowledge of the + # Vulkan extension enum scheme in this function. + # A 'alias' attribute contains the name of another enum + # which this is an alias of. The other enum must be + # declared first when emitting this enum. + def enumToValue(self, elem, needsNum): + name = elem.get('name') + numVal = None + if ('value' in elem.keys()): + value = elem.get('value') + # print('About to translate value =', value, 'type =', type(value)) + if (needsNum): + numVal = int(value, 0) + # If there's a non-integer, numeric 'type' attribute (e.g. 'u' or + # 'ull'), append it to the string value. + # t = enuminfo.elem.get('type') + # if (t != None and t != '' and t != 'i' and t != 's'): + # value += enuminfo.type + self.logMsg('diag', 'Enum', name, '-> value [', numVal, ',', value, ']') + return [numVal, value] + if ('bitpos' in elem.keys()): + value = elem.get('bitpos') + numVal = int(value, 0) + numVal = 1 << numVal + value = '0x%08x' % numVal + self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']') + return [numVal, value] + if ('offset' in elem.keys()): + # Obtain values in the mapping from the attributes + enumNegative = False + offset = int(elem.get('offset'),0) + extnumber = int(elem.get('extnumber'),0) + extends = elem.get('extends') + if ('dir' in elem.keys()): + enumNegative = True + self.logMsg('diag', 'Enum', name, 'offset =', offset, + 'extnumber =', extnumber, 'extends =', extends, + 'enumNegative =', enumNegative) + # Now determine the actual enumerant value, as defined + # in the "Layers and Extensions" appendix of the spec. + numVal = self.extBase + (extnumber - 1) * self.extBlockSize + offset + if (enumNegative): + numVal = -numVal + value = '%d' % numVal + # More logic needed! + self.logMsg('diag', 'Enum', name, '-> offset [', numVal, ',', value, ']') + return [numVal, value] + if 'alias' in elem.keys(): + return [None, elem.get('alias')] + return [None, None] + # + # checkDuplicateEnums - sanity check for enumerated values + # enums - list of Elements + # returns the list with duplicates stripped + def checkDuplicateEnums(self, enums): + # Dictionaries indexed by name and numeric value. + # Entries are [ Element, numVal, strVal ] matching name or value + + nameMap = {} + valueMap = {} + + stripped = [] + for elem in enums: + name = elem.get('name') + (numVal, strVal) = self.enumToValue(elem, True) + + if name in nameMap: + # Duplicate name found; check values + (name2, numVal2, strVal2) = nameMap[name] + + # Duplicate enum values for the same name are benign. This + # happens when defining the same enum conditionally in + # several extension blocks. + if (strVal2 == strVal or (numVal != None and + numVal == numVal2)): + True + # self.logMsg('info', 'checkDuplicateEnums: Duplicate enum (' + name + + # ') found with the same value:' + strVal) + else: + self.logMsg('warn', 'checkDuplicateEnums: Duplicate enum (' + name + + ') found with different values:' + strVal + + ' and ' + strVal2) + + # Don't add the duplicate to the returned list + continue + elif numVal in valueMap: + # Duplicate value found (such as an alias); report it, but + # still add this enum to the list. + (name2, numVal2, strVal2) = valueMap[numVal] + + try: + self.logMsg('warn', 'Two enums found with the same value: ' + + name + ' = ' + name2.get('name') + ' = ' + strVal) + except: + pdb.set_trace() + + # Track this enum to detect followon duplicates + nameMap[name] = [ elem, numVal, strVal ] + if numVal != None: + valueMap[numVal] = [ elem, numVal, strVal ] + + # Add this enum to the list + stripped.append(elem) + + # Return the list + return stripped + # + def makeDir(self, path): + self.logMsg('diag', 'OutputGenerator::makeDir(' + path + ')') + if not (path in self.madeDirs.keys()): + # This can get race conditions with multiple writers, see + # https://stackoverflow.com/questions/273192/ + if not os.path.exists(path): + os.makedirs(path) + self.madeDirs[path] = None + # + def beginFile(self, genOpts): + self.genOpts = genOpts + # + # Open specified output file. Not done in constructor since a + # Generator can be used without writing to a file. + if (self.genOpts.filename != None): + filename = self.genOpts.directory + '/' + self.genOpts.filename + self.outFile = io.open(filename, 'w', encoding='utf-8') + else: + self.outFile = sys.stdout + def endFile(self): + self.errFile and self.errFile.flush() + self.warnFile and self.warnFile.flush() + self.diagFile and self.diagFile.flush() + self.outFile.flush() + if (self.outFile != sys.stdout and self.outFile != sys.stderr): + self.outFile.close() + self.genOpts = None + # + def beginFeature(self, interface, emit): + self.emit = emit + self.featureName = interface.get('name') + # If there's an additional 'protect' attribute in the feature, save it + self.featureExtraProtect = interface.get('protect') + def endFeature(self): + # Derived classes responsible for emitting feature + self.featureName = None + self.featureExtraProtect = None + # Utility method to validate we're generating something only inside a + # tag + def validateFeature(self, featureType, featureName): + if (self.featureName == None): + raise UserWarning('Attempt to generate', featureType, + featureName, 'when not in feature') + # + # Type generation + def genType(self, typeinfo, name, alias): + self.validateFeature('type', name) + # + # Struct (e.g. C "struct" type) generation + def genStruct(self, typeinfo, name, alias): + self.validateFeature('struct', name) + + # The mixed-mode tags may contain no-op tags. + # It is convenient to remove them here where all output generators + # will benefit. + for member in typeinfo.elem.findall('.//member'): + for comment in member.findall('comment'): + member.remove(comment) + # + # Group (e.g. C "enum" type) generation + def genGroup(self, groupinfo, name, alias): + self.validateFeature('group', name) + # + # Enumerant (really, constant) generation + def genEnum(self, enuminfo, name, alias): + self.validateFeature('enum', name) + # + # Command generation + def genCmd(self, cmd, name, alias): + self.validateFeature('command', name) + # + # Utility functions - turn a into C-language prototype + # and typedef declarations for that name. + # name - contents of tag + # tail - whatever text follows that tag in the Element + def makeProtoName(self, name, tail): + return self.genOpts.apientry + name + tail + def makeTypedefName(self, name, tail): + return '(' + self.genOpts.apientryp + 'PFN_' + name + tail + ')' + # + # makeCParamDecl - return a string which is an indented, formatted + # declaration for a or block (e.g. function parameter + # or structure/union member). + # param - Element ( or ) to format + # aligncol - if non-zero, attempt to align the nested element + # at this column + def makeCParamDecl(self, param, aligncol): + paramdecl = ' ' + noneStr(param.text) + for elem in param: + text = noneStr(elem.text) + tail = noneStr(elem.tail) + if (elem.tag == 'name' and aligncol > 0): + self.logMsg('diag', 'Aligning parameter', elem.text, 'to column', self.genOpts.alignFuncParam) + # Align at specified column, if possible + paramdecl = paramdecl.rstrip() + oldLen = len(paramdecl) + # This works around a problem where very long type names - + # longer than the alignment column - would run into the tail + # text. + paramdecl = paramdecl.ljust(aligncol-1) + ' ' + newLen = len(paramdecl) + self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl) + paramdecl += text + tail + return paramdecl + # + # getCParamTypeLength - return the length of the type field is an indented, formatted + # declaration for a or block (e.g. function parameter + # or structure/union member). + # param - Element ( or ) to identify + def getCParamTypeLength(self, param): + paramdecl = ' ' + noneStr(param.text) + for elem in param: + text = noneStr(elem.text) + tail = noneStr(elem.tail) + if (elem.tag == 'name'): + # Align at specified column, if possible + newLen = len(paramdecl.rstrip()) + self.logMsg('diag', 'Identifying length of', elem.text, 'as', newLen) + paramdecl += text + tail + return newLen + # + # isEnumRequired(elem) - return True if this element is + # required, False otherwise + # elem - element to test + def isEnumRequired(self, elem): + required = elem.get('required') != None + self.logMsg('diag', 'isEnumRequired:', elem.get('name'), + '->', required) + return required + + #@@@ This code is overridden by equivalent code now run in + #@@@ Registry.generateFeature + + required = False + + extname = elem.get('extname') + if extname is not None: + # 'supported' attribute was injected when the element was + # moved into the group in Registry.parseTree() + if self.genOpts.defaultExtensions == elem.get('supported'): + required = True + elif re.match(self.genOpts.addExtensions, extname) is not None: + required = True + elif elem.get('version') is not None: + required = re.match(self.genOpts.emitversions, elem.get('version')) is not None + else: + required = True + + return required + + # + # makeCDecls - return C prototype and function pointer typedef for a + # command, as a two-element list of strings. + # cmd - Element containing a tag + def makeCDecls(self, cmd): + """Generate C function pointer typedef for Element""" + proto = cmd.find('proto') + params = cmd.findall('param') + # Begin accumulating prototype and typedef strings + pdecl = self.genOpts.apicall + tdecl = 'typedef ' + # + # Insert the function return type/name. + # For prototypes, add APIENTRY macro before the name + # For typedefs, add (APIENTRY *) around the name and + # use the PFN_cmdnameproc naming convention. + # Done by walking the tree for element by element. + # etree has elem.text followed by (elem[i], elem[i].tail) + # for each child element and any following text + # Leading text + pdecl += noneStr(proto.text) + tdecl += noneStr(proto.text) + # For each child element, if it's a wrap in appropriate + # declaration. Otherwise append its contents and tail contents. + for elem in proto: + text = noneStr(elem.text) + tail = noneStr(elem.tail) + if (elem.tag == 'name'): + pdecl += self.makeProtoName(text, tail) + tdecl += self.makeTypedefName(text, tail) + else: + pdecl += text + tail + tdecl += text + tail + # Now add the parameter declaration list, which is identical + # for prototypes and typedefs. Concatenate all the text from + # a node without the tags. No tree walking required + # since all tags are ignored. + # Uses: self.indentFuncProto + # self.indentFuncPointer + # self.alignFuncParam + # Might be able to doubly-nest the joins, e.g. + # ','.join(('_'.join([l[i] for i in range(0,len(l))]) + n = len(params) + # Indented parameters + if n > 0: + indentdecl = '(\n' + for i in range(0,n): + paramdecl = self.makeCParamDecl(params[i], self.genOpts.alignFuncParam) + if (i < n - 1): + paramdecl += ',\n' + else: + paramdecl += ');' + indentdecl += paramdecl + else: + indentdecl = '(void);' + # Non-indented parameters + paramdecl = '(' + if n > 0: + for i in range(0,n): + paramdecl += ''.join([t for t in params[i].itertext()]) + if (i < n - 1): + paramdecl += ', ' + else: + paramdecl += 'void' + paramdecl += ");"; + return [ pdecl + indentdecl, tdecl + paramdecl ] + # + def newline(self): + write('', file=self.outFile) + + def setRegistry(self, registry): + self.registry = registry + # diff --git a/generator/Vulkan-Headers/registry/genvk.py b/generator/Vulkan-Headers/registry/genvk.py new file mode 100644 index 0000000..6d7760b --- /dev/null +++ b/generator/Vulkan-Headers/registry/genvk.py @@ -0,0 +1,531 @@ +#!/usr/bin/python3 +# +# Copyright (c) 2013-2018 The Khronos Group Inc. +# +# 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. + +import argparse, cProfile, pdb, string, sys, time +from reg import * +from generator import write +from cgenerator import CGeneratorOptions, COutputGenerator +from docgenerator import DocGeneratorOptions, DocOutputGenerator +from extensionmetadocgenerator import ExtensionMetaDocGeneratorOptions, ExtensionMetaDocOutputGenerator +from pygenerator import PyOutputGenerator +from validitygenerator import ValidityOutputGenerator +from hostsyncgenerator import HostSynchronizationOutputGenerator +from extensionStubSource import ExtensionStubSourceOutputGenerator + +# Simple timer functions +startTime = None + +def startTimer(timeit): + global startTime + startTime = time.clock() + +def endTimer(timeit, msg): + global startTime + endTime = time.clock() + if (timeit): + write(msg, endTime - startTime, file=sys.stderr) + startTime = None + +# Turn a list of strings into a regexp string matching exactly those strings +def makeREstring(list, default = None): + if len(list) > 0 or default == None: + return '^(' + '|'.join(list) + ')$' + else: + return default + +# Returns a directory of [ generator function, generator options ] indexed +# by specified short names. The generator options incorporate the following +# parameters: +# +# args is an parsed argument object; see below for the fields that are used. +def makeGenOpts(args): + global genOpts + genOpts = {} + + # Default class of extensions to include, or None + defaultExtensions = args.defaultExtensions + + # Additional extensions to include (list of extensions) + extensions = args.extension + + # Extensions to remove (list of extensions) + removeExtensions = args.removeExtensions + + # Extensions to emit (list of extensions) + emitExtensions = args.emitExtensions + + # Features to include (list of features) + features = args.feature + + # Whether to disable inclusion protect in headers + protect = args.protect + + # Output target directory + directory = args.directory + + # Descriptive names for various regexp patterns used to select + # versions and extensions + allFeatures = allExtensions = '.*' + noFeatures = noExtensions = None + + # Turn lists of names/patterns into matching regular expressions + addExtensionsPat = makeREstring(extensions, None) + removeExtensionsPat = makeREstring(removeExtensions, None) + emitExtensionsPat = makeREstring(emitExtensions, allExtensions) + featuresPat = makeREstring(features, allFeatures) + + # Copyright text prefixing all headers (list of strings). + prefixStrings = [ + '/*', + '** Copyright (c) 2015-2018 The Khronos Group Inc.', + '**', + '** 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.', + '*/', + '' + ] + + # Text specific to Vulkan headers + vkPrefixStrings = [ + '/*', + '** This header is generated from the Khronos Vulkan XML API Registry.', + '**', + '*/', + '' + ] + + # Defaults for generating re-inclusion protection wrappers (or not) + protectFile = protect + protectFeature = protect + protectProto = protect + + # API include files for spec and ref pages + # Overwrites include subdirectories in spec source tree + # The generated include files do not include the calling convention + # macros (apientry etc.), unlike the header files. + # Because the 1.0 core branch includes ref pages for extensions, + # all the extension interfaces need to be generated, even though + # none are used by the core spec itself. + genOpts['apiinc'] = [ + DocOutputGenerator, + DocGeneratorOptions( + filename = 'timeMarker', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + apicall = '', + apientry = '', + apientryp = '*', + alignFuncParam = 48, + expandEnumerants = False) + ] + + # API names to validate man/api spec includes & links + genOpts['vkapi.py'] = [ + PyOutputGenerator, + DocGeneratorOptions( + filename = 'vkapi.py', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat) + ] + + # API validity files for spec + genOpts['validinc'] = [ + ValidityOutputGenerator, + DocGeneratorOptions( + filename = 'timeMarker', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat) + ] + + # API host sync table files for spec + genOpts['hostsyncinc'] = [ + HostSynchronizationOutputGenerator, + DocGeneratorOptions( + filename = 'timeMarker', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat) + ] + + # Extension stub source dispatcher + # This target is no longer maintained and supported. + # See README.adoc for discussion. + genOpts['vulkan_ext.c'] = [ + ExtensionStubSourceOutputGenerator, + CGeneratorOptions( + filename = 'vulkan_ext.c', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = None, + defaultExtensions = None, + addExtensions = '.*', + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + alignFuncParam = 48) + ] + + # Extension metainformation for spec extension appendices + genOpts['extinc'] = [ + ExtensionMetaDocOutputGenerator, + ExtensionMetaDocGeneratorOptions( + filename = 'timeMarker', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = None, + defaultExtensions = defaultExtensions, + addExtensions = None, + removeExtensions = None, + emitExtensions = emitExtensionsPat) + ] + + # Platform extensions, in their own header files + # Each element of the platforms[] array defines information for + # generating a single platform: + # [0] is the generated header file name + # [1] is the set of platform extensions to generate + # [2] is additional extensions whose interfaces should be considered, + # but suppressed in the output, to avoid duplicate definitions of + # dependent types like VkDisplayKHR and VkSurfaceKHR which come from + # non-platform extensions. + + # Track all platform extensions, for exclusion from vulkan_core.h + allPlatformExtensions = [] + + # Extensions suppressed for all platforms. + # Covers common WSI extension types. + commonSuppressExtensions = [ 'VK_KHR_display', 'VK_KHR_swapchain' ] + + platforms = [ + [ 'vulkan_android.h', [ 'VK_KHR_android_surface', + 'VK_ANDROID_external_memory_android_hardware_buffer' + ], commonSuppressExtensions ], + [ 'vulkan_ios.h', [ 'VK_MVK_ios_surface' ], commonSuppressExtensions ], + [ 'vulkan_macos.h', [ 'VK_MVK_macos_surface' ], commonSuppressExtensions ], + [ 'vulkan_mir.h', [ 'VK_KHR_mir_surface' ], commonSuppressExtensions ], + [ 'vulkan_vi.h', [ 'VK_NN_vi_surface' ], commonSuppressExtensions ], + [ 'vulkan_wayland.h', [ 'VK_KHR_wayland_surface' ], commonSuppressExtensions ], + [ 'vulkan_win32.h', [ 'VK_.*_win32(|_.*)' ], commonSuppressExtensions + [ 'VK_KHR_external_semaphore', 'VK_KHR_external_memory_capabilities', 'VK_KHR_external_fence', 'VK_KHR_external_fence_capabilities', 'VK_NV_external_memory_capabilities' ] ], + [ 'vulkan_xcb.h', [ 'VK_KHR_xcb_surface' ], commonSuppressExtensions ], + [ 'vulkan_xlib.h', [ 'VK_KHR_xlib_surface' ], commonSuppressExtensions ], + [ 'vulkan_xlib_xrandr.h', [ 'VK_EXT_acquire_xlib_display' ], commonSuppressExtensions ], + ] + + for platform in platforms: + headername = platform[0] + + allPlatformExtensions += platform[1] + + addPlatformExtensionsRE = makeREstring(platform[1] + platform[2]) + emitPlatformExtensionsRE = makeREstring(platform[1]) + + opts = CGeneratorOptions( + filename = headername, + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = None, + defaultExtensions = None, + addExtensions = addPlatformExtensionsRE, + removeExtensions = None, + emitExtensions = emitPlatformExtensionsRE, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + + genOpts[headername] = [ COutputGenerator, opts ] + + # Header for core API + extensions. + # To generate just the core API, + # change to 'defaultExtensions = None' below. + # + # By default this adds all enabled, non-platform extensions. + # It removes all platform extensions (from the platform headers options + # constructed above) as well as any explicitly specified removals. + + removeExtensionsPat = makeREstring(allPlatformExtensions + removeExtensions, None) + + genOpts['vulkan_core.h'] = [ + COutputGenerator, + CGeneratorOptions( + filename = 'vulkan_core.h', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = defaultExtensions, + addExtensions = None, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + # Unused - vulkan10.h target. + # It is possible to generate a header with just the Vulkan 1.0 + + # extension interfaces defined, but since the promoted KHR extensions + # are now defined in terms of the 1.1 interfaces, such a header is very + # similar to vulkan_core.h. + genOpts['vulkan10.h'] = [ + COutputGenerator, + CGeneratorOptions( + filename = 'vulkan10.h', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = 'VK_VERSION_1_0', + emitversions = 'VK_VERSION_1_0', + defaultExtensions = defaultExtensions, + addExtensions = None, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + genOpts['alias.h'] = [ + COutputGenerator, + CGeneratorOptions( + filename = 'alias.h', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = defaultExtensions, + addExtensions = None, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = None, + genFuncPointers = False, + protectFile = False, + protectFeature = False, + protectProto = '', + protectProtoStr = '', + apicall = '', + apientry = '', + apientryp = '', + alignFuncParam = 36) + ] + +# Generate a target based on the options in the matching genOpts{} object. +# This is encapsulated in a function so it can be profiled and/or timed. +# The args parameter is an parsed argument object containing the following +# fields that are used: +# target - target to generate +# directory - directory to generate it in +# protect - True if re-inclusion wrappers should be created +# extensions - list of additional extensions to include in generated +# interfaces +def genTarget(args): + global genOpts + + # Create generator options with specified parameters + makeGenOpts(args) + + if (args.target in genOpts.keys()): + createGenerator = genOpts[args.target][0] + options = genOpts[args.target][1] + + if not args.quiet: + write('* Building', options.filename, file=sys.stderr) + write('* options.versions =', options.versions, file=sys.stderr) + write('* options.emitversions =', options.emitversions, file=sys.stderr) + write('* options.defaultExtensions =', options.defaultExtensions, file=sys.stderr) + write('* options.addExtensions =', options.addExtensions, file=sys.stderr) + write('* options.removeExtensions =', options.removeExtensions, file=sys.stderr) + write('* options.emitExtensions =', options.emitExtensions, file=sys.stderr) + + startTimer(args.time) + gen = createGenerator(errFile=errWarn, + warnFile=errWarn, + diagFile=diag) + reg.setGenerator(gen) + reg.apiGen(options) + + if not args.quiet: + write('* Generated', options.filename, file=sys.stderr) + endTimer(args.time, '* Time to generate ' + options.filename + ' =') + else: + write('No generator options for unknown target:', + args.target, file=sys.stderr) + +# -feature name +# -extension name +# For both, "name" may be a single name, or a space-separated list +# of names, or a regular expression. +if __name__ == '__main__': + parser = argparse.ArgumentParser() + + parser.add_argument('-defaultExtensions', action='store', + default='vulkan', + help='Specify a single class of extensions to add to targets') + parser.add_argument('-extension', action='append', + default=[], + help='Specify an extension or extensions to add to targets') + parser.add_argument('-removeExtensions', action='append', + default=[], + help='Specify an extension or extensions to remove from targets') + parser.add_argument('-emitExtensions', action='append', + default=[], + help='Specify an extension or extensions to emit in targets') + parser.add_argument('-feature', action='append', + default=[], + help='Specify a core API feature name or names to add to targets') + parser.add_argument('-debug', action='store_true', + help='Enable debugging') + parser.add_argument('-dump', action='store_true', + help='Enable dump to stderr') + parser.add_argument('-diagfile', action='store', + default=None, + help='Write diagnostics to specified file') + parser.add_argument('-errfile', action='store', + default=None, + help='Write errors and warnings to specified file instead of stderr') + parser.add_argument('-noprotect', dest='protect', action='store_false', + help='Disable inclusion protection in output headers') + parser.add_argument('-profile', action='store_true', + help='Enable profiling') + parser.add_argument('-registry', action='store', + default='vk.xml', + help='Use specified registry file instead of vk.xml') + parser.add_argument('-time', action='store_true', + help='Enable timing') + parser.add_argument('-validate', action='store_true', + help='Enable group validation') + parser.add_argument('-o', action='store', dest='directory', + default='.', + help='Create target and related files in specified directory') + parser.add_argument('target', metavar='target', nargs='?', + help='Specify target') + parser.add_argument('-quiet', action='store_true', default=True, + help='Suppress script output during normal execution.') + parser.add_argument('-verbose', action='store_false', dest='quiet', default=True, + help='Enable script output during normal execution.') + + args = parser.parse_args() + + # This splits arguments which are space-separated lists + args.feature = [name for arg in args.feature for name in arg.split()] + args.extension = [name for arg in args.extension for name in arg.split()] + + # Load & parse registry + reg = Registry() + + startTimer(args.time) + tree = etree.parse(args.registry) + endTimer(args.time, '* Time to make ElementTree =') + + if args.debug: + pdb.run('reg.loadElementTree(tree)') + else: + startTimer(args.time) + reg.loadElementTree(tree) + endTimer(args.time, '* Time to parse ElementTree =') + + if (args.validate): + reg.validateGroups() + + if (args.dump): + write('* Dumping registry to regdump.txt', file=sys.stderr) + reg.dumpReg(filehandle = open('regdump.txt', 'w', encoding='utf-8')) + + # create error/warning & diagnostic files + if (args.errfile): + errWarn = open(args.errfile, 'w', encoding='utf-8') + else: + errWarn = sys.stderr + + if (args.diagfile): + diag = open(args.diagfile, 'w', encoding='utf-8') + else: + diag = None + + if (args.debug): + pdb.run('genTarget(args)') + elif (args.profile): + import cProfile, pstats + cProfile.run('genTarget(args)', 'profile.txt') + p = pstats.Stats('profile.txt') + p.strip_dirs().sort_stats('time').print_stats(50) + else: + genTarget(args) diff --git a/generator/Vulkan-Headers/registry/reg.py b/generator/Vulkan-Headers/registry/reg.py new file mode 100644 index 0000000..c9f92db --- /dev/null +++ b/generator/Vulkan-Headers/registry/reg.py @@ -0,0 +1,1066 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2013-2018 The Khronos Group Inc. +# +# 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. + +import io,os,pdb,re,string,sys,copy +import xml.etree.ElementTree as etree +from collections import defaultdict + +# matchAPIProfile - returns whether an API and profile +# being generated matches an element's profile +# api - string naming the API to match +# profile - string naming the profile to match +# elem - Element which (may) have 'api' and 'profile' +# attributes to match to. +# If a tag is not present in the Element, the corresponding API +# or profile always matches. +# Otherwise, the tag must exactly match the API or profile. +# Thus, if 'profile' = core: +# with no attribute will match +# will match +# will not match +# Possible match conditions: +# Requested Element +# Profile Profile +# --------- -------- +# None None Always matches +# 'string' None Always matches +# None 'string' Does not match. Can't generate multiple APIs +# or profiles, so if an API/profile constraint +# is present, it must be asked for explicitly. +# 'string' 'string' Strings must match +# +# ** In the future, we will allow regexes for the attributes, +# not just strings, so that api="^(gl|gles2)" will match. Even +# this isn't really quite enough, we might prefer something +# like "gl(core)|gles1(common-lite)". +def matchAPIProfile(api, profile, elem): + """Match a requested API & profile name to a api & profile attributes of an Element""" + match = True + # Match 'api', if present + if ('api' in elem.attrib): + if (api == None): + raise UserWarning("No API requested, but 'api' attribute is present with value '" + + elem.get('api') + "'") + elif (api != elem.get('api')): + # Requested API doesn't match attribute + return False + if ('profile' in elem.attrib): + if (profile == None): + raise UserWarning("No profile requested, but 'profile' attribute is present with value '" + + elem.get('profile') + "'") + elif (profile != elem.get('profile')): + # Requested profile doesn't match attribute + return False + return True + +# BaseInfo - base class for information about a registry feature +# (type/group/enum/command/API/extension). +# required - should this feature be defined during header generation +# (has it been removed by a profile or version)? +# declared - has this feature been defined already? +# elem - etree Element for this feature +# resetState() - reset required/declared to initial values. Used +# prior to generating a new API interface. +# compareElem(info) - return True if self.elem and info.elem have the +# same definition. +class BaseInfo: + """Represents the state of a registry feature, used during API generation""" + def __init__(self, elem): + self.required = False + self.declared = False + self.elem = elem + def resetState(self): + self.required = False + self.declared = False + def compareElem(self, info): + # Just compares the tag and attributes. + # @@ This should be virtualized. In particular, comparing + # tags requires special-casing on the attributes, as 'extnumber' is + # only relevant when 'offset' is present. + selfKeys = sorted(self.elem.keys()) + infoKeys = sorted(info.elem.keys()) + + if selfKeys != infoKeys: + return False + + # Ignore value of 'extname' and 'extnumber', as these will inherently + # be different when redefining the same interface in different feature + # and/or extension blocks. + for key in selfKeys: + if (key != 'extname' and key != 'extnumber' and + (self.elem.get(key) != info.elem.get(key))): + return False + + return True + +# TypeInfo - registry information about a type. No additional state +# beyond BaseInfo is required. +class TypeInfo(BaseInfo): + """Represents the state of a registry type""" + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.additionalValidity = [] + self.removedValidity = [] + def resetState(self): + BaseInfo.resetState(self) + self.additionalValidity = [] + self.removedValidity = [] + +# GroupInfo - registry information about a group of related enums +# in an block, generally corresponding to a C "enum" type. +class GroupInfo(BaseInfo): + """Represents the state of a registry group""" + def __init__(self, elem): + BaseInfo.__init__(self, elem) + +# EnumInfo - registry information about an enum +# type - numeric type of the value of the tag +# ( '' for GLint, 'u' for GLuint, 'ull' for GLuint64 ) +class EnumInfo(BaseInfo): + """Represents the state of a registry enum""" + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.type = elem.get('type') + if (self.type == None): + self.type = '' + +# CmdInfo - registry information about a command +class CmdInfo(BaseInfo): + """Represents the state of a registry command""" + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.additionalValidity = [] + self.removedValidity = [] + def resetState(self): + BaseInfo.resetState(self) + self.additionalValidity = [] + self.removedValidity = [] + +# FeatureInfo - registry information about an API +# or +# name - feature name string (e.g. 'VK_KHR_surface') +# version - feature version number (e.g. 1.2). +# features are unversioned and assigned version number 0. +# ** This is confusingly taken from the 'number' attribute of . +# Needs fixing. +# number - extension number, used for ordering and for +# assigning enumerant offsets. features do +# not have extension numbers and are assigned number 0. +# category - category, e.g. VERSION or khr/vendor tag +# emit - has this feature been defined already? +class FeatureInfo(BaseInfo): + """Represents the state of an API feature (version/extension)""" + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.name = elem.get('name') + # Determine element category (vendor). Only works + # for elements. + if (elem.tag == 'feature'): + self.category = 'VERSION' + self.version = elem.get('name') + self.versionNumber = elem.get('number') + self.number = "0" + self.supported = None + else: + self.category = self.name.split('_', 2)[1] + self.version = "0" + self.versionNumber = "0" + self.number = elem.get('number') + self.supported = elem.get('supported') + self.emit = False + +from generator import write, GeneratorOptions, OutputGenerator + +# Registry - object representing an API registry, loaded from an XML file +# Members +# tree - ElementTree containing the root +# typedict - dictionary of TypeInfo objects keyed by type name +# groupdict - dictionary of GroupInfo objects keyed by group name +# enumdict - dictionary of EnumInfo objects keyed by enum name +# cmddict - dictionary of CmdInfo objects keyed by command name +# apidict - dictionary of Elements keyed by API name +# extensions - list of Elements +# extdict - dictionary of Elements keyed by extension name +# gen - OutputGenerator object used to write headers / messages +# genOpts - GeneratorOptions object used to control which +# fetures to write and how to format them +# emitFeatures - True to actually emit features for a version / extension, +# or False to just treat them as emitted +# breakPat - regexp pattern to break on when generatng names +# Public methods +# loadElementTree(etree) - load registry from specified ElementTree +# loadFile(filename) - load registry from XML file +# setGenerator(gen) - OutputGenerator to use +# breakOnName() - specify a feature name regexp to break on when +# generating features. +# parseTree() - parse the registry once loaded & create dictionaries +# dumpReg(maxlen, filehandle) - diagnostic to dump the dictionaries +# to specified file handle (default stdout). Truncates type / +# enum / command elements to maxlen characters (default 80) +# generator(g) - specify the output generator object +# apiGen(apiname, genOpts) - generate API headers for the API type +# and profile specified in genOpts, but only for the versions and +# extensions specified there. +# apiReset() - call between calls to apiGen() to reset internal state +# Private methods +# addElementInfo(elem,info,infoName,dictionary) - add feature info to dict +# lookupElementInfo(fname,dictionary) - lookup feature info in dict +class Registry: + """Represents an API registry loaded from XML""" + def __init__(self): + self.tree = None + self.typedict = {} + self.groupdict = {} + self.enumdict = {} + self.cmddict = {} + self.apidict = {} + self.extensions = [] + self.requiredextensions = [] # Hack - can remove it after validity generator goes away + self.validextensionstructs = defaultdict(list) + self.extdict = {} + # A default output generator, so commands prior to apiGen can report + # errors via the generator object. + self.gen = OutputGenerator() + self.genOpts = None + self.emitFeatures = False + self.breakPat = None + # self.breakPat = re.compile('VkFenceImportFlagBits.*') + def loadElementTree(self, tree): + """Load ElementTree into a Registry object and parse it""" + self.tree = tree + self.parseTree() + def loadFile(self, file): + """Load an API registry XML file into a Registry object and parse it""" + self.tree = etree.parse(file) + self.parseTree() + def setGenerator(self, gen): + """Specify output generator object. None restores the default generator""" + self.gen = gen + self.gen.setRegistry(self) + + # addElementInfo - add information about an element to the + # corresponding dictionary + # elem - ///// Element + # info - corresponding {Type|Group|Enum|Cmd|Feature}Info object + # infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' + # dictionary - self.{type|group|enum|cmd|api|ext}dict + # If the Element has an 'api' attribute, the dictionary key is the + # tuple (name,api). If not, the key is the name. 'name' is an + # attribute of the Element + def addElementInfo(self, elem, info, infoName, dictionary): + # self.gen.logMsg('diag', 'Adding ElementInfo.required =', + # info.required, 'name =', elem.get('name')) + + if ('api' in elem.attrib): + key = (elem.get('name'),elem.get('api')) + else: + key = elem.get('name') + if key in dictionary: + if not dictionary[key].compareElem(info): + self.gen.logMsg('warn', 'Attempt to redefine', key, + 'with different value (this may be benign)') + #else: + # self.gen.logMsg('warn', 'Benign redefinition of', key, + # 'with identical value') + else: + dictionary[key] = info + # + # lookupElementInfo - find a {Type|Enum|Cmd}Info object by name. + # If an object qualified by API name exists, use that. + # fname - name of type / enum / command + # dictionary - self.{type|enum|cmd}dict + def lookupElementInfo(self, fname, dictionary): + key = (fname, self.genOpts.apiname) + if (key in dictionary): + # self.gen.logMsg('diag', 'Found API-specific element for feature', fname) + return dictionary[key] + elif (fname in dictionary): + # self.gen.logMsg('diag', 'Found generic element for feature', fname) + return dictionary[fname] + else: + return None + def breakOnName(self, regexp): + self.breakPat = re.compile(regexp) + def parseTree(self): + """Parse the registry Element, once created""" + # This must be the Element for the root + self.reg = self.tree.getroot() + # + # Create dictionary of registry types from toplevel tags + # and add 'name' attribute to each tag (where missing) + # based on its element. + # + # There's usually one block; more are OK + # Required attributes: 'name' or nested tag contents + self.typedict = {} + for type in self.reg.findall('types/type'): + # If the doesn't already have a 'name' attribute, set + # it from contents of its tag. + if (type.get('name') == None): + type.attrib['name'] = type.find('name').text + self.addElementInfo(type, TypeInfo(type), 'type', self.typedict) + # + # Create dictionary of registry enum groups from tags. + # + # Required attributes: 'name'. If no name is given, one is + # generated, but that group can't be identified and turned into an + # enum type definition - it's just a container for tags. + self.groupdict = {} + for group in self.reg.findall('enums'): + self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict) + # + # Create dictionary of registry enums from tags + # + # tags usually define different namespaces for the values + # defined in those tags, but the actual names all share the + # same dictionary. + # Required attributes: 'name', 'value' + # For containing which have type="enum" or type="bitmask", + # tag all contained s are required. This is a stopgap until + # a better scheme for tagging core and extension enums is created. + self.enumdict = {} + for enums in self.reg.findall('enums'): + required = (enums.get('type') != None) + for enum in enums.findall('enum'): + enumInfo = EnumInfo(enum) + enumInfo.required = required + self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) + # self.gen.logMsg('diag', 'parseTree: marked req =', + # required, 'for', enum.get('name')) + # + # Create dictionary of registry commands from tags + # and add 'name' attribute to each tag (where missing) + # based on its element. + # + # There's usually only one block; more are OK. + # Required attributes: 'name' or tag contents + self.cmddict = {} + # List of commands which alias others. Contains + # [ aliasName, element ] + # for each alias + cmdAlias = [] + for cmd in self.reg.findall('commands/command'): + # If the doesn't already have a 'name' attribute, set + # it from contents of its tag. + name = cmd.get('name') + if name == None: + name = cmd.attrib['name'] = cmd.find('proto/name').text + ci = CmdInfo(cmd) + self.addElementInfo(cmd, ci, 'command', self.cmddict) + alias = cmd.get('alias') + if alias: + cmdAlias.append([name, alias, cmd]) + # Now loop over aliases, injecting a copy of the aliased command's + # Element with the aliased prototype name replaced with the command + # name - if it exists. + for (name, alias, cmd) in cmdAlias: + if alias in self.cmddict: + #@ pdb.set_trace() + aliasInfo = self.cmddict[alias] + cmdElem = copy.deepcopy(aliasInfo.elem) + cmdElem.find('proto/name').text = name + cmdElem.attrib['name'] = name + cmdElem.attrib['alias'] = alias + ci = CmdInfo(cmdElem) + # Replace the dictionary entry for the CmdInfo element + self.cmddict[name] = ci + + #@ newString = etree.tostring(base, encoding="unicode").replace(aliasValue, aliasName) + #@elem.append(etree.fromstring(replacement)) + else: + self.gen.logMsg('warn', 'No matching found for command', + cmd.get('name'), 'alias', alias) + + # + # Create dictionaries of API and extension interfaces + # from toplevel and tags. + # + self.apidict = {} + for feature in self.reg.findall('feature'): + featureInfo = FeatureInfo(feature) + self.addElementInfo(feature, featureInfo, 'feature', self.apidict) + + # Add additional enums defined only in tags + # to the corresponding core type. + # When seen here, the element, processed to contain the + # numeric enum value, is added to the corresponding + # element, as well as adding to the enum dictionary. It is + # *removed* from the element it is introduced in. + # Not doing this will cause spurious genEnum() + # calls to be made in output generation, and it's easier + # to handle here than in genEnum(). + # + # In lxml.etree, an Element can have only one parent, so the + # append() operation also removes the element. But in Python's + # ElementTree package, an Element can have multiple parents. So + # it must be explicitly removed from the tag, leading + # to the nested loop traversal of / elements + # below. + # + # This code also adds a 'version' attribute containing the + # api version. + # + # For tags which are actually just constants, if there's + # no 'extends' tag but there is a 'value' or 'bitpos' tag, just + # add an EnumInfo record to the dictionary. That works because + # output generation of constants is purely dependency-based, and + # doesn't need to iterate through the XML tags. + # + for elem in feature.findall('require'): + for enum in elem.findall('enum'): + addEnumInfo = False + groupName = enum.get('extends') + if (groupName != None): + # self.gen.logMsg('diag', 'Found extension enum', + # enum.get('name')) + # Add version number attribute to the element + enum.attrib['version'] = featureInfo.version + # Look up the GroupInfo with matching groupName + if (groupName in self.groupdict.keys()): + # self.gen.logMsg('diag', 'Matching group', + # groupName, 'found, adding element...') + gi = self.groupdict[groupName] + gi.elem.append(enum) + # Remove element from parent tag + # This should be a no-op in lxml.etree + elem.remove(enum) + else: + self.gen.logMsg('warn', 'NO matching group', + groupName, 'for enum', enum.get('name'), 'found.') + addEnumInfo = True + elif (enum.get('value') or enum.get('bitpos') or enum.get('alias')): + # self.gen.logMsg('diag', 'Adding extension constant "enum"', + # enum.get('name')) + addEnumInfo = True + if (addEnumInfo): + enumInfo = EnumInfo(enum) + self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) + + self.extensions = self.reg.findall('extensions/extension') + self.extdict = {} + for feature in self.extensions: + featureInfo = FeatureInfo(feature) + self.addElementInfo(feature, featureInfo, 'extension', self.extdict) + + # Add additional enums defined only in tags + # to the corresponding core type. + # Algorithm matches that of enums in a "feature" tag as above. + # + # This code also adds a 'extnumber' attribute containing the + # extension number, used for enumerant value calculation. + # + for elem in feature.findall('require'): + for enum in elem.findall('enum'): + addEnumInfo = False + groupName = enum.get('extends') + if (groupName != None): + # self.gen.logMsg('diag', 'Found extension enum', + # enum.get('name')) + + # Add block's extension number attribute to + # the element unless specified explicitly, such + # as when redefining an enum in another extension. + extnumber = enum.get('extnumber') + if not extnumber: + enum.attrib['extnumber'] = featureInfo.number + + enum.attrib['extname'] = featureInfo.name + enum.attrib['supported'] = featureInfo.supported + # Look up the GroupInfo with matching groupName + if (groupName in self.groupdict.keys()): + # self.gen.logMsg('diag', 'Matching group', + # groupName, 'found, adding element...') + gi = self.groupdict[groupName] + gi.elem.append(enum) + # Remove element from parent tag + # This should be a no-op in lxml.etree + elem.remove(enum) + else: + self.gen.logMsg('warn', 'NO matching group', + groupName, 'for enum', enum.get('name'), 'found.') + addEnumInfo = True + elif (enum.get('value') or enum.get('bitpos') or enum.get('alias')): + # self.gen.logMsg('diag', 'Adding extension constant "enum"', + # enum.get('name')) + addEnumInfo = True + if (addEnumInfo): + enumInfo = EnumInfo(enum) + self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) + + # Construct a "validextensionstructs" list for parent structures + # based on "structextends" tags in child structures + for type in self.reg.findall('types/type'): + parentStructs = type.get('structextends') + if (parentStructs != None): + for parent in parentStructs.split(','): + # self.gen.logMsg('diag', type.get('name'), 'extends', parent) + self.validextensionstructs[parent].append(type.get('name')) + # Sort the lists so they don't depend on the XML order + for parent in self.validextensionstructs: + self.validextensionstructs[parent].sort() + + def dumpReg(self, maxlen = 120, filehandle = sys.stdout): + """Dump all the dictionaries constructed from the Registry object""" + write('***************************************', file=filehandle) + write(' ** Dumping Registry contents **', file=filehandle) + write('***************************************', file=filehandle) + write('// Types', file=filehandle) + for name in self.typedict: + tobj = self.typedict[name] + write(' Type', name, '->', etree.tostring(tobj.elem)[0:maxlen], file=filehandle) + write('// Groups', file=filehandle) + for name in self.groupdict: + gobj = self.groupdict[name] + write(' Group', name, '->', etree.tostring(gobj.elem)[0:maxlen], file=filehandle) + write('// Enums', file=filehandle) + for name in self.enumdict: + eobj = self.enumdict[name] + write(' Enum', name, '->', etree.tostring(eobj.elem)[0:maxlen], file=filehandle) + write('// Commands', file=filehandle) + for name in self.cmddict: + cobj = self.cmddict[name] + write(' Command', name, '->', etree.tostring(cobj.elem)[0:maxlen], file=filehandle) + write('// APIs', file=filehandle) + for key in self.apidict: + write(' API Version ', key, '->', + etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle) + write('// Extensions', file=filehandle) + for key in self.extdict: + write(' Extension', key, '->', + etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle) + # write('***************************************', file=filehandle) + # write(' ** Dumping XML ElementTree **', file=filehandle) + # write('***************************************', file=filehandle) + # write(etree.tostring(self.tree.getroot(),pretty_print=True), file=filehandle) + # + # typename - name of type + # required - boolean (to tag features as required or not) + def markTypeRequired(self, typename, required): + """Require (along with its dependencies) or remove (but not its dependencies) a type""" + self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required) + # Get TypeInfo object for tag corresponding to typename + type = self.lookupElementInfo(typename, self.typedict) + if (type != None): + if (required): + # Tag type dependencies in 'alias' and 'required' attributes as + # required. This DOES NOT un-tag dependencies in a + # tag. See comments in markRequired() below for the reason. + for attrib in [ 'requires', 'alias' ]: + depname = type.elem.get(attrib) + if depname: + self.gen.logMsg('diag', 'Generating dependent type', + depname, 'for', attrib, 'type', typename) + # Don't recurse on self-referential structures. + if (typename != depname): + self.markTypeRequired(depname, required) + else: + self.gen.logMsg('diag', 'type', typename, 'is self-referential') + # Tag types used in defining this type (e.g. in nested + # tags) + # Look for in entire tree, + # not just immediate children + for subtype in type.elem.findall('.//type'): + self.gen.logMsg('diag', 'markRequired: type requires dependent ', subtype.text) + if (typename != subtype.text): + self.markTypeRequired(subtype.text, required) + else: + self.gen.logMsg('diag', 'type', typename, 'is self-referential') + # Tag enums used in defining this type, for example in + # member[MEMBER_SIZE] + for subenum in type.elem.findall('.//enum'): + self.gen.logMsg('diag', 'markRequired: type requires dependent ', subenum.text) + self.markEnumRequired(subenum.text, required) + type.required = required + else: + self.gen.logMsg('warn', 'type:', typename , 'IS NOT DEFINED') + # + # enumname - name of enum + # required - boolean (to tag features as required or not) + def markEnumRequired(self, enumname, required): + self.gen.logMsg('diag', 'tagging enum:', enumname, '-> required =', required) + enum = self.lookupElementInfo(enumname, self.enumdict) + if (enum != None): + enum.required = required + # Tag enum dependencies in 'alias' attribute as required + depname = enum.elem.get('alias') + if depname: + self.gen.logMsg('diag', 'Generating dependent enum', + depname, 'for alias', enumname, 'required =', enum.required) + self.markEnumRequired(depname, required) + else: + self.gen.logMsg('warn', 'enum:', enumname , 'IS NOT DEFINED') + # + # cmdname - name of command + # required - boolean (to tag features as required or not) + def markCmdRequired(self, cmdname, required): + self.gen.logMsg('diag', 'tagging command:', cmdname, '-> required =', required) + cmd = self.lookupElementInfo(cmdname, self.cmddict) + if (cmd != None): + cmd.required = required + # Tag command dependencies in 'alias' attribute as required + depname = cmd.elem.get('alias') + if depname: + self.gen.logMsg('diag', 'Generating dependent command', + depname, 'for alias', cmdname) + self.markCmdRequired(depname, required) + # Tag all parameter types of this command as required. + # This DOES NOT remove types of commands in a + # tag, because many other commands may use the same type. + # We could be more clever and reference count types, + # instead of using a boolean. + if (required): + # Look for in entire tree, + # not just immediate children + for type in cmd.elem.findall('.//type'): + self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type.text) + self.markTypeRequired(type.text, required) + else: + self.gen.logMsg('warn', 'command:', name, 'IS NOT DEFINED') + # + # features - Element for or tag + # required - boolean (to tag features as required or not) + def markRequired(self, features, required): + """Require or remove features specified in the Element""" + self.gen.logMsg('diag', 'markRequired (features = , required =', required, ')') + # Loop over types, enums, and commands in the tag + # @@ It would be possible to respect 'api' and 'profile' attributes + # in individual features, but that's not done yet. + for typeElem in features.findall('type'): + self.markTypeRequired(typeElem.get('name'), required) + for enumElem in features.findall('enum'): + self.markEnumRequired(enumElem.get('name'), required) + for cmdElem in features.findall('command'): + self.markCmdRequired(cmdElem.get('name'), required) + # + # interface - Element for or , containing + # and tags + # api - string specifying API name being generated + # profile - string specifying API profile being generated + def requireAndRemoveFeatures(self, interface, api, profile): + """Process and tags for a or """ + # marks things that are required by this version/profile + for feature in interface.findall('require'): + if (matchAPIProfile(api, profile, feature)): + self.markRequired(feature,True) + # marks things that are removed by this version/profile + for feature in interface.findall('remove'): + if (matchAPIProfile(api, profile, feature)): + self.markRequired(feature,False) + + def assignAdditionalValidity(self, interface, api, profile): + # + # Loop over all usage inside all tags. + for feature in interface.findall('require'): + if (matchAPIProfile(api, profile, feature)): + for v in feature.findall('usage'): + if v.get('command'): + self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v)) + if v.get('struct'): + self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v)) + + # + # Loop over all usage inside all tags. + for feature in interface.findall('remove'): + if (matchAPIProfile(api, profile, feature)): + for v in feature.findall('usage'): + if v.get('command'): + self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v)) + if v.get('struct'): + self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v)) + + # + # generateFeature - generate a single type / enum group / enum / command, + # and all its dependencies as needed. + # fname - name of feature (//) + # ftype - type of feature, 'type' | 'enum' | 'command' + # dictionary - of *Info objects - self.{type|enum|cmd}dict + def generateFeature(self, fname, ftype, dictionary): + #@ # Break to debugger on matching name pattern + #@ if self.breakPat and re.match(self.breakPat, fname): + #@ pdb.set_trace() + + self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname) + f = self.lookupElementInfo(fname, dictionary) + if (f == None): + # No such feature. This is an error, but reported earlier + self.gen.logMsg('diag', 'No entry found for feature', fname, + 'returning!') + return + # + # If feature isn't required, or has already been declared, return + if (not f.required): + self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)') + return + if (f.declared): + self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)') + return + # Always mark feature declared, as though actually emitted + f.declared = True + + # Determine if this is an alias, and of what, if so + alias = f.elem.get('alias') + if alias: + self.gen.logMsg('diag', fname, 'is an alias of', alias) + + # + # Pull in dependent declaration(s) of the feature. + # For types, there may be one type in the 'required' attribute of + # the element, one in the 'alias' attribute, and many in + # imbedded and tags within the element. + # For commands, there may be many in tags within the element. + # For enums, no dependencies are allowed (though perhaps if you + # have a uint64 enum, it should require that type). + genProc = None + if (ftype == 'type'): + genProc = self.gen.genType + + # Generate type dependencies in 'alias' and 'required' attributes + if alias: + self.generateFeature(alias, 'type', self.typedict) + requires = f.elem.get('requires') + if requires: + self.generateFeature(requires, 'type', self.typedict) + + # Generate types used in defining this type (e.g. in nested + # tags) + # Look for in entire tree, + # not just immediate children + for subtype in f.elem.findall('.//type'): + self.gen.logMsg('diag', 'Generating required dependent ', + subtype.text) + self.generateFeature(subtype.text, 'type', self.typedict) + + # Generate enums used in defining this type, for example in + # member[MEMBER_SIZE] + for subtype in f.elem.findall('.//enum'): + self.gen.logMsg('diag', 'Generating required dependent ', + subtype.text) + self.generateFeature(subtype.text, 'enum', self.enumdict) + + # If the type is an enum group, look up the corresponding + # group in the group dictionary and generate that instead. + if (f.elem.get('category') == 'enum'): + self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead') + group = self.lookupElementInfo(fname, self.groupdict) + if alias != None: + # An alias of another group name. + # Pass to genGroup with 'alias' parameter = aliased name + self.gen.logMsg('diag', 'Generating alias', fname, + 'for enumerated type', alias) + # Now, pass the *aliased* GroupInfo to the genGroup, but + # with an additional parameter which is the alias name. + genProc = self.gen.genGroup + f = self.lookupElementInfo(alias, self.groupdict) + elif group == None: + self.gen.logMsg('warn', 'Skipping enum type', fname, + ': No matching enumerant group') + return + else: + genProc = self.gen.genGroup + f = group + + #@ The enum group is not ready for generation. At this + #@ point, it contains all tags injected by + #@ tags without any verification of whether + #@ they're required or not. It may also contain + #@ duplicates injected by multiple consistent + #@ definitions of an . + + #@ Pass over each enum, marking its enumdict[] entry as + #@ required or not. Mark aliases of enums as required, + #@ too. + + enums = group.elem.findall('enum') + + self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname) + + # Check for required enums, including aliases + # LATER - Check for, report, and remove duplicates? + enumAliases = [] + for elem in enums: + name = elem.get('name') + + required = False + + extname = elem.get('extname') + version = elem.get('version') + if extname is not None: + # 'supported' attribute was injected when the element was + # moved into the group in Registry.parseTree() + if self.genOpts.defaultExtensions == elem.get('supported'): + required = True + elif re.match(self.genOpts.addExtensions, extname) is not None: + required = True + elif version is not None: + required = re.match(self.genOpts.emitversions, version) is not None + else: + required = True + + self.gen.logMsg('diag', '* required =', required, 'for', name) + if required: + # Mark this element as required (in the element, not the EnumInfo) + elem.attrib['required'] = 'true' + # If it's an alias, track that for later use + enumAlias = elem.get('alias') + if enumAlias: + enumAliases.append(enumAlias) + for elem in enums: + name = elem.get('name') + if name in enumAliases: + elem.attrib['required'] = 'true' + self.gen.logMsg('diag', '* also need to require alias', name) + elif (ftype == 'command'): + # Generate command dependencies in 'alias' attribute + if alias: + self.generateFeature(alias, 'command', self.cmddict) + + genProc = self.gen.genCmd + for type in f.elem.findall('.//type'): + depname = type.text + self.gen.logMsg('diag', 'Generating required parameter type', + depname) + self.generateFeature(depname, 'type', self.typedict) + elif (ftype == 'enum'): + # Generate enum dependencies in 'alias' attribute + if alias: + self.generateFeature(alias, 'enum', self.enumdict) + genProc = self.gen.genEnum + + # Actually generate the type only if emitting declarations + if self.emitFeatures: + self.gen.logMsg('diag', 'Emitting', ftype, fname, 'declaration') + genProc(f, fname, alias) + else: + self.gen.logMsg('diag', 'Skipping', ftype, fname, + '(should not be emitted)') + # + # generateRequiredInterface - generate all interfaces required + # by an API version or extension + # interface - Element for or + def generateRequiredInterface(self, interface): + """Generate required C interface for specified API version/extension""" + + # + # Loop over all features inside all tags. + for features in interface.findall('require'): + for t in features.findall('type'): + self.generateFeature(t.get('name'), 'type', self.typedict) + for e in features.findall('enum'): + self.generateFeature(e.get('name'), 'enum', self.enumdict) + for c in features.findall('command'): + self.generateFeature(c.get('name'), 'command', self.cmddict) + + # + # apiGen(genOpts) - generate interface for specified versions + # genOpts - GeneratorOptions object with parameters used + # by the Generator object. + def apiGen(self, genOpts): + """Generate interfaces for the specified API type and range of versions""" + # + self.gen.logMsg('diag', '*******************************************') + self.gen.logMsg('diag', ' Registry.apiGen file:', genOpts.filename, + 'api:', genOpts.apiname, + 'profile:', genOpts.profile) + self.gen.logMsg('diag', '*******************************************') + # + self.genOpts = genOpts + # Reset required/declared flags for all features + self.apiReset() + # + # Compile regexps used to select versions & extensions + regVersions = re.compile(self.genOpts.versions) + regEmitVersions = re.compile(self.genOpts.emitversions) + regAddExtensions = re.compile(self.genOpts.addExtensions) + regRemoveExtensions = re.compile(self.genOpts.removeExtensions) + regEmitExtensions = re.compile(self.genOpts.emitExtensions) + # + # Get all matching API feature names & add to list of FeatureInfo + # Note we used to select on feature version attributes, not names. + features = [] + apiMatch = False + for key in self.apidict: + fi = self.apidict[key] + api = fi.elem.get('api') + if (api == self.genOpts.apiname): + apiMatch = True + if (regVersions.match(fi.name)): + # Matches API & version #s being generated. Mark for + # emission and add to the features[] list . + # @@ Could use 'declared' instead of 'emit'? + fi.emit = (regEmitVersions.match(fi.name) != None) + features.append(fi) + if (not fi.emit): + self.gen.logMsg('diag', 'NOT tagging feature api =', api, + 'name =', fi.name, 'version =', fi.version, + 'for emission (does not match emitversions pattern)') + else: + self.gen.logMsg('diag', 'Including feature api =', api, + 'name =', fi.name, 'version =', fi.version, + 'for emission (matches emitversions pattern)') + else: + self.gen.logMsg('diag', 'NOT including feature api =', api, + 'name =', fi.name, 'version =', fi.version, + '(does not match requested versions)') + else: + self.gen.logMsg('diag', 'NOT including feature api =', api, + 'name =', fi.name, + '(does not match requested API)') + if (not apiMatch): + self.gen.logMsg('warn', 'No matching API versions found!') + # + # Get all matching extensions, in order by their extension number, + # and add to the list of features. + # Start with extensions tagged with 'api' pattern matching the API + # being generated. Add extensions matching the pattern specified in + # regExtensions, then remove extensions matching the pattern + # specified in regRemoveExtensions + for (extName,ei) in sorted(self.extdict.items(),key = lambda x : x[1].number): + extName = ei.name + include = False + # + # Include extension if defaultExtensions is not None and if the + # 'supported' attribute matches defaultExtensions. The regexp in + # 'supported' must exactly match defaultExtensions, so bracket + # it with ^(pat)$. + pat = '^(' + ei.elem.get('supported') + ')$' + if (self.genOpts.defaultExtensions and + re.match(pat, self.genOpts.defaultExtensions)): + self.gen.logMsg('diag', 'Including extension', + extName, "(defaultExtensions matches the 'supported' attribute)") + include = True + # + # Include additional extensions if the extension name matches + # the regexp specified in the generator options. This allows + # forcing extensions into an interface even if they're not + # tagged appropriately in the registry. + if (regAddExtensions.match(extName) != None): + self.gen.logMsg('diag', 'Including extension', + extName, '(matches explicitly requested extensions to add)') + include = True + # Remove extensions if the name matches the regexp specified + # in generator options. This allows forcing removal of + # extensions from an interface even if they're tagged that + # way in the registry. + if (regRemoveExtensions.match(extName) != None): + self.gen.logMsg('diag', 'Removing extension', + extName, '(matches explicitly requested extensions to remove)') + include = False + # + # If the extension is to be included, add it to the + # extension features list. + if (include): + ei.emit = (regEmitExtensions.match(extName) != None) + features.append(ei) + if (not ei.emit): + self.gen.logMsg('diag', 'NOT tagging extension', + extName, + 'for emission (does not match emitextensions pattern)') + # Hack - can be removed when validity generator goes away + # (Jon) I'm not sure what this does, or if it should respect + # the ei.emit flag above. + self.requiredextensions.append(extName) + else: + self.gen.logMsg('diag', 'NOT including extension', + extName, '(does not match api attribute or explicitly requested extensions)') + # + # Sort the extension features list, if a sort procedure is defined + if (self.genOpts.sortProcedure): + self.genOpts.sortProcedure(features) + # + # Pass 1: loop over requested API versions and extensions tagging + # types/commands/features as required (in an block) or no + # longer required (in an block). It is possible to remove + # a feature in one version and restore it later by requiring it in + # a later version. + # If a profile other than 'None' is being generated, it must + # match the profile attribute (if any) of the and + # tags. + self.gen.logMsg('diag', '*******PASS 1: TAG FEATURES **********') + for f in features: + self.gen.logMsg('diag', 'PASS 1: Tagging required and removed features for', + f.name) + self.requireAndRemoveFeatures(f.elem, self.genOpts.apiname, self.genOpts.profile) + self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile) + # + # Pass 2: loop over specified API versions and extensions printing + # declarations for required things which haven't already been + # generated. + self.gen.logMsg('diag', '*******PASS 2: GENERATE INTERFACES FOR FEATURES **********') + self.gen.beginFile(self.genOpts) + for f in features: + self.gen.logMsg('diag', 'PASS 2: Generating interface for', + f.name) + emit = self.emitFeatures = f.emit + if (not emit): + self.gen.logMsg('diag', 'PASS 2: NOT declaring feature', + f.elem.get('name'), 'because it is not tagged for emission') + # Generate the interface (or just tag its elements as having been + # emitted, if they haven't been). + self.gen.beginFeature(f.elem, emit) + self.generateRequiredInterface(f.elem) + self.gen.endFeature() + self.gen.endFile() + # + # apiReset - use between apiGen() calls to reset internal state + # + def apiReset(self): + """Reset type/enum/command dictionaries before generating another API""" + for type in self.typedict: + self.typedict[type].resetState() + for enum in self.enumdict: + self.enumdict[enum].resetState() + for cmd in self.cmddict: + self.cmddict[cmd].resetState() + for cmd in self.apidict: + self.apidict[cmd].resetState() + # + # validateGroups - check that group= attributes match actual groups + # + def validateGroups(self): + """Validate group= attributes on and tags""" + # Keep track of group names not in tags + badGroup = {} + self.gen.logMsg('diag', 'VALIDATING GROUP ATTRIBUTES ***') + for cmd in self.reg.findall('commands/command'): + proto = cmd.find('proto') + funcname = cmd.find('proto/name').text + if ('group' in proto.attrib.keys()): + group = proto.get('group') + # self.gen.logMsg('diag', 'Command ', funcname, ' has return group ', group) + if (group not in self.groupdict.keys()): + # self.gen.logMsg('diag', 'Command ', funcname, ' has UNKNOWN return group ', group) + if (group not in badGroup.keys()): + badGroup[group] = 1 + else: + badGroup[group] = badGroup[group] + 1 + for param in cmd.findall('param'): + pname = param.find('name') + if (pname != None): + pname = pname.text + else: + pname = type.get('name') + if ('group' in param.attrib.keys()): + group = param.get('group') + if (group not in self.groupdict.keys()): + # self.gen.logMsg('diag', 'Command ', funcname, ' param ', pname, ' has UNKNOWN group ', group) + if (group not in badGroup.keys()): + badGroup[group] = 1 + else: + badGroup[group] = badGroup[group] + 1 + if (len(badGroup.keys()) > 0): + self.gen.logMsg('diag', 'SUMMARY OF UNRECOGNIZED GROUPS ***') + for key in sorted(badGroup.keys()): + self.gen.logMsg('diag', ' ', key, ' occurred ', badGroup[key], ' times') diff --git a/generator/Vulkan-Headers/registry/validusage.json b/generator/Vulkan-Headers/registry/validusage.json new file mode 100644 index 0000000..1bd6b30 --- /dev/null +++ b/generator/Vulkan-Headers/registry/validusage.json @@ -0,0 +1,19076 @@ +{ + "version info": { + "schema version": 2, + "api version": "1.1.79", + "comment": "from git branch: master commit: ff9357a4bad5fa49b99b9d3f69d254e2a3f0f575", + "date": "2018-07-02 20:23:28Z" + }, + "validation": { + "vkGetInstanceProcAddr": { + "core": [ + { + "vuid": "VUID-vkGetInstanceProcAddr-instance-parameter", + "text": " If instance is not NULL, instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkGetInstanceProcAddr-pName-parameter", + "text": " pName must be a null-terminated UTF-8 string" + } + ] + }, + "vkGetDeviceProcAddr": { + "core": [ + { + "vuid": "VUID-vkGetDeviceProcAddr-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceProcAddr-pName-parameter", + "text": " pName must be a null-terminated UTF-8 string" + } + ] + }, + "vkEnumerateInstanceVersion": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkEnumerateInstanceVersion-pApiVersion-parameter", + "text": " pApiVersion must be a valid pointer to a uint32_t value" + } + ] + }, + "vkCreateInstance": { + "core": [ + { + "vuid": "VUID-vkCreateInstance-ppEnabledExtensionNames-01388", + "text": " All &amp;lt;&amp;lt;extended-functionality-extensions-dependencies, required extensions&amp;gt;&amp;gt; for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list." + }, + { + "vuid": "VUID-vkCreateInstance-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateInstance-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateInstance-pInstance-parameter", + "text": " pInstance must be a valid pointer to a VkInstance handle" + } + ] + }, + "VkInstanceCreateInfo": { + "core": [ + { + "vuid": "VUID-VkInstanceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT, VkDebugUtilsMessengerCreateInfoEXT, or VkValidationFlagsEXT" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-pApplicationInfo-parameter", + "text": " If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid VkApplicationInfo structure" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter", + "text": " If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter", + "text": " If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings" + } + ] + }, + "VkValidationFlagsEXT": { + "(VK_EXT_validation_flags)": [ + { + "vuid": "VUID-VkValidationFlagsEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT" + }, + { + "vuid": "VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter", + "text": " pDisabledValidationChecks must be a valid pointer to an array of disabledValidationCheckCount VkValidationCheckEXT values" + }, + { + "vuid": "VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength", + "text": " disabledValidationCheckCount must be greater than 0" + } + ] + }, + "VkApplicationInfo": { + "core": [ + { + "vuid": "VUID-VkApplicationInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO" + }, + { + "vuid": "VUID-VkApplicationInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkApplicationInfo-pApplicationName-parameter", + "text": " If pApplicationName is not NULL, pApplicationName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkApplicationInfo-pEngineName-parameter", + "text": " If pEngineName is not NULL, pEngineName must be a null-terminated UTF-8 string" + } + ] + }, + "vkDestroyInstance": { + "core": [ + { + "vuid": "VUID-vkDestroyInstance-instance-00629", + "text": " All child objects created using instance must have been destroyed prior to destroying instance" + }, + { + "vuid": "VUID-vkDestroyInstance-instance-00630", + "text": " If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyInstance-instance-00631", + "text": " If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyInstance-instance-parameter", + "text": " If instance is not NULL, instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDestroyInstance-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + } + ] + }, + "vkEnumeratePhysicalDevices": { + "core": [ + { + "vuid": "VUID-vkEnumeratePhysicalDevices-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter", + "text": " pPhysicalDeviceCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter", + "text": " If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles" + } + ] + }, + "vkGetPhysicalDeviceProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceProperties-pProperties-parameter", + "text": " pProperties must be a valid pointer to a VkPhysicalDeviceProperties structure" + } + ] + }, + "vkGetPhysicalDeviceProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter", + "text": " pProperties must be a valid pointer to a VkPhysicalDeviceProperties2 structure" + } + ] + }, + "VkPhysicalDeviceProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2" + }, + { + "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceSubgroupProperties, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" + }, + { + "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + } + ] + }, + "VkPhysicalDeviceIDProperties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities,VK_KHR_external_semaphore_capabilities,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceIDProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES" + } + ] + }, + "vkGetPhysicalDeviceQueueFamilyProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter", + "text": " pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter", + "text": " If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures" + } + ] + }, + "vkGetPhysicalDeviceQueueFamilyProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter", + "text": " pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter", + "text": " If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties2 structures" + } + ] + }, + "VkQueueFamilyProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkQueueFamilyProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2" + }, + { + "vuid": "VUID-VkQueueFamilyProperties2-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkEnumeratePhysicalDeviceGroups": { + "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ + { + "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter", + "text": " pPhysicalDeviceGroupCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter", + "text": " If the value referenced by pPhysicalDeviceGroupCount is not 0, and pPhysicalDeviceGroupProperties is not NULL, pPhysicalDeviceGroupProperties must be a valid pointer to an array of pPhysicalDeviceGroupCount VkPhysicalDeviceGroupProperties structures" + } + ] + }, + "vkCreateDevice": { + "core": [ + { + "vuid": "VUID-vkCreateDevice-ppEnabledExtensionNames-01387", + "text": " All &amp;lt;&amp;lt;extended-functionality-extensions-dependencies, required extensions&amp;gt;&amp;gt; for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list." + }, + { + "vuid": "VUID-vkCreateDevice-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkCreateDevice-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateDevice-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDevice-pDevice-parameter", + "text": " pDevice must be a valid pointer to a VkDevice handle" + } + ] + }, + "VkDeviceCreateInfo": { + "core": [ + { + "vuid": "VUID-VkDeviceCreateInfo-queueFamilyIndex-00372", + "text": "" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceSamplerYcbcrConversionFeatures, or VkPhysicalDeviceVariablePointerFeatures" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter", + "text": " pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter", + "text": " If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter", + "text": " If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter", + "text": " If pEnabledFeatures is not NULL, pEnabledFeatures must be a valid pointer to a valid VkPhysicalDeviceFeatures structure" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength", + "text": " queueCreateInfoCount must be greater than 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-pNext-00373", + "text": " If the pNext chain includes a VkPhysicalDeviceFeatures2 structure, then pEnabledFeatures must be NULL" + } + ], + "(VK_AMD_negative_viewport_height)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840", + "text": " ppEnabledExtensionNames must not contain VK_AMD_negative_viewport_height" + } + ], + "(VK_AMD_negative_viewport_height)+!(VK_VERSION_1_1)+(VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374", + "text": " ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height" + } + ] + }, + "VkDeviceGroupDeviceCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375", + "text": " Each element of pPhysicalDevices must be unique" + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376", + "text": " All elements of pPhysicalDevices must be in the same device group as enumerated by vkEnumeratePhysicalDeviceGroups" + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377", + "text": " If physicalDeviceCount is not 0, the physicalDevice parameter of vkCreateDevice must be an element of pPhysicalDevices." + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO" + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter", + "text": " If physicalDeviceCount is not 0, pPhysicalDevices must be a valid pointer to an array of physicalDeviceCount valid VkPhysicalDevice handles" + } + ] + }, + "vkDestroyDevice": { + "core": [ + { + "vuid": "VUID-vkDestroyDevice-device-00378", + "text": " All child objects created on device must have been destroyed prior to destroying device" + }, + { + "vuid": "VUID-vkDestroyDevice-device-00379", + "text": " If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDevice-device-00380", + "text": " If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDevice-device-parameter", + "text": " If device is not NULL, device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyDevice-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + } + ] + }, + "VkDeviceQueueCreateInfo": { + "core": [ + { + "vuid": "VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-queueCount-00382", + "text": " queueCount must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383", + "text": " Each element of pQueuePriorities must be between 0.0 and 1.0 inclusive" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceQueueGlobalPriorityCreateInfoEXT" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkDeviceQueueCreateFlagBits values" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter", + "text": " pQueuePriorities must be a valid pointer to an array of queueCount float values" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-queueCount-arraylength", + "text": " queueCount must be greater than 0" + } + ] + }, + "VkDeviceQueueGlobalPriorityCreateInfoEXT": { + "(VK_EXT_global_priority)": [ + { + "vuid": "VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter", + "text": " globalPriority must be a valid VkQueueGlobalPriorityEXT value" + } + ] + }, + "vkGetDeviceQueue": { + "core": [ + { + "vuid": "VUID-vkGetDeviceQueue-queueFamilyIndex-00384", + "text": " queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure" + }, + { + "vuid": "VUID-vkGetDeviceQueue-queueIndex-00385", + "text": " queueIndex must be less than the number of queues created for the specified queue family index when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure" + }, + { + "vuid": "VUID-vkGetDeviceQueue-flags-01841", + "text": " VkDeviceQueueCreateInfo::flags must have been set to zero when device was created" + }, + { + "vuid": "VUID-vkGetDeviceQueue-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceQueue-pQueue-parameter", + "text": " pQueue must be a valid pointer to a VkQueue handle" + } + ] + }, + "vkGetDeviceQueue2": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkGetDeviceQueue2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceQueue2-pQueueInfo-parameter", + "text": " pQueueInfo must be a valid pointer to a valid VkDeviceQueueInfo2 structure" + }, + { + "vuid": "VUID-vkGetDeviceQueue2-pQueue-parameter", + "text": " pQueue must be a valid pointer to a VkQueue handle" + } + ] + }, + "VkDeviceQueueInfo2": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842", + "text": " queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-queueIndex-01843", + "text": " queueIndex must be less than the number of queues created for the specified queue family index and VkDeviceQueueCreateFlags member flags equal to this flags value when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-flags-parameter", + "text": " flags must be a valid combination of VkDeviceQueueCreateFlagBits values" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-flags-requiredbitmask", + "text": " flags must not be 0" + } + ] + }, + "vkCreateCommandPool": { + "core": [ + { + "vuid": "VUID-vkCreateCommandPool-queueFamilyIndex-01937", + "text": " pCreateInfo::queueFamilyIndex must be the index of a queue family available in the logical device device." + }, + { + "vuid": "VUID-vkCreateCommandPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateCommandPool-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkCommandPoolCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateCommandPool-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateCommandPool-pCommandPool-parameter", + "text": " pCommandPool must be a valid pointer to a VkCommandPool handle" + } + ] + }, + "VkCommandPoolCreateInfo": { + "core": [ + { + "vuid": "VUID-VkCommandPoolCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO" + }, + { + "vuid": "VUID-VkCommandPoolCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCommandPoolCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkCommandPoolCreateFlagBits values" + } + ] + }, + "vkTrimCommandPool": { + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkTrimCommandPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkTrimCommandPool-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-vkTrimCommandPool-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-vkTrimCommandPool-commandPool-parent", + "text": " commandPool must have been created, allocated, or retrieved from device" + } + ] + }, + "vkResetCommandPool": { + "core": [ + { + "vuid": "VUID-vkResetCommandPool-commandPool-00040", + "text": " All VkCommandBuffer objects allocated from commandPool must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkResetCommandPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetCommandPool-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-vkResetCommandPool-flags-parameter", + "text": " flags must be a valid combination of VkCommandPoolResetFlagBits values" + }, + { + "vuid": "VUID-vkResetCommandPool-commandPool-parent", + "text": " commandPool must have been created, allocated, or retrieved from device" + } + ] + }, + "vkDestroyCommandPool": { + "core": [ + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-00041", + "text": " All VkCommandBuffer objects allocated from commandPool must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-00042", + "text": " If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-00043", + "text": " If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyCommandPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-parameter", + "text": " If commandPool is not VK_NULL_HANDLE, commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-vkDestroyCommandPool-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-parent", + "text": " If commandPool is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkAllocateCommandBuffers": { + "core": [ + { + "vuid": "VUID-vkAllocateCommandBuffers-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter", + "text": " pAllocateInfo must be a valid pointer to a valid VkCommandBufferAllocateInfo structure" + }, + { + "vuid": "VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter", + "text": " pCommandBuffers must be a valid pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles" + } + ] + }, + "VkCommandBufferAllocateInfo": { + "core": [ + { + "vuid": "VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044", + "text": " commandBufferCount must be greater than 0" + }, + { + "vuid": "VUID-VkCommandBufferAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkCommandBufferAllocateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCommandBufferAllocateInfo-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-VkCommandBufferAllocateInfo-level-parameter", + "text": " level must be a valid VkCommandBufferLevel value" + } + ] + }, + "vkResetCommandBuffer": { + "core": [ + { + "vuid": "VUID-vkResetCommandBuffer-commandBuffer-00045", + "text": " commandBuffer must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkResetCommandBuffer-commandBuffer-00046", + "text": " commandBuffer must have been allocated from a pool that was created with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT" + }, + { + "vuid": "VUID-vkResetCommandBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkResetCommandBuffer-flags-parameter", + "text": " flags must be a valid combination of VkCommandBufferResetFlagBits values" + } + ] + }, + "vkFreeCommandBuffers": { + "core": [ + { + "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-00047", + "text": " All elements of pCommandBuffers must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-00048", + "text": " pCommandBuffers must be a valid pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-commandBufferCount-arraylength", + "text": " commandBufferCount must be greater than 0" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-commandPool-parent", + "text": " commandPool must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-parent", + "text": " Each element of pCommandBuffers that is a valid handle must have been created, allocated, or retrieved from commandPool" + } + ] + }, + "vkBeginCommandBuffer": { + "core": [ + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00049", + "text": " commandBuffer must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording or pending state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00050", + "text": " If commandBuffer was allocated from a VkCommandPool which did not have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, initial state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00051", + "text": " If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00052", + "text": " If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is VK_FALSE, or the precise occlusion queries feature is not enabled, the queryFlags member of the pInheritanceInfo member pBeginInfo must not contain VK_QUERY_CONTROL_PRECISE_BIT" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-pBeginInfo-parameter", + "text": " pBeginInfo must be a valid pointer to a valid VkCommandBufferBeginInfo structure" + } + ] + }, + "VkCommandBufferBeginInfo": { + "core": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-00053", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo must be a valid VkRenderPass" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-00054", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-00055", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-parameter", + "text": " flags must be a valid combination of VkCommandBufferUsageFlagBits values" + } + ] + }, + "VkCommandBufferInheritanceInfo": { + "core": [ + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056", + "text": " If the &amp;lt;&amp;lt;features-features-inheritedQueries,inherited queries&amp;gt;&amp;gt; feature is not enabled, occlusionQueryEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-queryFlags-00057", + "text": " If the &amp;lt;&amp;lt;features-features-inheritedQueries,inherited queries&amp;gt;&amp;gt; feature is enabled, queryFlags must be a valid combination of VkQueryControlFlagBits values" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058", + "text": " If the &amp;lt;&amp;lt;features-features-pipelineStatisticsQuery,pipeline statistics queries&amp;gt;&amp;gt; feature is not enabled, pipelineStatistics must be 0" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-commonparent", + "text": " Both of framebuffer, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkEndCommandBuffer": { + "core": [ + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00059", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00060", + "text": " If commandBuffer is a primary command buffer, there must not be an active render pass instance" + }, + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00061", + "text": " All queries made &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt; during the recording of commandBuffer must have been made inactive" + }, + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + } + ], + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-01815", + "text": " If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT." + } + ], + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00062", + "text": " If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT." + } + ] + }, + "vkQueueSubmit": { + "core": [ + { + "vuid": "VUID-vkQueueSubmit-fence-00063", + "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" + }, + { + "vuid": "VUID-vkQueueSubmit-fence-00064", + "text": " If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00065", + "text": " Any calls to vkCmdSetEvent, vkCmdResetEvent or vkCmdWaitEvents that have been recorded into any of the command buffer elements of the pCommandBuffers member of any element of pSubmits, must not reference any VkEvent that is referenced by any of those commands in a command buffer that has been submitted to another queue and is still in the pending state." + }, + { + "vuid": "VUID-vkQueueSubmit-pWaitDstStageMask-00066", + "text": " Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the &amp;lt;&amp;lt;synchronization-pipeline-stages-supported, table of supported pipeline stages&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkQueueSubmit-pSignalSemaphores-00067", + "text": " Each element of the pSignalSemaphores member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device" + }, + { + "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00068", + "text": " When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, no other queue must be waiting on the same semaphore." + }, + { + "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00069", + "text": " All elements of the pWaitSemaphores member of all elements of pSubmits must be semaphores that are signaled, or have &amp;lt;&amp;lt;synchronization-semaphores-signaling, semaphore signal operations&amp;gt;&amp;gt; previously submitted for execution." + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00070", + "text": " Each element of the pCommandBuffers member of each element of pSubmits must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending or executable state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00071", + "text": " If any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00072", + "text": " Any &amp;lt;&amp;lt;commandbuffers-secondary, secondary command buffers recorded&amp;gt;&amp;gt; into any element of the pCommandBuffers member of any element of pSubmits must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending or executable state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00073", + "text": " If any &amp;lt;&amp;lt;commandbuffers-secondary, secondary command buffers recorded&amp;gt;&amp;gt; into any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00074", + "text": " Each element of the pCommandBuffers member of each element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to." + }, + { + "vuid": "VUID-vkQueueSubmit-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueSubmit-pSubmits-parameter", + "text": " If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures" + }, + { + "vuid": "VUID-vkQueueSubmit-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkQueueSubmit-commonparent", + "text": " Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkSubmitInfo": { + "core": [ + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-00075", + "text": " Each element of pCommandBuffers must not have been allocated with VK_COMMAND_BUFFER_LEVEL_SECONDARY" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00076", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00077", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00078", + "text": " Each element of pWaitDstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT." + }, + { + "vuid": "VUID-VkSubmitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBMIT_INFO" + }, + { + "vuid": "VUID-VkSubmitInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfo, VkProtectedSubmitInfo, VkWin32KeyedMutexAcquireReleaseInfoKHR, or VkWin32KeyedMutexAcquireReleaseInfoNV" + }, + { + "vuid": "VUID-VkSubmitInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitSemaphores-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitDstStageMask must be a valid pointer to an array of waitSemaphoreCount valid combinations of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask", + "text": " Each element of pWaitDstStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-parameter", + "text": " If commandBufferCount is not 0, pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles" + }, + { + "vuid": "VUID-VkSubmitInfo-pSignalSemaphores-parameter", + "text": " If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkSubmitInfo-commonparent", + "text": " Each of the elements of pCommandBuffers, the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkD3D12FenceSubmitInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079", + "text": " waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure." + }, + { + "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080", + "text": " signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure." + }, + { + "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR" + }, + { + "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter", + "text": " If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a valid pointer to an array of waitSemaphoreValuesCount uint64_t values" + }, + { + "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter", + "text": " If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a valid pointer to an array of signalSemaphoreValuesCount uint64_t values" + } + ] + }, + "VkWin32KeyedMutexAcquireReleaseInfoKHR": { + "(VK_KHR_win32_keyed_mutex)": [ + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081", + "text": " Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHR::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT." + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter", + "text": " If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter", + "text": " If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter", + "text": " If acquireCount is not 0, pAcquireTimeouts must be a valid pointer to an array of acquireCount uint32_t values" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter", + "text": " If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter", + "text": " If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent", + "text": " Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkWin32KeyedMutexAcquireReleaseInfoNV": { + "(VK_NV_win32_keyed_mutex)": [ + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter", + "text": " If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter", + "text": " If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireTimeoutMilliseconds-parameter", + "text": " If acquireCount is not 0, pAcquireTimeoutMilliseconds must be a valid pointer to an array of acquireCount uint32_t values" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseSyncs-parameter", + "text": " If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseKeys-parameter", + "text": " If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values" + }, + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent", + "text": " Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkProtectedSubmitInfo": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01816", + "text": " If the protected memory feature is not enabled, protectedSubmit must not be VK_TRUE." + }, + { + "vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01817", + "text": " If protectedSubmit is VK_TRUE, then each element of the pCommandBuffers array must be a protected command buffer." + }, + { + "vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01818", + "text": " If protectedSubmit is VK_FALSE, then each element of the pCommandBuffers array must be an unprotected command buffer." + }, + { + "vuid": "VUID-VkProtectedSubmitInfo-pNext-01819", + "text": " If the VkSubmitInfo::pNext chain does not include a VkProtectedSubmitInfo structure, then each element of the command buffer of the pCommandBuffers array must be an unprotected command buffer." + }, + { + "vuid": "VUID-VkProtectedSubmitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO" + } + ] + }, + "VkDeviceGroupSubmitInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082", + "text": " waitSemaphoreCount must equal VkSubmitInfo::waitSemaphoreCount" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083", + "text": " commandBufferCount must equal VkSubmitInfo::commandBufferCount" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084", + "text": " signalSemaphoreCount must equal VkSubmitInfo::signalSemaphoreCount" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085", + "text": " All elements of pWaitSemaphoreDeviceIndices and pSignalSemaphoreDeviceIndices must be valid device indices" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086", + "text": " All elements of pCommandBufferDeviceMasks must be valid device masks" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitSemaphoreDeviceIndices must be a valid pointer to an array of waitSemaphoreCount uint32_t values" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter", + "text": " If commandBufferCount is not 0, pCommandBufferDeviceMasks must be a valid pointer to an array of commandBufferCount uint32_t values" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter", + "text": " If signalSemaphoreCount is not 0, pSignalSemaphoreDeviceIndices must be a valid pointer to an array of signalSemaphoreCount uint32_t values" + } + ] + }, + "vkCmdExecuteCommands": { + "core": [ + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00087", + "text": " commandBuffer must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_PRIMARY" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00088", + "text": " Each element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00089", + "text": " Each element of pCommandBuffers must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending or executable state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00090", + "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, and it was recorded into any other primary command buffer, that primary command buffer must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00091", + "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00092", + "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not have already been recorded to commandBuffer." + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00093", + "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not appear more than once in pCommandBuffers." + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00094", + "text": " Each element of pCommandBuffers must have been allocated from a VkCommandPool that was created for the same queue family as the VkCommandPool from which commandBuffer was allocated" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-contents-00095", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of vkCmdBeginRenderPass set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00096", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00097", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pInheritanceInfo-00098", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, the render passes specified in the pBeginInfo::pInheritanceInfo::renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the current render pass." + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00099", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00100", + "text": " If vkCmdExecuteCommands is not being called within a render pass instance, each element of pCommandBuffers must not have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00101", + "text": " If the &amp;lt;&amp;lt;features-features-inheritedQueries,inherited queries&amp;gt;&amp;gt; feature is not enabled, commandBuffer must not have any queries &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00102", + "text": " If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to VK_TRUE" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00103", + "text": " If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00104", + "text": " If commandBuffer has a VK_QUERY_TYPE_PIPELINE_STATISTICS query &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00105", + "text": " Each element of pCommandBuffers must not begin any query types that are &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt; in commandBuffer" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-parameter", + "text": " pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBufferCount-arraylength", + "text": " commandBufferCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commonparent", + "text": " Both of commandBuffer, and the elements of pCommandBuffers must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01820", + "text": " If commandBuffer is a protected command buffer, then each element of pCommandBuffers must be a protected command buffer." + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01821", + "text": " If commandBuffer is an unprotected command buffer, then each element of pCommandBuffers must be an unprotected command buffer." + } + ] + }, + "VkDeviceGroupCommandBufferBeginInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106", + "text": " deviceMask must be a valid device mask value" + }, + { + "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO" + } + ] + }, + "vkCmdSetDeviceMask": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00108", + "text": " deviceMask must be a valid device mask value" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00109", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00110", + "text": " deviceMask must not include any set bits that were not in the VkDeviceGroupCommandBufferBeginInfo::deviceMask value when the command buffer began recording." + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00111", + "text": " If vkCmdSetDeviceMask is called inside a render pass instance, deviceMask must not include any set bits that were not in the VkDeviceGroupRenderPassBeginInfo::deviceMask value when the render pass instance began recording." + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations" + } + ] + }, + "vkCreateFence": { + "core": [ + { + "vuid": "VUID-vkCreateFence-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateFence-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkFenceCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateFence-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateFence-pFence-parameter", + "text": " pFence must be a valid pointer to a VkFence handle" + } + ] + }, + "VkFenceCreateInfo": { + "core": [ + { + "vuid": "VUID-VkFenceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO" + }, + { + "vuid": "VUID-VkFenceCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportFenceCreateInfo or VkExportFenceWin32HandleInfoKHR" + }, + { + "vuid": "VUID-VkFenceCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkFenceCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkFenceCreateFlagBits values" + } + ] + }, + "VkExportFenceCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_fence)": [ + { + "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-01446", + "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalFenceProperties." + }, + { + "vuid": "VUID-VkExportFenceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO" + }, + { + "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBits values" + } + ] + }, + "VkExportFenceWin32HandleInfoKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447", + "text": " If VkExportFenceCreateInfo::handleTypes does not include VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, VkExportFenceWin32HandleInfoKHR must not be in the pNext chain of VkFenceCreateInfo." + }, + { + "vuid": "VUID-VkExportFenceWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter", + "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" + } + ] + }, + "vkGetFenceWin32HandleKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-vkGetFenceWin32HandleKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter", + "text": " pGetWin32HandleInfo must be a valid pointer to a valid VkFenceGetWin32HandleInfoKHR structure" + }, + { + "vuid": "VUID-vkGetFenceWin32HandleKHR-pHandle-parameter", + "text": " pHandle must be a valid pointer to a HANDLE value" + } + ] + }, + "VkFenceGetWin32HandleInfoKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448", + "text": " handleType must have been included in VkExportFenceCreateInfo::handleTypes when the fence’s current payload was created." + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449", + "text": " If handleType is defined as an NT handle, vkGetFenceWin32HandleKHR must be called no more than once for each valid unique combination of fence and handleType." + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-fence-01450", + "text": " fence must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-fences-importing,Importing Fence Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType." + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451", + "text": " If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-fences-signaling,fence signal operation&amp;gt;&amp;gt; pending execution." + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452", + "text": " handleType must be defined as an NT handle or a global share handle." + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "vkGetFenceFdKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-vkGetFenceFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetFenceFdKHR-pGetFdInfo-parameter", + "text": " pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure" + }, + { + "vuid": "VUID-vkGetFenceFdKHR-pFd-parameter", + "text": " pFd must be a valid pointer to a int value" + } + ] + }, + "VkFenceGetFdInfoKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01453", + "text": " handleType must have been included in VkExportFenceCreateInfo::handleTypes when fence’s current payload was created." + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01454", + "text": " If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-fences-signaling,fence signal operation&amp;gt;&amp;gt; pending execution." + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-fence-01455", + "text": " fence must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-fences-importing,Importing Fence Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType." + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01456", + "text": " handleType must be defined as a POSIX file descriptor handle." + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "vkDestroyFence": { + "core": [ + { + "vuid": "VUID-vkDestroyFence-fence-01120", + "text": " All &amp;lt;&amp;lt;devsandqueues-submission, queue submission&amp;gt;&amp;gt; commands that refer to fence must have completed execution" + }, + { + "vuid": "VUID-vkDestroyFence-fence-01121", + "text": " If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyFence-fence-01122", + "text": " If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyFence-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyFence-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkDestroyFence-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyFence-fence-parent", + "text": " If fence is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetFenceStatus": { + "core": [ + { + "vuid": "VUID-vkGetFenceStatus-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetFenceStatus-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkGetFenceStatus-fence-parent", + "text": " fence must have been created, allocated, or retrieved from device" + } + ] + }, + "vkResetFences": { + "core": [ + { + "vuid": "VUID-vkResetFences-pFences-01123", + "text": " Each element of pFences must not be currently associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkResetFences-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetFences-pFences-parameter", + "text": " pFences must be a valid pointer to an array of fenceCount valid VkFence handles" + }, + { + "vuid": "VUID-vkResetFences-fenceCount-arraylength", + "text": " fenceCount must be greater than 0" + }, + { + "vuid": "VUID-vkResetFences-pFences-parent", + "text": " Each element of pFences must have been created, allocated, or retrieved from device" + } + ] + }, + "vkWaitForFences": { + "core": [ + { + "vuid": "VUID-vkWaitForFences-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkWaitForFences-pFences-parameter", + "text": " pFences must be a valid pointer to an array of fenceCount valid VkFence handles" + }, + { + "vuid": "VUID-vkWaitForFences-fenceCount-arraylength", + "text": " fenceCount must be greater than 0" + }, + { + "vuid": "VUID-vkWaitForFences-pFences-parent", + "text": " Each element of pFences must have been created, allocated, or retrieved from device" + } + ] + }, + "vkRegisterDeviceEventEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkRegisterDeviceEventEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter", + "text": " pDeviceEventInfo must be a valid pointer to a valid VkDeviceEventInfoEXT structure" + }, + { + "vuid": "VUID-vkRegisterDeviceEventEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkRegisterDeviceEventEXT-pFence-parameter", + "text": " pFence must be a valid pointer to a VkFence handle" + } + ] + }, + "VkDeviceEventInfoEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkDeviceEventInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT" + }, + { + "vuid": "VUID-VkDeviceEventInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDeviceEventInfoEXT-deviceEvent-parameter", + "text": " deviceEvent must be a valid VkDeviceEventTypeEXT value" + } + ] + }, + "vkRegisterDisplayEventEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkRegisterDisplayEventEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter", + "text": " pDisplayEventInfo must be a valid pointer to a valid VkDisplayEventInfoEXT structure" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-pFence-parameter", + "text": " pFence must be a valid pointer to a VkFence handle" + } + ] + }, + "VkDisplayEventInfoEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkDisplayEventInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT" + }, + { + "vuid": "VUID-VkDisplayEventInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayEventInfoEXT-displayEvent-parameter", + "text": " displayEvent must be a valid VkDisplayEventTypeEXT value" + } + ] + }, + "vkImportFenceWin32HandleKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-vkImportFenceWin32HandleKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter", + "text": " pImportFenceWin32HandleInfo must be a valid pointer to a valid VkImportFenceWin32HandleInfoKHR structure" + } + ] + }, + "VkImportFenceWin32HandleInfoKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457", + "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-fence-handletypes-win32, Handle Types Supported by VkImportFenceWin32HandleInfoKHR&amp;gt;&amp;gt; table." + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459", + "text": " If handleType is not VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, name must be NULL." + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460", + "text": " If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType." + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461", + "text": " If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType." + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01462", + "text": " If handle is not NULL, name must be NULL." + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01539", + "text": " If handle is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility." + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-name-01540", + "text": " If name is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility." + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkFenceImportFlagBits values" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter", + "text": " If handleType is not 0, handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "vkImportFenceFdKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-vkImportFenceFdKHR-fence-01463", + "text": " fence must not be associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkImportFenceFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter", + "text": " pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure" + } + ] + }, + "VkImportFenceFdInfoKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-VkImportFenceFdInfoKHR-handleType-01464", + "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-fence-handletypes-fd, Handle Types Supported by VkImportFenceFdInfoKHR&amp;gt;&amp;gt; table." + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-fd-01541", + "text": " fd must obey any requirements listed for handleType in &amp;lt;&amp;lt;external-fence-handle-types-compatibility,external fence handle types compatibility&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkFenceImportFlagBits values" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "vkCreateSemaphore": { + "core": [ + { + "vuid": "VUID-vkCreateSemaphore-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSemaphore-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSemaphoreCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateSemaphore-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateSemaphore-pSemaphore-parameter", + "text": " pSemaphore must be a valid pointer to a VkSemaphore handle" + } + ] + }, + "VkSemaphoreCreateInfo": { + "core": [ + { + "vuid": "VUID-VkSemaphoreCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO" + }, + { + "vuid": "VUID-VkSemaphoreCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportSemaphoreCreateInfo or VkExportSemaphoreWin32HandleInfoKHR" + }, + { + "vuid": "VUID-VkSemaphoreCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSemaphoreCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "VkExportSemaphoreCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore)": [ + { + "vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-01124", + "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphoreProperties." + }, + { + "vuid": "VUID-VkExportSemaphoreCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO" + }, + { + "vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values" + } + ] + }, + "VkExportSemaphoreWin32HandleInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125", + "text": " If VkExportSemaphoreCreateInfo::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, VkExportSemaphoreWin32HandleInfoKHR must not be in the pNext chain of VkSemaphoreCreateInfo." + }, + { + "vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter", + "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" + } + ] + }, + "vkGetSemaphoreWin32HandleKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-vkGetSemaphoreWin32HandleKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter", + "text": " pGetWin32HandleInfo must be a valid pointer to a valid VkSemaphoreGetWin32HandleInfoKHR structure" + }, + { + "vuid": "VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter", + "text": " pHandle must be a valid pointer to a HANDLE value" + } + ] + }, + "VkSemaphoreGetWin32HandleInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126", + "text": " handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when the semaphore’s current payload was created." + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127", + "text": " If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHR must be called no more than once for each valid unique combination of semaphore and handleType." + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128", + "text": " semaphore must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType." + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129", + "text": " If handleType refers to a handle type with copy payload transference semantics, as defined below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt;, there must be no queue waiting on semaphore." + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130", + "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-semaphores-signaling,semaphore signal operation&amp;gt;&amp;gt; pending execution." + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131", + "text": " handleType must be defined as an NT handle or a global share handle." + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ] + }, + "vkGetSemaphoreFdKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-vkGetSemaphoreFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter", + "text": " pGetFdInfo must be a valid pointer to a valid VkSemaphoreGetFdInfoKHR structure" + }, + { + "vuid": "VUID-vkGetSemaphoreFdKHR-pFd-parameter", + "text": " pFd must be a valid pointer to a int value" + } + ] + }, + "VkSemaphoreGetFdInfoKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01132", + "text": " handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when semaphore’s current payload was created." + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133", + "text": " semaphore must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType." + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01134", + "text": " If handleType refers to a handle type with copy payload transference semantics, as defined below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt;, there must be no queue waiting on semaphore." + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01135", + "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-semaphores-signaling,semaphore signal operation&amp;gt;&amp;gt; pending execution." + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01136", + "text": " handleType must be defined as a POSIX file descriptor handle." + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ] + }, + "vkDestroySemaphore": { + "core": [ + { + "vuid": "VUID-vkDestroySemaphore-semaphore-01137", + "text": " All submitted batches that refer to semaphore must have completed execution" + }, + { + "vuid": "VUID-vkDestroySemaphore-semaphore-01138", + "text": " If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySemaphore-semaphore-01139", + "text": " If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySemaphore-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroySemaphore-semaphore-parameter", + "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-vkDestroySemaphore-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroySemaphore-semaphore-parent", + "text": " If semaphore is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkImportSemaphoreWin32HandleKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-vkImportSemaphoreWin32HandleKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter", + "text": " pImportSemaphoreWin32HandleInfo must be a valid pointer to a valid VkImportSemaphoreWin32HandleInfoKHR structure" + } + ] + }, + "VkImportSemaphoreWin32HandleInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140", + "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-semaphore-handletypes-win32,Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR&amp;gt;&amp;gt; table." + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466", + "text": " If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, name must be NULL." + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467", + "text": " If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType." + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468", + "text": " If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType." + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469", + "text": " If handle is not NULL, name must be NULL." + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542", + "text": " If handle is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility." + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543", + "text": " If name is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility." + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkSemaphoreImportFlagBits values" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter", + "text": " If handleType is not 0, handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ] + }, + "vkImportSemaphoreFdKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-vkImportSemaphoreFdKHR-semaphore-01142", + "text": " semaphore must not be associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkImportSemaphoreFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter", + "text": " pImportSemaphoreFdInfo must be a valid pointer to a valid VkImportSemaphoreFdInfoKHR structure" + } + ] + }, + "VkImportSemaphoreFdInfoKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-01143", + "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-semaphore-handletypes-fd,Handle Types Supported by VkImportSemaphoreFdInfoKHR&amp;gt;&amp;gt; table." + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-fd-01544", + "text": " fd must obey any requirements listed for handleType in &amp;lt;&amp;lt;external-semaphore-handle-types-compatibility,external semaphore handle types compatibility&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkSemaphoreImportFlagBits values" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ] + }, + "vkCreateEvent": { + "core": [ + { + "vuid": "VUID-vkCreateEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateEvent-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkEventCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateEvent-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateEvent-pEvent-parameter", + "text": " pEvent must be a valid pointer to a VkEvent handle" + } + ] + }, + "VkEventCreateInfo": { + "core": [ + { + "vuid": "VUID-VkEventCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO" + }, + { + "vuid": "VUID-VkEventCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkEventCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkDestroyEvent": { + "core": [ + { + "vuid": "VUID-vkDestroyEvent-event-01145", + "text": " All submitted commands that refer to event must have completed execution" + }, + { + "vuid": "VUID-vkDestroyEvent-event-01146", + "text": " If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyEvent-event-01147", + "text": " If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyEvent-event-parameter", + "text": " If event is not VK_NULL_HANDLE, event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkDestroyEvent-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyEvent-event-parent", + "text": " If event is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetEventStatus": { + "core": [ + { + "vuid": "VUID-vkGetEventStatus-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetEventStatus-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkGetEventStatus-event-parent", + "text": " event must have been created, allocated, or retrieved from device" + } + ] + }, + "vkSetEvent": { + "core": [ + { + "vuid": "VUID-vkSetEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkSetEvent-event-parent", + "text": " event must have been created, allocated, or retrieved from device" + } + ] + }, + "vkResetEvent": { + "core": [ + { + "vuid": "VUID-vkResetEvent-event-01148", + "text": " event must not be waited on by a vkCmdWaitEvents command that is currently executing" + }, + { + "vuid": "VUID-vkResetEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkResetEvent-event-parent", + "text": " event must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdSetEvent": { + "core": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-01149", + "text": " stageMask must not include VK_PIPELINE_STAGE_HOST_BIT" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-01150", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-01151", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-parameter", + "text": " stageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-requiredbitmask", + "text": " stageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdSetEvent-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdSetEvent-commonparent", + "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-01152", + "text": " commandBuffer’s current device mask must include exactly one physical device." + } + ] + }, + "vkCmdResetEvent": { + "core": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-01153", + "text": " stageMask must not include VK_PIPELINE_STAGE_HOST_BIT" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-01154", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-01155", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdResetEvent-event-01156", + "text": " When this command executes, event must not be waited on by a vkCmdWaitEvents command that is currently executing" + }, + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-parameter", + "text": " stageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-requiredbitmask", + "text": " stageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdResetEvent-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdResetEvent-commonparent", + "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-01157", + "text": " commandBuffer’s current device mask must include exactly one physical device." + } + ] + }, + "vkCmdWaitEvents": { + "core": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01158", + "text": " srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the members of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the members of pEvents was set using vkSetEvent" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01159", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-01160", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01161", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-01162", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pEvents-01163", + "text": " If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents must not be called inside a render pass instance" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01164", + "text": " Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the &amp;lt;&amp;lt;synchronization-pipeline-stages-supported, table of supported pipeline stages&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-01165", + "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-01166", + "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pEvents-parameter", + "text": " pEvents must be a valid pointer to an array of eventCount valid VkEvent handles" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask", + "text": " srcStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask", + "text": " dstStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-parameter", + "text": " If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter", + "text": " If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter", + "text": " If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWaitEvents-eventCount-arraylength", + "text": " eventCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents-commonparent", + "text": " Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-01167", + "text": " commandBuffer’s current device mask must include exactly one physical device." + } + ] + }, + "vkCmdPipelineBarrier": { + "core": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01168", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-01169", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01170", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-01171", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pDependencies-01172", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with a VkSubpassDependency instance in pDependencies that expresses a dependency from the current subpass to itself." + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01173", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, srcStageMask must contain a subset of the bit values in the srcStageMask member of that instance of VkSubpassDependency" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-01174", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, dstStageMask must contain a subset of the bit values in the dstStageMask member of that instance of VkSubpassDependency" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcAccessMask-01175", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the srcAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the srcAccessMask member of that instance of VkSubpassDependency" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstAccessMask-01176", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the dstAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the dstAccessMask member of that instance of VkSubpassDependency" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-01177", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, dependencyFlags must be equal to the dependencyFlags member of that instance of VkSubpassDependency" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, bufferMemoryBarrierCount must be 0" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-image-01179", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the image member of any element of pImageMemoryBarriers must be equal to one of the elements of pAttachments that the current framebuffer was created with, that is also referred to by one of the elements of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-oldLayout-01180", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any element of pImageMemoryBarriers must be equal to the layout member of an element of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with, that refers to the same image" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-oldLayout-01181", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of an element of pImageMemoryBarriers must be equal" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182", + "text": " If vkCmdPipelineBarrier is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pImageMemoryBarriers must be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01183", + "text": " Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the &amp;lt;&amp;lt;synchronization-pipeline-stages-supported, table of supported pipeline stages&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184", + "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185", + "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask", + "text": " srcStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask", + "text": " dstStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-parameter", + "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter", + "text": " If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter", + "text": " If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter", + "text": " If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-01186", + "text": " If vkCmdPipelineBarrier is called outside of a render pass instance, dependencyFlags must not include VK_DEPENDENCY_VIEW_LOCAL_BIT" + } + ] + }, + "VkMemoryBarrier": { + "core": [ + { + "vuid": "VUID-VkMemoryBarrier-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER" + }, + { + "vuid": "VUID-VkMemoryBarrier-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMemoryBarrier-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkMemoryBarrier-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" + } + ] + }, + "VkBufferMemoryBarrier": { + "core": [ + { + "vuid": "VUID-VkBufferMemoryBarrier-offset-01187", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-size-01188", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-size-01189", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01196", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01931", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ], + "!(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01190", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01192", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see &amp;lt;&amp;lt;devsandqueues-queueprops&amp;gt;&amp;gt;)" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01191", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01763", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory ownership transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01193", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01764", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01765", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." + } + ] + }, + "VkImageMemoryBarrier": { + "core": [ + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01197", + "text": " oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-newLayout-01198", + "text": " newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01205", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01486", + "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01724", + "text": " If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01488", + "text": " subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01725", + "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01207", + "text": " If image has a depth/stencil format with both depth and stencil components, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01208", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01209", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01210", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01211", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01212", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01213", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01932", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-parameter", + "text": " oldLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-newLayout-parameter", + "text": " newLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-parameter", + "text": " subresourceRange must be a valid VkImageSubresourceRange structure" + } + ], + "!(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-01199", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01200", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see &amp;lt;&amp;lt;devsandqueues-queueprops&amp;gt;&amp;gt;)." + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-01381", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01766", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01201", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED." + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01767", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01768", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-01671", + "text": " If image has a single-plane color format or is not disjoint, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01672", + "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01673", + "text": " If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01658", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01659", + "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + } + ] + }, + "vkQueueWaitIdle": { + "core": [ + { + "vuid": "VUID-vkQueueWaitIdle-queue-parameter", + "text": " queue must be a valid VkQueue handle" + } + ] + }, + "vkDeviceWaitIdle": { + "core": [ + { + "vuid": "VUID-vkDeviceWaitIdle-device-parameter", + "text": " device must be a valid VkDevice handle" + } + ] + }, + "vkCreateRenderPass": { + "core": [ + { + "vuid": "VUID-vkCreateRenderPass-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateRenderPass-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateRenderPass-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateRenderPass-pRenderPass-parameter", + "text": " pRenderPass must be a valid pointer to a VkRenderPass handle" + } + ] + }, + "VkRenderPassCreateInfo": { + "core": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-None-00832", + "text": " If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-attachment-00833", + "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-attachment-00834", + "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pPreserveAttachments-00835", + "text": " The value of each element of the pPreserveAttachments member in each element of pSubpasses must not be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-00836", + "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL." + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00837", + "text": " For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the &amp;lt;&amp;lt;synchronization-pipeline-stages-types, pipeline&amp;gt;&amp;gt; identified by the pipelineBindPoint member of the source subpass." + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00838", + "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the &amp;lt;&amp;lt;synchronization-pipeline-stages-types, pipeline&amp;gt;&amp;gt; identified by the pipelineBindPoint member of the source subpass." + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassInputAttachmentAspectCreateInfo or VkRenderPassMultiviewCreateInfo" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-parameter", + "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pSubpasses-parameter", + "text": " pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-parameter", + "text": " If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-subpassCount-arraylength", + "text": " subpassCount must be greater than 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01566", + "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL." + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01567", + "text": " For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL." + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01926", + "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the subpass member of each element of its pAspectReferences member must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01927", + "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the member of pSubpasses identified by its subpass member" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01963", + "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the aspectMask member of any element of pAspectReferences must only include aspects that are present in images of the format of the input attachment specified by the subpass and inputAttachment of the same element of pAspectReferences" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01928", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, and its subpassCount member is not zero, that member must be equal to the value of subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01929", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, if its dependencyCount member is not zero, it must be equal to dependencyCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01930", + "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal" + } + ] + }, + "VkRenderPassMultiviewCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841", + "text": " Each view index must not be set in more than one element of pCorrelationMasks" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter", + "text": " If subpassCount is not 0, pViewMasks must be a valid pointer to an array of subpassCount uint32_t values" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter", + "text": " If dependencyCount is not 0, pViewOffsets must be a valid pointer to an array of dependencyCount int32_t values" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter", + "text": " If correlationMaskCount is not 0, pCorrelationMasks must be a valid pointer to an array of correlationMaskCount uint32_t values" + } + ] + }, + "VkAttachmentDescription": { + "core": [ + { + "vuid": "VUID-VkAttachmentDescription-finalLayout-00843", + "text": " finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkAttachmentDescription-flags-parameter", + "text": " flags must be a valid combination of VkAttachmentDescriptionFlagBits values" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkAttachmentDescription-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkAttachmentDescription-loadOp-parameter", + "text": " loadOp must be a valid VkAttachmentLoadOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-storeOp-parameter", + "text": " storeOp must be a valid VkAttachmentStoreOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-stencilLoadOp-parameter", + "text": " stencilLoadOp must be a valid VkAttachmentLoadOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-stencilStoreOp-parameter", + "text": " stencilStoreOp must be a valid VkAttachmentStoreOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-initialLayout-parameter", + "text": " initialLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkAttachmentDescription-finalLayout-parameter", + "text": " finalLayout must be a valid VkImageLayout value" + } + ] + }, + "VkRenderPassInputAttachmentAspectCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO" + }, + { + "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter", + "text": " pAspectReferences must be a valid pointer to an array of aspectReferenceCount valid VkInputAttachmentAspectReference structures" + }, + { + "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength", + "text": " aspectReferenceCount must be greater than 0" + } + ] + }, + "VkInputAttachmentAspectReference": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-01964", + "text": " aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT" + }, + { + "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ] + }, + "VkSubpassDescription": { + "core": [ + { + "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-00844", + "text": " pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-VkSubpassDescription-colorAttachmentCount-00845", + "text": " colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription-loadOp-00846", + "text": " If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00847", + "text": " If pResolveAttachments is not NULL, for each resolve attachment that does not have the value VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have the value VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00848", + "text": " If pResolveAttachments is not NULL, the sample count of each element of pColorAttachments must be anything other than VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00849", + "text": " Each element of pResolveAttachments must have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00850", + "text": " Each element of pResolveAttachments must have the same VkFormat as its corresponding color attachment" + }, + { + "vuid": "VUID-VkSubpassDescription-pColorAttachments-01417", + "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count" + }, + { + "vuid": "VUID-VkSubpassDescription-None-00852", + "text": " If any input attachments are VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass must not access those input attachments from the fragment shader" + }, + { + "vuid": "VUID-VkSubpassDescription-attachment-00853", + "text": " The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescription-pPreserveAttachments-00854", + "text": " Each element of pPreserveAttachments must not also be an element of any other member of the subpass description" + }, + { + "vuid": "VUID-VkSubpassDescription-layout-00855", + "text": " If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same layout" + }, + { + "vuid": "VUID-VkSubpassDescription-flags-parameter", + "text": " flags must be a valid combination of VkSubpassDescriptionFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-VkSubpassDescription-pInputAttachments-parameter", + "text": " If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures" + }, + { + "vuid": "VUID-VkSubpassDescription-pColorAttachments-parameter", + "text": " If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-parameter", + "text": " If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures" + }, + { + "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-parameter", + "text": " If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure" + }, + { + "vuid": "VUID-VkSubpassDescription-pPreserveAttachments-parameter", + "text": " If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values" + } + ], + "(VK_AMD_mixed_attachment_samples)": [ + { + "vuid": "VUID-VkSubpassDescription-pColorAttachments-01506", + "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED" + } + ], + "!(VK_AMD_mixed_attachment_samples)+!(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-01418", + "text": " If pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count" + } + ], + "(VK_NVX_multiview_per_view_attributes)": [ + { + "vuid": "VUID-VkSubpassDescription-flags-00856", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX." + } + ] + }, + "VkAttachmentReference": { + "core": [ + { + "vuid": "VUID-VkAttachmentReference-layout-00857", + "text": " layout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkAttachmentReference-layout-parameter", + "text": " layout must be a valid VkImageLayout value" + } + ] + }, + "VkSubpassDependency": { + "core": [ + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00858", + "text": " If srcSubpass is not VK_SUBPASS_EXTERNAL, srcStageMask must not include VK_PIPELINE_STAGE_HOST_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstSubpass-00859", + "text": " If dstSubpass is not VK_SUBPASS_EXTERNAL, dstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-00860", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-00861", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-00862", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-00863", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00864", + "text": " srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00865", + "text": " srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00866", + "text": " If srcSubpass is equal to dstSubpass, srcStageMask and dstStageMask must only contain one of VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, or VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00867", + "text": " If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are &amp;lt;&amp;lt;synchronization-framebuffer-regions,framebuffer-space stages&amp;gt;&amp;gt;, the &amp;lt;&amp;lt;synchronization-pipeline-stages-order, logically latest&amp;gt;&amp;gt; pipeline stage in srcStageMask must be &amp;lt;&amp;lt;synchronization-pipeline-stages-order, logically earlier&amp;gt;&amp;gt; than or equal to the &amp;lt;&amp;lt;synchronization-pipeline-stages-order, logically earliest&amp;gt;&amp;gt; pipeline stage in dstStageMask" + }, + { + "vuid": "VUID-VkSubpassDependency-srcAccessMask-00868", + "text": " Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkSubpassDependency-dstAccessMask-00869", + "text": " Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-requiredbitmask", + "text": " srcStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-requiredbitmask", + "text": " dstStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubpassDependency-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-dependencyFlags-parameter", + "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkSubpassDependency-dependencyFlags-00870", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then both srcSubpass and dstSubpass must not equal VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency-dependencyFlags-00871", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then the render pass must have multiview enabled" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00872", + "text": " If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT" + } + ] + }, + "vkDestroyRenderPass": { + "core": [ + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00873", + "text": " All submitted commands that refer to renderPass must have completed execution" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00874", + "text": " If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00875", + "text": " If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyRenderPass-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-parameter", + "text": " If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-vkDestroyRenderPass-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-parent", + "text": " If renderPass is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateFramebuffer": { + "core": [ + { + "vuid": "VUID-vkCreateFramebuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateFramebuffer-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateFramebuffer-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateFramebuffer-pFramebuffer-parameter", + "text": " pFramebuffer must be a valid pointer to a VkFramebuffer handle" + } + ] + }, + "VkFramebufferCreateInfo": { + "core": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-attachmentCount-00876", + "text": " attachmentCount must be equal to the attachment count specified in renderPass" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00877", + "text": " Each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00878", + "text": " Each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00879", + "text": " Each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00880", + "text": " Each element of pAttachments must have been created with an VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00881", + "text": " Each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00882", + "text": " Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00883", + "text": " Each element of pAttachments must only specify a single mip level" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00884", + "text": " Each element of pAttachments must have been created with the identity swizzle" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-width-00885", + "text": " width must be greater than 0." + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-width-00886", + "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-height-00887", + "text": " height must be greater than 0." + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-height-00888", + "text": " height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-layers-00889", + "text": " layers must be greater than 0." + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-layers-00890", + "text": " layers must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-parameter", + "text": " renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-parameter", + "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-commonparent", + "text": " Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00891", + "text": " Each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format" + } + ] + }, + "vkDestroyFramebuffer": { + "core": [ + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00892", + "text": " All submitted commands that refer to framebuffer must have completed execution" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00893", + "text": " If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00894", + "text": " If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-parameter", + "text": " If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-parent", + "text": " If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdBeginRenderPass": { + "core": [ + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00895", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00897", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00898", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00899", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00900", + "text": " If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-srcStageMask-00901", + "text": " The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from." + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter", + "text": " pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-contents-parameter", + "text": " contents must be a valid VkSubpassContents value" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00896", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-01758", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + } + ] + }, + "VkRenderPassBeginInfo": { + "core": [ + { + "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-00902", + "text": " clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-00903", + "text": " If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount valid VkClearValue unions" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-renderPass-00904", + "text": " renderPass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer." + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo or VkRenderPassSampleLocationsBeginInfoEXT" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-renderPass-parameter", + "text": " renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-parameter", + "text": " framebuffer must be a valid VkFramebuffer handle" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-commonparent", + "text": " Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkRenderPassSampleLocationsBeginInfoEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT" + }, + { + "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter", + "text": " If attachmentInitialSampleLocationsCount is not 0, pAttachmentInitialSampleLocations must be a valid pointer to an array of attachmentInitialSampleLocationsCount valid VkAttachmentSampleLocationsEXT structures" + }, + { + "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter", + "text": " If postSubpassSampleLocationsCount is not 0, pPostSubpassSampleLocations must be a valid pointer to an array of postSubpassSampleLocationsCount valid VkSubpassSampleLocationsEXT structures" + } + ] + }, + "VkAttachmentSampleLocationsEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531", + "text": " attachmentIndex must be less than the attachmentCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with" + }, + { + "vuid": "VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter", + "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" + } + ] + }, + "VkSubpassSampleLocationsEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532", + "text": " subpassIndex must be less than the subpassCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with" + }, + { + "vuid": "VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter", + "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" + } + ] + }, + "VkDeviceGroupRenderPassBeginInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905", + "text": " deviceMask must be a valid device mask value" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907", + "text": " deviceMask must be a subset of the command buffer’s initial device mask" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908", + "text": " deviceRenderAreaCount must either be zero or equal to the number of physical devices in the logical device." + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter", + "text": " If deviceRenderAreaCount is not 0, pDeviceRenderAreas must be a valid pointer to an array of deviceRenderAreaCount VkRect2D structures" + } + ] + }, + "vkGetRenderAreaGranularity": { + "core": [ + { + "vuid": "VUID-vkGetRenderAreaGranularity-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetRenderAreaGranularity-renderPass-parameter", + "text": " renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-vkGetRenderAreaGranularity-pGranularity-parameter", + "text": " pGranularity must be a valid pointer to a VkExtent2D structure" + }, + { + "vuid": "VUID-vkGetRenderAreaGranularity-renderPass-parent", + "text": " renderPass must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdNextSubpass": { + "core": [ + { + "vuid": "VUID-vkCmdNextSubpass-None-00909", + "text": " The current subpass index must be less than the number of subpasses in the render pass minus one" + }, + { + "vuid": "VUID-vkCmdNextSubpass-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdNextSubpass-contents-parameter", + "text": " contents must be a valid VkSubpassContents value" + }, + { + "vuid": "VUID-vkCmdNextSubpass-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdNextSubpass-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdNextSubpass-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdNextSubpass-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ] + }, + "vkCmdEndRenderPass": { + "core": [ + { + "vuid": "VUID-vkCmdEndRenderPass-None-00910", + "text": " The current subpass index must be equal to the number of subpasses in the render pass minus one" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ] + }, + "vkCreateShaderModule": { + "core": [ + { + "vuid": "VUID-vkCreateShaderModule-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateShaderModule-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkShaderModuleCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateShaderModule-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateShaderModule-pShaderModule-parameter", + "text": " pShaderModule must be a valid pointer to a VkShaderModule handle" + } + ] + }, + "VkShaderModuleCreateInfo": { + "core": [ + { + "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-01085", + "text": " codeSize must be greater than 0" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01089", + "text": " pCode must declare the Shader capability for SPIR-V code" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01090", + "text": " pCode must not declare any capability that is not supported by the API, as described by the &amp;lt;&amp;lt;spirvenv-module-validation, Capabilities&amp;gt;&amp;gt; section of the &amp;lt;&amp;lt;spirvenv-capabilities,SPIR-V Environment&amp;gt;&amp;gt; appendix" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01091", + "text": " If pCode declares any of the capabilities listed as optional in the &amp;lt;&amp;lt;spirvenv-capabilities-table,SPIR-V Environment&amp;gt;&amp;gt; appendix, the corresponding feature(s) must be enabled." + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkShaderModuleValidationCacheCreateInfoEXT" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-parameter", + "text": " pCode must be a valid pointer to an array of \\(codeSize \\over 4\\) uint32_t values" + } + ], + "!(VK_NV_glsl_shader)": [ + { + "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-01086", + "text": " codeSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01087", + "text": " pCode must point to valid SPIR-V code, formatted and packed as described by the &amp;lt;&amp;lt;spirv-spec,Khronos SPIR-V Specification&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01088", + "text": " pCode must adhere to the validation rules described by the &amp;lt;&amp;lt;spirvenv-module-validation, Validation Rules within a Module&amp;gt;&amp;gt; section of the &amp;lt;&amp;lt;spirvenv-capabilities,SPIR-V Environment&amp;gt;&amp;gt; appendix" + } + ], + "(VK_NV_glsl_shader)": [ + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01376", + "text": " If pCode points to SPIR-V code, codeSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01377", + "text": " pCode must point to either valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification or valid GLSL code which must be written to the GL_KHR_vulkan_glsl extension specification" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01378", + "text": " If pCode points to SPIR-V code, that code must adhere to the validation rules described by the &amp;lt;&amp;lt;spirvenv-module-validation, Validation Rules within a Module&amp;gt;&amp;gt; section of the &amp;lt;&amp;lt;spirvenv-capabilities,SPIR-V Environment&amp;gt;&amp;gt; appendix" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01379", + "text": " If pCode points to GLSL code, it must be valid GLSL code written to the GL_KHR_vulkan_glsl GLSL extension specification" + } + ] + }, + "VkShaderModuleValidationCacheCreateInfoEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkShaderModuleValidationCacheCreateInfoEXT-validationCache-parameter", + "text": " validationCache must be a valid VkValidationCacheEXT handle" + } + ] + }, + "vkDestroyShaderModule": { + "core": [ + { + "vuid": "VUID-vkDestroyShaderModule-shaderModule-01092", + "text": " If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyShaderModule-shaderModule-01093", + "text": " If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyShaderModule-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyShaderModule-shaderModule-parameter", + "text": " If shaderModule is not VK_NULL_HANDLE, shaderModule must be a valid VkShaderModule handle" + }, + { + "vuid": "VUID-vkDestroyShaderModule-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyShaderModule-shaderModule-parent", + "text": " If shaderModule is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateValidationCacheEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-vkCreateValidationCacheEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateValidationCacheEXT-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkValidationCacheCreateInfoEXT structure" + }, + { + "vuid": "VUID-vkCreateValidationCacheEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateValidationCacheEXT-pValidationCache-parameter", + "text": " pValidationCache must be a valid pointer to a VkValidationCacheEXT handle" + } + ] + }, + "VkValidationCacheCreateInfoEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534", + "text": " If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetValidationCacheDataEXT when pInitialData was originally retrieved" + }, + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535", + "text": " If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetValidationCacheDataEXT" + }, + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-pInitialData-parameter", + "text": " If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes" + } + ] + }, + "vkMergeValidationCachesEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-vkMergeValidationCachesEXT-dstCache-01536", + "text": " dstCache must not appear in the list of source caches" + }, + { + "vuid": "VUID-vkMergeValidationCachesEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkMergeValidationCachesEXT-dstCache-parameter", + "text": " dstCache must be a valid VkValidationCacheEXT handle" + }, + { + "vuid": "VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter", + "text": " pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkValidationCacheEXT handles" + }, + { + "vuid": "VUID-vkMergeValidationCachesEXT-srcCacheCount-arraylength", + "text": " srcCacheCount must be greater than 0" + }, + { + "vuid": "VUID-vkMergeValidationCachesEXT-dstCache-parent", + "text": " dstCache must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkMergeValidationCachesEXT-pSrcCaches-parent", + "text": " Each element of pSrcCaches must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetValidationCacheDataEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-vkGetValidationCacheDataEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetValidationCacheDataEXT-validationCache-parameter", + "text": " validationCache must be a valid VkValidationCacheEXT handle" + }, + { + "vuid": "VUID-vkGetValidationCacheDataEXT-pDataSize-parameter", + "text": " pDataSize must be a valid pointer to a size_t value" + }, + { + "vuid": "VUID-vkGetValidationCacheDataEXT-pData-parameter", + "text": " If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes" + }, + { + "vuid": "VUID-vkGetValidationCacheDataEXT-validationCache-parent", + "text": " validationCache must have been created, allocated, or retrieved from device" + } + ] + }, + "vkDestroyValidationCacheEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-01537", + "text": " If VkAllocationCallbacks were provided when validationCache was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-01538", + "text": " If no VkAllocationCallbacks were provided when validationCache was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyValidationCacheEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-parameter", + "text": " If validationCache is not VK_NULL_HANDLE, validationCache must be a valid VkValidationCacheEXT handle" + }, + { + "vuid": "VUID-vkDestroyValidationCacheEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-parent", + "text": " If validationCache is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateComputePipelines": { + "core": [ + { + "vuid": "VUID-vkCreateComputePipelines-flags-00695", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" + }, + { + "vuid": "VUID-vkCreateComputePipelines-flags-00696", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + }, + { + "vuid": "VUID-vkCreateComputePipelines-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-parameter", + "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pPipelines-parameter", + "text": " pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles" + }, + { + "vuid": "VUID-vkCreateComputePipelines-createInfoCount-arraylength", + "text": " createInfoCount must be greater than 0" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-parent", + "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "VkComputePipelineCreateInfo": { + "core": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00697", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00698", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00699", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00700", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-stage-00701", + "text": " The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-stage-00702", + "text": " The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the &amp;lt;&amp;lt;interfaces,Shader Interfaces&amp;gt;&amp;gt; chapter" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-layout-00703", + "text": " layout must be &amp;lt;&amp;lt;descriptorsets-pipelinelayout-consistency,consistent&amp;gt;&amp;gt; with the layout of the compute shader specified in stage" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-layout-01687", + "text": " The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkPipelineCreateFlagBits values" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-stage-parameter", + "text": " stage must be a valid VkPipelineShaderStageCreateInfo structure" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-commonparent", + "text": " Both of basePipelineHandle, and layout that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkPipelineShaderStageCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00704", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00705", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00706", + "text": " stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-00707", + "text": " pName must be the name of an OpEntryPoint in module with an execution model that matches stage" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708", + "text": " If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709", + "text": " If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710", + "text": " If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711", + "text": " If the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00712", + "text": " If stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00713", + "text": " If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction that specifies a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00714", + "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00715", + "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00716", + "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00717", + "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00718", + "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00719", + "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, it must write to FragDepth in all execution paths" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-parameter", + "text": " stage must be a valid VkShaderStageFlagBits value" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-module-parameter", + "text": " module must be a valid VkShaderModule handle" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-parameter", + "text": " pName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter", + "text": " If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure" + } + ], + "(VK_EXT_shader_stencil_export)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-01511", + "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragStencilRefEXT in any execution path, it must write to FragStencilRefEXT in all execution paths" + } + ] + }, + "vkCreateGraphicsPipelines": { + "core": [ + { + "vuid": "VUID-vkCreateGraphicsPipelines-flags-00720", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-flags-00721", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-parameter", + "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pPipelines-parameter", + "text": " pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength", + "text": " createInfoCount must be greater than 0" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-parent", + "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "VkGraphicsPipelineCreateInfo": { + "core": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00722", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00723", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00724", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00725", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00726", + "text": " The stage member of each element of pStages must be unique" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00727", + "text": " The stage member of one element of pStages must be VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00728", + "text": " The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00729", + "text": " If pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00730", + "text": " If pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00731", + "text": " If pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pTessellationState must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00732", + "text": " If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00733", + "text": " If pStages includes tessellation shader stages, and the shader code of both stages contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline, they must both specify the same subdivision mode" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00734", + "text": " If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the output patch size in the pipeline" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00735", + "text": " If pStages includes tessellation shader stages, and the shader code of both contain an OpExecutionMode instruction that specifies the out patch size in the pipeline, they must both specify the same patch size" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00736", + "text": " If pStages includes tessellation shader stages, the topology member of pInputAssembly must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-topology-00737", + "text": " If the topology member of pInputAssembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, pStages must include tessellation shader stages" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00738", + "text": " If pStages includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is &amp;lt;&amp;lt;shaders-geometry-execution, compatible&amp;gt;&amp;gt; with the primitive topology specified in pInputAssembly" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00739", + "text": " If pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is &amp;lt;&amp;lt;shaders-geometry-execution, compatible&amp;gt;&amp;gt; with the primitive topology that is output by the tessellation stages" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00740", + "text": " If pStages includes a fragment shader stage and a geometry shader stage, and the fragment shader code reads from an input variable that is decorated with PrimitiveID, then the geometry shader code must write to a matching output variable, decorated with PrimitiveID, in all execution paths" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00741", + "text": " If pStages includes a fragment shader stage, its shader code must not read from any input attachment that is defined as VK_ATTACHMENT_UNUSED in subpass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00742", + "text": " The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the &amp;lt;&amp;lt;interfaces,Shader Interfaces&amp;gt;&amp;gt; chapter" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00745", + "text": " If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the blendEnable member of the corresponding element of the pAttachment member of pColorBlendState must be VK_FALSE if the format of the attachment does not support color blend operations, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746", + "text": " If rasterization is not disabled and the subpass uses color attachments, the attachmentCount member of pColorBlendState must be equal to the colorAttachmentCount used to create subpass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747", + "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState::viewportCount VkViewport structures" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748", + "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState::scissorCount VkRect2D structures" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749", + "text": " If the wide lines feature is not enabled, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_WIDTH, the lineWidth member of pRasterizationState must be 1.0" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750", + "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751", + "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752", + "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses a depth/stencil attachment, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753", + "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754", + "text": " If the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-00756", + "text": " layout must be &amp;lt;&amp;lt;descriptorsets-pipelinelayout-consistency,consistent&amp;gt;&amp;gt; with all shaders specified in pStages" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00758", + "text": " If subpass does not use any color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must follow the rules for a &amp;lt;&amp;lt;renderpass-noattachments, zero-attachment subpass&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00759", + "text": " subpass must be a valid subpass within renderPass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-01688", + "text": " The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkPipelineCreateFlagBits values" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-parameter", + "text": " pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter", + "text": " pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter", + "text": " pInputAssemblyState must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter", + "text": " pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter", + "text": " If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter", + "text": " renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength", + "text": " stageCount must be greater than 0" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-commonparent", + "text": " Each of basePipelineHandle, layout, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00743", + "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00744", + "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01756", + "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01757", + "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-01565", + "text": " If pStages includes a fragment shader stage and an input attachment was referenced by the VkRenderPassInputAttachmentAspectCreateInfo at renderPass create time, its shader code must not read from any aspect that was not specified in the aspectMask of the corresponding VkInputAttachmentAspectReference structure." + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755", + "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive" + } + ], + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755", + "text": " If the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521", + "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.width must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.width as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522", + "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.height must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.height as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523", + "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524", + "text": " If the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample" + } + ], + "!(VK_AMD_mixed_attachment_samples)+!(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00757", + "text": " If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must be the same as the sample count for those subpass attachments" + } + ], + "(VK_AMD_mixed_attachment_samples)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01505", + "text": " If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must equal the maximum of the sample counts of those subpass attachments" + } + ], + "(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01411", + "text": " If subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the rasterizationSamples member of pMultisampleState must be the same as the sample count of the depth/stencil attachment" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01412", + "text": " If subpass has any color attachments, then the rasterizationSamples member of pMultisampleState must be greater than or equal to the sample count for those subpass attachments" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00760", + "text": " If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewTessellationShader is not enabled, then pStages must not include tessellation shaders." + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00761", + "text": " If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewGeometryShader is not enabled, then pStages must not include a geometry shader." + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00762", + "text": " If the renderPass has multiview enabled and subpass has more than one bit set in the view mask, shaders in the pipeline must not write to the Layer built-in output" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00763", + "text": " If the renderPass has multiview enabled, then all shaders must not include variables decorated with the Layer built-in decoration in their interfaces." + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00764", + "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag." + } + ], + "(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715", + "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, chained to the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures" + } + ] + }, + "VkPipelineDynamicStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442", + "text": " Each element of pDynamicStates must be unique" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter", + "text": " pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-dynamicStateCount-arraylength", + "text": " dynamicStateCount must be greater than 0" + } + ] + }, + "vkDestroyPipeline": { + "core": [ + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00765", + "text": " All submitted commands that refer to pipeline must have completed execution" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00766", + "text": " If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00767", + "text": " If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyPipeline-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-parameter", + "text": " If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle" + }, + { + "vuid": "VUID-vkDestroyPipeline-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-parent", + "text": " If pipeline is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreatePipelineCache": { + "core": [ + { + "vuid": "VUID-vkCreatePipelineCache-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreatePipelineCache-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkPipelineCacheCreateInfo structure" + }, + { + "vuid": "VUID-vkCreatePipelineCache-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreatePipelineCache-pPipelineCache-parameter", + "text": " pPipelineCache must be a valid pointer to a VkPipelineCache handle" + } + ] + }, + "VkPipelineCacheCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00768", + "text": " If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00769", + "text": " If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pInitialData-parameter", + "text": " If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes" + } + ] + }, + "vkMergePipelineCaches": { + "core": [ + { + "vuid": "VUID-vkMergePipelineCaches-dstCache-00770", + "text": " dstCache must not appear in the list of source caches" + }, + { + "vuid": "VUID-vkMergePipelineCaches-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkMergePipelineCaches-dstCache-parameter", + "text": " dstCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkMergePipelineCaches-pSrcCaches-parameter", + "text": " pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkPipelineCache handles" + }, + { + "vuid": "VUID-vkMergePipelineCaches-srcCacheCount-arraylength", + "text": " srcCacheCount must be greater than 0" + }, + { + "vuid": "VUID-vkMergePipelineCaches-dstCache-parent", + "text": " dstCache must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkMergePipelineCaches-pSrcCaches-parent", + "text": " Each element of pSrcCaches must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetPipelineCacheData": { + "core": [ + { + "vuid": "VUID-vkGetPipelineCacheData-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetPipelineCacheData-pipelineCache-parameter", + "text": " pipelineCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkGetPipelineCacheData-pDataSize-parameter", + "text": " pDataSize must be a valid pointer to a size_t value" + }, + { + "vuid": "VUID-vkGetPipelineCacheData-pData-parameter", + "text": " If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes" + }, + { + "vuid": "VUID-vkGetPipelineCacheData-pipelineCache-parent", + "text": " pipelineCache must have been created, allocated, or retrieved from device" + } + ] + }, + "vkDestroyPipelineCache": { + "core": [ + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00771", + "text": " If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00772", + "text": " If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-parameter", + "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-parent", + "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "VkSpecializationInfo": { + "core": [ + { + "vuid": "VUID-VkSpecializationInfo-offset-00773", + "text": " The offset member of each element of pMapEntries must be less than dataSize" + }, + { + "vuid": "VUID-VkSpecializationInfo-pMapEntries-00774", + "text": " The size member of each element of pMapEntries must be less than or equal to dataSize minus offset" + }, + { + "vuid": "VUID-VkSpecializationInfo-mapEntryCount-00775", + "text": " If mapEntryCount is not 0, pMapEntries must be a valid pointer to an array of mapEntryCount valid VkSpecializationMapEntry structures" + }, + { + "vuid": "VUID-VkSpecializationInfo-pData-parameter", + "text": " If dataSize is not 0, pData must be a valid pointer to an array of dataSize bytes" + } + ] + }, + "VkSpecializationMapEntry": { + "core": [ + { + "vuid": "VUID-VkSpecializationMapEntry-constantID-00776", + "text": " For a constantID specialization constant declared in a shader, size must match the byte size of the constantID. If the specialization constant is of type boolean, size must be the byte size of VkBool32" + } + ] + }, + "vkCmdBindPipeline": { + "core": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00777", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00778", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00779", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00780", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-00781", + "text": " If the &amp;lt;&amp;lt;features-features-variableMultisampleRate,variable multisample rate&amp;gt;&amp;gt; feature is not supported, pipeline is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-parameter", + "text": " pipeline must be a valid VkPipeline handle" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commonparent", + "text": " Both of commandBuffer, and pipeline must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdBindPipeline-variableSampleLocations-01525", + "text": " If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, and pipeline is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its sampleLocationsEnable member set to VK_TRUE but without VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sampleLocationsInfo specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created" + } + ] + }, + "vkGetShaderInfoAMD": { + "(VK_AMD_shader_info)": [ + { + "vuid": "VUID-vkGetShaderInfoAMD-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetShaderInfoAMD-pipeline-parameter", + "text": " pipeline must be a valid VkPipeline handle" + }, + { + "vuid": "VUID-vkGetShaderInfoAMD-shaderStage-parameter", + "text": " shaderStage must be a valid VkShaderStageFlagBits value" + }, + { + "vuid": "VUID-vkGetShaderInfoAMD-infoType-parameter", + "text": " infoType must be a valid VkShaderInfoTypeAMD value" + }, + { + "vuid": "VUID-vkGetShaderInfoAMD-pInfoSize-parameter", + "text": " pInfoSize must be a valid pointer to a size_t value" + }, + { + "vuid": "VUID-vkGetShaderInfoAMD-pInfo-parameter", + "text": " If the value referenced by pInfoSize is not 0, and pInfo is not NULL, pInfo must be a valid pointer to an array of pInfoSize bytes" + }, + { + "vuid": "VUID-vkGetShaderInfoAMD-pipeline-parent", + "text": " pipeline must have been created, allocated, or retrieved from device" + } + ] + }, + "VkAllocationCallbacks": { + "core": [ + { + "vuid": "VUID-VkAllocationCallbacks-pfnAllocation-00632", + "text": " pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction" + }, + { + "vuid": "VUID-VkAllocationCallbacks-pfnReallocation-00633", + "text": " pfnReallocation must be a valid pointer to a valid user-defined PFN_vkReallocationFunction" + }, + { + "vuid": "VUID-VkAllocationCallbacks-pfnFree-00634", + "text": " pfnFree must be a valid pointer to a valid user-defined PFN_vkFreeFunction" + }, + { + "vuid": "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635", + "text": " If either of pfnInternalAllocation or pfnInternalFree is not NULL, both must be valid callbacks" + } + ] + }, + "vkGetPhysicalDeviceMemoryProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter", + "text": " pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties structure" + } + ] + }, + "vkGetPhysicalDeviceMemoryProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter", + "text": " pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties2 structure" + } + ] + }, + "VkPhysicalDeviceMemoryProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2" + }, + { + "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkAllocateMemory": { + "core": [ + { + "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01713", + "text": " pAllocateInfo\\-&amp;gt;allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[pAllocateInfo\\-&amp;gt;memoryTypeIndex].size as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from." + }, + { + "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01714", + "text": " pAllocateInfo\\-&amp;gt;memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from." + }, + { + "vuid": "VUID-vkAllocateMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAllocateMemory-pAllocateInfo-parameter", + "text": " pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure" + }, + { + "vuid": "VUID-vkAllocateMemory-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkAllocateMemory-pMemory-parameter", + "text": " pMemory must be a valid pointer to a VkDeviceMemory handle" + } + ] + }, + "VkMemoryAllocateInfo": { + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00638", + "text": " allocationSize must be greater than 0" + } + ], + "(VK_KHR_external_memory)+(VK_KHR_dedicated_allocation,VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-00639", + "text": " If the pNext chain contains an instance of VkExportMemoryAllocateInfo, and any of the handle types specified in VkExportMemoryAllocateInfo::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2 in VkExternalImageFormatProperties::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferProperties::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of ifdef::VK_KHR_dedicated_allocation[VkMemoryDedicatedAllocateInfo]" + } + ], + "(VK_KHR_external_memory)+(VK_NV_external_memory)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-00640", + "text": " If the pNext chain contains an instance of VkExportMemoryAllocateInfo, it must not contain an instance of VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV." + } + ], + "(VK_KHR_external_memory_win32+VK_NV_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-00641", + "text": " If the pNext chain contains an instance of VkImportMemoryWin32HandleInfoKHR, it must not contain an instance of VkImportMemoryWin32HandleInfoNV." + } + ], + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01742", + "text": " If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648", + "text": " If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHR." + } + ], + "(VK_KHR_external_memory+VK_KHR_device_group)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-None-00643", + "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfo must match that specified when the memory object being imported was allocated." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-None-00644", + "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the memory was originally allocated." + } + ], + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645", + "text": " If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHR." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01743", + "text": " If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00646", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, allocationSize must match the size reported in the memory requirements of the image or buffer member of the instance of VkDedicatedAllocationMemoryAllocateInfoNV included in the pNext chain." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00647", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872", + "text": " If the protected memory feature is not enabled, the VkMemoryAllocateInfo::memoryTypeIndex must not indicate a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT." + } + ], + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744", + "text": " If the parameters define an import operation and the external handle is a host pointer, the value of memoryTypeIndex must be one of those returned by vkGetMemoryHostPointerPropertiesEXT" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01745", + "text": " If the parameters define an import operation and the external handle is a host pointer, allocationSize must be an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-None-01873", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BIT_ANDROID:" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-01874", + "text": " If the parameters do not define an import operation, and the pNext chain contains an instance of VkExportMemoryAllocateInfo with VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID included in its handleTypes member, and the pNext contains an instance of VkMemoryDedicatedAllocateInfo with image not equal to VK_NULL_HANDLE, then allocationSize must be 0, otherwise allocationSize must be greater than 0." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-01875", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE:" + } + ], + "core": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkMemoryAllocateFlagsInfo, or VkMemoryDedicatedAllocateInfo" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + } + ] + }, + "VkMemoryDedicatedAllocateInfo": { + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01432", + "text": " At least one of image and buffer must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01433", + "text": " If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01434", + "text": " If image is not VK_NULL_HANDLE, image must have been created without VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in VkImageCreateInfo::flags" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01435", + "text": " If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01436", + "text": " If buffer is not VK_NULL_HANDLE, buffer must have been created without VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in VkBufferCreateInfo::flags" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-parameter", + "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter", + "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-commonparent", + "text": " Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01876", + "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory." + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01877", + "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory." + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01878", + "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory." + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01879", + "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory." + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01797", + "text": " If image is not VK_NULL_HANDLE, image must not have been created with VK_IMAGE_CREATE_DISJOINT_BIT set in VkImageCreateInfo::flags" + } + ] + }, + "VkDedicatedAllocationMemoryAllocateInfoNV": { + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649", + "text": " At least one of image and buffer must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650", + "text": " If image is not VK_NULL_HANDLE, the image must have been created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651", + "text": " If buffer is not VK_NULL_HANDLE, the buffer must have been created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652", + "text": " If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653", + "text": " If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter", + "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter", + "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-commonparent", + "text": " Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_NV_dedicated_allocation)+(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654", + "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory." + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655", + "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory." + } + ] + }, + "VkExportMemoryAllocateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkExportMemoryAllocateInfo-handleTypes-00656", + "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." + }, + { + "vuid": "VUID-VkExportMemoryAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkExportMemoryAllocateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" + } + ] + }, + "VkExportMemoryWin32HandleInfoKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657", + "text": " If VkExportMemoryAllocateInfo::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, VkExportMemoryWin32HandleInfoKHR must not be in the pNext chain of VkMemoryAllocateInfo." + }, + { + "vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter", + "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" + } + ] + }, + "VkImportMemoryWin32HandleInfoKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658", + "text": " If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659", + "text": " The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660", + "text": " If handleType is not 0, it must be defined as an NT handle or a global share handle." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439", + "text": " If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, name must be NULL." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440", + "text": " If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661", + "text": " If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441", + "text": " if handle is not NULL, name must be NULL." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518", + "text": " If handle is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-name-01519", + "text": " If name is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter", + "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryWin32HandleKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-vkGetMemoryWin32HandleKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter", + "text": " pGetWin32HandleInfo must be a valid pointer to a valid VkMemoryGetWin32HandleInfoKHR structure" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter", + "text": " pHandle must be a valid pointer to a HANDLE value" + } + ] + }, + "VkMemoryGetWin32HandleInfoKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662", + "text": " handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created." + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663", + "text": " If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHR must be called no more than once for each valid unique combination of memory and handleType." + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664", + "text": " handleType must be defined as an NT handle or a global share handle." + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR" + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryWin32HandlePropertiesKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665", + "text": " handle must be an external memory handle created outside of the Vulkan API." + }, + { + "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666", + "text": " handleType must not be one of the handle types defined as opaque." + }, + { + "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter", + "text": " pMemoryWin32HandleProperties must be a valid pointer to a VkMemoryWin32HandlePropertiesKHR structure" + } + ] + }, + "VkImportMemoryFdInfoKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00667", + "text": " If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-00668", + "text": " The memory from which fd was exported must have been created on the same underlying physical device as device." + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00669", + "text": " If handleType is not 0, it must be defined as a POSIX file descriptor handle." + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00670", + "text": " If handleType is not 0, fd must be a valid handle of the type specified by handleType." + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01746", + "text": " The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in &amp;lt;&amp;lt;external-memory-handle-types-compatibility&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01520", + "text": " fd must obey any requirements listed for handleType in &amp;lt;&amp;lt;external-memory-handle-types-compatibility,external memory handle types compatibility&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-parameter", + "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryFdKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-vkGetMemoryFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter", + "text": " pGetFdInfo must be a valid pointer to a valid VkMemoryGetFdInfoKHR structure" + }, + { + "vuid": "VUID-vkGetMemoryFdKHR-pFd-parameter", + "text": " pFd must be a valid pointer to a int value" + } + ] + }, + "VkMemoryGetFdInfoKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00671", + "text": " handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created." + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00672", + "text": " handleType must be defined as a POSIX file descriptor handle." + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryFdPropertiesKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-fd-00673", + "text": " fd must be an external memory handle created outside of the Vulkan API." + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-00674", + "text": " handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR." + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter", + "text": " pMemoryFdProperties must be a valid pointer to a VkMemoryFdPropertiesKHR structure" + } + ] + }, + "VkImportMemoryHostPointerInfoEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747", + "text": " If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryPropertiesKHR" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748", + "text": " If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749", + "text": " pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host mapped foreign memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryHostPointerPropertiesEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753", + "text": " pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to host memory" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to host mapped foreign memory" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter", + "text": " pMemoryHostPointerProperties must be a valid pointer to a VkMemoryHostPointerPropertiesEXT structure" + } + ] + }, + "VkMemoryHostPointerPropertiesEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkMemoryHostPointerPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT" + }, + { + "vuid": "VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkImportAndroidHardwareBufferInfoANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880", + "text": " If buffer is not NULL, Android hardware buffers must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." + }, + { + "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881", + "text": " If buffer is not NULL, it must be a valid Android hardware buffer object with format and usage compatible with Vulkan as described by VkExternalMemoryHandleTypeFlagBits." + }, + { + "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID" + }, + { + "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-parameter", + "text": " buffer must be a valid pointer to a AHardwareBuffer value" + } + ] + }, + "vkGetMemoryAndroidHardwareBufferANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryAndroidHardwareBufferANDROID-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkMemoryGetAndroidHardwareBufferInfoANDROID structure" + }, + { + "vuid": "VUID-vkGetMemoryAndroidHardwareBufferANDROID-pBuffer-parameter", + "text": " pBuffer must be a valid pointer to a valid pointer to a AHardwareBuffer value" + } + ] + }, + "VkMemoryGetAndroidHardwareBufferInfoANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882", + "text": " VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created." + }, + { + "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883", + "text": " If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo with non-NULL image member, then that image must already be bound to memory." + } + ] + }, + "vkGetAndroidHardwareBufferPropertiesANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884", + "text": " buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags." + }, + { + "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-parameter", + "text": " buffer must be a valid pointer to a valid AHardwareBuffer value" + }, + { + "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-pProperties-parameter", + "text": " pProperties must be a valid pointer to a VkAndroidHardwareBufferPropertiesANDROID structure" + } + ] + }, + "VkAndroidHardwareBufferFormatPropertiesANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkAndroidHardwareBufferFormatPropertiesANDROID-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID" + } + ] + }, + "VkExportMemoryAllocateInfoNV": { + "(VK_NV_external_memory)": [ + { + "vuid": "VUID-VkExportMemoryAllocateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV" + }, + { + "vuid": "VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" + } + ] + }, + "VkExportMemoryWin32HandleInfoNV": { + "(VK_NV_external_memory_win32)": [ + { + "vuid": "VUID-VkExportMemoryWin32HandleInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV" + }, + { + "vuid": "VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter", + "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" + } + ] + }, + "VkImportMemoryWin32HandleInfoNV": { + "(VK_NV_external_memory_win32)": [ + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327", + "text": " handleType must not have more than one bit set." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handle-01328", + "text": " handle must be a valid handle to memory, obtained as specified by handleType." + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter", + "text": " handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" + } + ] + }, + "vkGetMemoryWin32HandleNV": { + "(VK_NV_external_memory_win32)": [ + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-handleType-01326", + "text": " handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-handleType-parameter", + "text": " handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask", + "text": " handleType must not be 0" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-pHandle-parameter", + "text": " pHandle must be a valid pointer to a HANDLE value" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ] + }, + "VkMemoryAllocateFlagsInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675", + "text": " If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must be a valid device mask." + }, + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676", + "text": " If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must not be zero" + }, + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO" + }, + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-flags-parameter", + "text": " flags must be a valid combination of VkMemoryAllocateFlagBits values" + } + ] + }, + "vkFreeMemory": { + "core": [ + { + "vuid": "VUID-vkFreeMemory-memory-00677", + "text": " All submitted commands that refer to memory (via images or buffers) must have completed execution" + }, + { + "vuid": "VUID-vkFreeMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkFreeMemory-memory-parameter", + "text": " If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkFreeMemory-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkFreeMemory-memory-parent", + "text": " If memory is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkMapMemory": { + "core": [ + { + "vuid": "VUID-vkMapMemory-memory-00678", + "text": " memory must not be currently mapped" + }, + { + "vuid": "VUID-vkMapMemory-offset-00679", + "text": " offset must be less than the size of memory" + }, + { + "vuid": "VUID-vkMapMemory-size-00680", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" + }, + { + "vuid": "VUID-vkMapMemory-size-00681", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of the memory minus offset" + }, + { + "vuid": "VUID-vkMapMemory-memory-00682", + "text": " memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT" + }, + { + "vuid": "VUID-vkMapMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkMapMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkMapMemory-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-vkMapMemory-ppData-parameter", + "text": " ppData must be a valid pointer to a pointer value" + }, + { + "vuid": "VUID-vkMapMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ], + "(VK_KHR_device_group)": [ + { + "vuid": "VUID-vkMapMemory-memory-00683", + "text": " memory must not have been allocated with multiple instances." + } + ] + }, + "vkFlushMappedMemoryRanges": { + "core": [ + { + "vuid": "VUID-vkFlushMappedMemoryRanges-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter", + "text": " pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures" + }, + { + "vuid": "VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength", + "text": " memoryRangeCount must be greater than 0" + } + ] + }, + "vkInvalidateMappedMemoryRanges": { + "core": [ + { + "vuid": "VUID-vkInvalidateMappedMemoryRanges-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter", + "text": " pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures" + }, + { + "vuid": "VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength", + "text": " memoryRangeCount must be greater than 0" + } + ] + }, + "VkMappedMemoryRange": { + "core": [ + { + "vuid": "VUID-VkMappedMemoryRange-memory-00684", + "text": " memory must be currently mapped" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-00685", + "text": " If size is not equal to VK_WHOLE_SIZE, offset and size must specify a range contained within the currently mapped range of memory" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-00686", + "text": " If size is equal to VK_WHOLE_SIZE, offset must be within the currently mapped range of memory" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-01389", + "text": " If size is equal to VK_WHOLE_SIZE, the end of the current mapping of memory must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize bytes from the beginning of the memory object." + }, + { + "vuid": "VUID-VkMappedMemoryRange-offset-00687", + "text": " offset must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-01390", + "text": " If size is not equal to VK_WHOLE_SIZE, size must either be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, or offset plus size must equal the size of memory." + }, + { + "vuid": "VUID-VkMappedMemoryRange-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE" + }, + { + "vuid": "VUID-VkMappedMemoryRange-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMappedMemoryRange-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + } + ] + }, + "vkUnmapMemory": { + "core": [ + { + "vuid": "VUID-vkUnmapMemory-memory-00689", + "text": " memory must be currently mapped" + }, + { + "vuid": "VUID-vkUnmapMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkUnmapMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkUnmapMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetDeviceMemoryCommitment": { + "core": [ + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-00690", + "text": " memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter", + "text": " pCommittedMemoryInBytes must be a valid pointer to a VkDeviceSize value" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetDeviceGroupPeerMemoryFeatures": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691", + "text": " heapIndex must be less than memoryHeapCount" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692", + "text": " localDeviceIndex must be a valid device index" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693", + "text": " remoteDeviceIndex must be a valid device index" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694", + "text": " localDeviceIndex must not equal remoteDeviceIndex" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter", + "text": " pPeerMemoryFeatures must be a valid pointer to a VkPeerMemoryFeatureFlags value" + } + ] + }, + "vkCreateBuffer": { + "core": [ + { + "vuid": "VUID-vkCreateBuffer-flags-00911", + "text": " If the flags member of pCreateInfo includes VK_BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" + }, + { + "vuid": "VUID-vkCreateBuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateBuffer-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkBufferCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateBuffer-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateBuffer-pBuffer-parameter", + "text": " pBuffer must be a valid pointer to a VkBuffer handle" + } + ] + }, + "VkBufferCreateInfo": { + "core": [ + { + "vuid": "VUID-VkBufferCreateInfo-size-00912", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-00913", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-00914", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00915", + "text": " If the &amp;lt;&amp;lt;features-features-sparseBinding,sparse bindings&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00916", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyBuffer,sparse buffer residency&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00917", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyAliased,sparse aliased residency&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00918", + "text": " If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO" + }, + { + "vuid": "VUID-VkBufferCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV or VkExternalMemoryBufferCreateInfo" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkBufferCreateFlagBits values" + }, + { + "vuid": "VUID-VkBufferCreateInfo-usage-parameter", + "text": " usage must be a valid combination of VkBufferUsageFlagBits values" + }, + { + "vuid": "VUID-VkBufferCreateInfo-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-parameter", + "text": " sharingMode must be a valid VkSharingMode value" + } + ], + "!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-01391", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-01419", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferCreateInfo-pNext-00920", + "text": " If the pNext chain contains an instance of VkExternalMemoryBufferCreateInfo, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo\\-&amp;gt;handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkBufferCreateInfo-flags-01887", + "text": " If the protected memory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-None-01888", + "text": " If any of the bits VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT are set, VK_BUFFER_CREATE_PROTECTED_BIT must not also be set" + } + ], + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkBufferCreateInfo-pNext-01571", + "text": " If the pNext chain contains an instance of VkDedicatedAllocationBufferCreateInfoNV, and the dedicatedAllocation member of the chained structure is VK_TRUE, then flags must not include VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + } + ] + }, + "VkDedicatedAllocationBufferCreateInfoNV": { + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkDedicatedAllocationBufferCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV" + } + ] + }, + "VkExternalMemoryBufferCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkExternalMemoryBufferCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO" + }, + { + "vuid": "VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" + } + ] + }, + "vkDestroyBuffer": { + "core": [ + { + "vuid": "VUID-vkDestroyBuffer-buffer-00922", + "text": " All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-00923", + "text": " If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-00924", + "text": " If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyBuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-parameter", + "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkDestroyBuffer-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-parent", + "text": " If buffer is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateBufferView": { + "core": [ + { + "vuid": "VUID-vkCreateBufferView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateBufferView-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkBufferViewCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateBufferView-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateBufferView-pView-parameter", + "text": " pView must be a valid pointer to a VkBufferView handle" + } + ] + }, + "VkBufferViewCreateInfo": { + "core": [ + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-00925", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-00926", + "text": " offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-range-00928", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be greater than 0" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-range-00929", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be a multiple of the element size of format" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-range-00930", + "text": " If range is not equal to VK_WHOLE_SIZE, range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-00931", + "text": " If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00932", + "text": " buffer must have been created with a usage value containing at least one of VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00933", + "text": " If buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format must be supported for uniform texel buffers, as specified by the VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00934", + "text": " If buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format must be supported for storage texel buffers, as specified by the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00935", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + } + ] + }, + "vkDestroyBufferView": { + "core": [ + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00936", + "text": " All submitted commands that refer to bufferView must have completed execution" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00937", + "text": " If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00938", + "text": " If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyBufferView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-parameter", + "text": " If bufferView is not VK_NULL_HANDLE, bufferView must be a valid VkBufferView handle" + }, + { + "vuid": "VUID-vkDestroyBufferView-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-parent", + "text": " If bufferView is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateImage": { + "core": [ + { + "vuid": "VUID-vkCreateImage-flags-00939", + "text": " If the flags member of pCreateInfo includes VK_IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" + }, + { + "vuid": "VUID-vkCreateImage-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateImage-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkImageCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateImage-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateImage-pImage-parameter", + "text": " pImage must be a valid pointer to a VkImage handle" + } + ] + }, + "VkImageCreateInfo": { + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-00940", + "text": " The combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters." + }, + { + "vuid": "VUID-VkImageCreateInfo-format-00943", + "text": " format must not be VK_FORMAT_UNDEFINED" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-01889", + "text": " If the pNext chain does not contain an instance of VkExternalFormatANDROID, or if format is not VK_FORMAT_UNDEFINED, the combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters." + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-01974", + "text": " If the pNext chain contains an instance of VkExternalFormatANDROID, and its member externalFormat is non-zero the format must be VK_FORMAT_UNDEFINED." + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-01975", + "text": " If the pNext chain does not contain an instance of VkExternalFormatANDROID, or does and its member externalFormat is 0 the format must not be VK_FORMAT_UNDEFINED." + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-01892", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-01893", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0:" + } + ], + "core": [ + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-00941", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-00942", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-00944", + "text": " extent::width must be greater than 0." + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-00945", + "text": " extent::height must be greater than 0." + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-00946", + "text": " extent::depth must be greater than 0." + }, + { + "vuid": "VUID-VkImageCreateInfo-mipLevels-00947", + "text": " mipLevels must be greater than 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-arrayLayers-00948", + "text": " arrayLayers must be greater than 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-00949", + "text": " If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00951", + "text": " If imageType is VK_IMAGE_TYPE_1D, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension1D, or VkImageFormatProperties::maxExtent.width (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00952", + "text": " If imageType is VK_IMAGE_TYPE_2D and flags does not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension2D, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00953", + "text": " If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimensionCube, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00954", + "text": " If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be equal and arrayLayers must be greater than or equal to 6" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00955", + "text": " If imageType is VK_IMAGE_TYPE_3D, extent.width, extent.height and extent.depth must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension3D, or VkImageFormatProperties::maxExtent.width/height/depth (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00956", + "text": " If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00957", + "text": " If imageType is VK_IMAGE_TYPE_2D, extent.depth must be 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-mipLevels-00958", + "text": " mipLevels must be less than or equal to {lfloor}log2(max(extent.width, extent.height, extent.depth)){rfloor} + 1." + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-00959", + "text": " mipLevels must be less than or equal to VkImageFormatProperties::maxMipLevels (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)" + }, + { + "vuid": "VUID-VkImageCreateInfo-arrayLayers-00960", + "text": " arrayLayers must be less than or equal to VkImageFormatProperties::maxArrayLayers (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00961", + "text": " If imageType is VK_IMAGE_TYPE_3D, arrayLayers must be 1." + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-00962", + "text": " If samples is not VK_SAMPLE_COUNT_1_BIT, imageType must be VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, tiling must be VK_IMAGE_TILING_OPTIMAL, and mipLevels must be equal to 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00963", + "text": " If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, then bits other than VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT must not be set" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00964", + "text": " If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00965", + "text": " If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00966", + "text": " If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, usage must also contain at least one of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT." + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-00967", + "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00968", + "text": " If the &amp;lt;&amp;lt;features-features-shaderStorageImageMultisample,multisampled storage images&amp;gt;&amp;gt; feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-00969", + "text": " If the &amp;lt;&amp;lt;features-features-sparseBinding,sparse bindings&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-01924", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyAliased,sparse aliased residency&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00970", + "text": " If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00971", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyImage2D,sparse residency for 2D images&amp;gt;&amp;gt; feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00972", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyImage3D,sparse residency for 3D images&amp;gt;&amp;gt; feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00973", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency2Samples,sparse residency for images with 2 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00974", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency4Samples,sparse residency for images with 4 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00975", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency8Samples,sparse residency for images with 8 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00976", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency16Samples,sparse residency for images with 16 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-00987", + "text": " If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-None-01925", + "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set" + }, + { + "vuid": "VUID-VkImageCreateInfo-initialLayout-00993", + "text": " initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED." + }, + { + "vuid": "VUID-VkImageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageFormatListCreateInfoKHR, or VkImageSwapchainCreateInfoKHR" + }, + { + "vuid": "VUID-VkImageCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-parameter", + "text": " imageType must be a valid VkImageType value" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkImageCreateInfo-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-parameter", + "text": " sharingMode must be a valid VkSharingMode value" + }, + { + "vuid": "VUID-VkImageCreateInfo-initialLayout-parameter", + "text": " initialLayout must be a valid VkImageLayout value" + } + ], + "!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-01392", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-01420", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-00950", + "text": " If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_3D" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-01890", + "text": " If the protected memory feature is not enabled, flags must not contain VK_IMAGE_CREATE_PROTECTED_BIT." + }, + { + "vuid": "VUID-VkImageCreateInfo-None-01891", + "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_CREATE_PROTECTED_BIT must not also be set." + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_NV_external_memory)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-00988", + "text": " If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfo." + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-00990", + "text": " If the pNext chain contains an instance of VkExternalMemoryImageCreateInfo, its handleTypes member must only contain bits that are also in VkExternalImageFormatProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2 with format, imageType, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfo in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfo::handleTypes" + } + ], + "(VK_NV_external_memory+VK_NV_external_memory_capabilities)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-00991", + "text": " If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, imageType, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkImageCreateInfo-physicalDeviceCount-01421", + "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-00992", + "text": " If flags contains VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-01572", + "text": " If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then format must be a &amp;lt;&amp;lt;appendix-compressedtex-bc,block-compressed image format&amp;gt;&amp;gt;, an &amp;lt;&amp;lt;appendix-compressedtex-etc2, ETC compressed image format&amp;gt;&amp;gt;, or an &amp;lt;&amp;lt;appendix-compressedtex-astc, ASTC compressed image format&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-01573", + "text": " If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT." + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory,VK_NV_external_memory)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-01443", + "text": " If the pNext chain includes a ifdef::VK_VERSION_1_1,VK_KHR_external_memory[VkExternalMemoryImageCreateInfo]" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-01574", + "text": " If the image format is one of those listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;:" + }, + { + "vuid": "VUID-VkImageCreateInfo-tiling-01575", + "text": " If tiling is VK_IMAGE_TILING_OPTIMAL, format is a multi-planar format, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-tiling-01576", + "text": " If tiling is VK_IMAGE_TILING_LINEAR, format is a multi-planar format, and VkFormatProperties::linearTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-01577", + "text": " If format is not a multi-planar format, and flags does not include VK_IMAGE_CREATE_ALIAS_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-01533", + "text": " If flags contains VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT format must be a depth or depth/stencil format" + } + ] + }, + "VkDedicatedAllocationImageCreateInfoNV": { + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994", + "text": " If dedicatedAllocation is VK_TRUE, VkImageCreateInfo::flags must not include VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + }, + { + "vuid": "VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV" + } + ] + }, + "VkExternalMemoryImageCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkExternalMemoryImageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" + }, + { + "vuid": "VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask", + "text": " handleTypes must not be 0" + } + ] + }, + "VkExternalMemoryImageCreateInfoNV": { + "(VK_NV_external_memory)": [ + { + "vuid": "VUID-VkExternalMemoryImageCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV" + }, + { + "vuid": "VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" + } + ] + }, + "VkExternalFormatANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkExternalFormatANDROID-externalFormat-01894", + "text": " externalFormat must be 0 or a value returned in the externalFormat member of VkAndroidHardwareBufferFormatPropertiesANDROID by an earlier call to vkGetAndroidHardwareBufferPropertiesANDROID" + }, + { + "vuid": "VUID-VkExternalFormatANDROID-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID" + } + ] + }, + "VkImageSwapchainCreateInfoKHR": { + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995", + "text": " If swapchain is not VK_NULL_HANDLE, the fields of VkImageCreateInfo must match the &amp;lt;&amp;lt;swapchain-wsi-image-create-info, implied image creation parameters&amp;gt;&amp;gt; of the swapchain" + }, + { + "vuid": "VUID-VkImageSwapchainCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter", + "text": " If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle" + } + ] + }, + "VkImageFormatListCreateInfoKHR": { + "(VK_KHR_image_format_list)": [ + { + "vuid": "VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01578", + "text": " If viewFormatCount is not 0, all of the formats in the pViewFormats array must be compatible with the format specified in the format field of VkImageCreateInfo, as described in the compatibility table." + }, + { + "vuid": "VUID-VkImageFormatListCreateInfoKHR-flags-01579", + "text": " If VkImageCreateInfo::flags does not contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, viewFormatCount must be 0 or 1." + }, + { + "vuid": "VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01580", + "text": " If viewFormatCount is not 0, VkImageCreateInfo::format must be in pViewFormats." + }, + { + "vuid": "VUID-VkImageFormatListCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkImageFormatListCreateInfoKHR-pViewFormats-parameter", + "text": " If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values" + } + ] + }, + "vkGetImageSubresourceLayout": { + "core": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-00996", + "text": " image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-aspectMask-00997", + "text": " The aspectMask member of pSubresource must only have a single bit set" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-mipLevel-01716", + "text": " The mipLevel member of pSubresource must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-arrayLayer-01717", + "text": " The arrayLayer member of pSubresource must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-pSubresource-parameter", + "text": " pSubresource must be a valid pointer to a valid VkImageSubresource structure" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-pLayout-parameter", + "text": " pLayout must be a valid pointer to a VkSubresourceLayout structure" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-01581", + "text": " If the format of image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt; with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-01582", + "text": " If the format of image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt; with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-01895", + "text": " If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory." + } + ] + }, + "VkImageSubresource": { + "core": [ + { + "vuid": "VUID-VkImageSubresource-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkImageSubresource-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ] + }, + "vkDestroyImage": { + "core": [ + { + "vuid": "VUID-vkDestroyImage-image-01000", + "text": " All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution" + }, + { + "vuid": "VUID-vkDestroyImage-image-01001", + "text": " If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyImage-image-01002", + "text": " If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyImage-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyImage-image-parameter", + "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkDestroyImage-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyImage-image-parent", + "text": " If image is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateImageView": { + "core": [ + { + "vuid": "VUID-vkCreateImageView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateImageView-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkImageViewCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateImageView-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateImageView-pView-parameter", + "text": " pView must be a valid pointer to a VkImageView handle" + } + ] + }, + "VkImageViewCreateInfo": { + "core": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01003", + "text": " If image was not created with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then viewType must not be VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-01004", + "text": " If the &amp;lt;&amp;lt;features-features-imageCubeArray,image cubemap arrays&amp;gt;&amp;gt; feature is not enabled, viewType must not be VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01006", + "text": " If image was created with VK_IMAGE_TILING_LINEAR, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01007", + "text": " image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01008", + "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01009", + "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01010", + "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01011", + "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01478", + "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01718", + "text": " If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01018", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01020", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subResourceRange-01021", + "text": " subresourceRange and viewType must be compatible with the image, as described in the &amp;lt;&amp;lt;resources-image-views-compatibility,compatibility table&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageViewUsageCreateInfo or VkSamplerYcbcrConversionInfo" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-parameter", + "text": " viewType must be a valid VkImageViewType value" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-components-parameter", + "text": " components must be a valid VkComponentMapping structure" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-parameter", + "text": " subresourceRange must be a valid VkImageSubresourceRange structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01005", + "text": " If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01482", + "text": " If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01483", + "text": " If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01484", + "text": " If image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the extent.depth specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01485", + "text": " If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the extent.depth specified in VkImageCreateInfo when image was created" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01012", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01013", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01014", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01015", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01016", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01965", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and format is not VK_FORMAT_UNDEFINED, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01966", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01967", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01968", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01969", + "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01896", + "text": " If image has an &amp;lt;&amp;lt;memory-external-android-hardware-buffer-external-formats,external format&amp;gt;&amp;gt;:" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01480", + "text": " subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01719", + "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01759", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01760", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, and if the format of the image is not a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01761", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, and if the format of the image is not a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01583", + "text": " If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with, or must be an uncompressed format that is size-compatible with, the format used to create image." + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01584", + "text": " If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, the levelCount and layerCount members of subresourceRange must both be 1." + } + ], + "(VK_KHR_image_format_list)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-01585", + "text": " If a VkImageFormatListCreateInfoKHR structure was included in the pNext chain of the VkImageCreateInfo struct used when creating image and the viewFormatCount field of VkImageFormatListCreateInfoKHR is not zero then format must be one of the formats in VkImageFormatListCreateInfoKHR::pViewFormats." + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01586", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format, and if subresourceRange.aspectMask is one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in &amp;lt;&amp;lt;features-formats-compatible-planes&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01762", + "text": " If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, or if the format of the image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format and if subresourceRange.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, format must be identical to the format used to create image" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-01970", + "text": " If the pNext chain contains an instance of VkSamplerYcbcrConversionInfo with a conversion value other than VK_NULL_HANDLE, all members of components must have the value VK_COMPONENT_SWIZZLE_IDENTITY." + } + ], + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01019", + "text": " If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be identical to the format used to create image" + } + ] + }, + "VkImageViewUsageCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageViewUsageCreateInfo-usage-01587", + "text": " usage must not include any set bits that were not set in the usage member of the VkImageCreateInfo structure used to create the image this image view is created from." + }, + { + "vuid": "VUID-VkImageViewUsageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageViewUsageCreateInfo-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask", + "text": " usage must not be 0" + } + ] + }, + "VkImageSubresourceRange": { + "core": [ + { + "vuid": "VUID-VkImageSubresourceRange-levelCount-01720", + "text": " If levelCount is not VK_REMAINING_MIP_LEVELS, it must be greater than 0" + }, + { + "vuid": "VUID-VkImageSubresourceRange-layerCount-01721", + "text": " If layerCount is not VK_REMAINING_ARRAY_LAYERS, it must be greater than 0" + }, + { + "vuid": "VUID-VkImageSubresourceRange-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageSubresourceRange-aspectMask-01670", + "text": " If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, then it must not include any of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ] + }, + "VkComponentMapping": { + "core": [ + { + "vuid": "VUID-VkComponentMapping-r-parameter", + "text": " r must be a valid VkComponentSwizzle value" + }, + { + "vuid": "VUID-VkComponentMapping-g-parameter", + "text": " g must be a valid VkComponentSwizzle value" + }, + { + "vuid": "VUID-VkComponentMapping-b-parameter", + "text": " b must be a valid VkComponentSwizzle value" + }, + { + "vuid": "VUID-VkComponentMapping-a-parameter", + "text": " a must be a valid VkComponentSwizzle value" + } + ] + }, + "vkDestroyImageView": { + "core": [ + { + "vuid": "VUID-vkDestroyImageView-imageView-01026", + "text": " All submitted commands that refer to imageView must have completed execution" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-01027", + "text": " If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-01028", + "text": " If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyImageView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-parameter", + "text": " If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle" + }, + { + "vuid": "VUID-vkDestroyImageView-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-parent", + "text": " If imageView is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetBufferMemoryRequirements": { + "core": [ + { + "vuid": "VUID-vkGetBufferMemoryRequirements-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements-buffer-parent", + "text": " buffer must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetImageMemoryRequirements": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkGetImageMemoryRequirements-image-01588", + "text": " image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set" + } + ], + "core": [ + { + "vuid": "VUID-vkGetImageMemoryRequirements-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetBufferMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-vkGetBufferMemoryRequirements2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements2-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkBufferMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure" + } + ] + }, + "VkBufferMemoryRequirementsInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkBufferMemoryRequirementsInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2" + }, + { + "vuid": "VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ] + }, + "vkGetImageMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-vkGetImageMemoryRequirements2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements2-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkImageMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure" + } + ] + }, + "VkImageMemoryRequirementsInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01589", + "text": " If image was created with a multi-planar format and the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01590", + "text": " If image was not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01591", + "text": " If image was created with a single-plane format, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01897", + "text": " If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory." + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkImagePlaneMemoryRequirementsInfo" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-parameter", + "text": " image must be a valid VkImage handle" + } + ] + }, + "VkImagePlaneMemoryRequirementsInfo": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-01592", + "text": " planeAspect must be an aspect that exists in the format; that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT" + }, + { + "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO" + }, + { + "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter", + "text": " planeAspect must be a valid VkImageAspectFlagBits value" + } + ] + }, + "VkMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkMemoryRequirements2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2" + }, + { + "vuid": "VUID-VkMemoryRequirements2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkMemoryDedicatedRequirements" + } + ] + }, + "VkMemoryDedicatedRequirements": { + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryDedicatedRequirements-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS" + } + ] + }, + "vkBindBufferMemory": { + "core": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01029", + "text": " buffer must not already be backed by a memory object" + }, + { + "vuid": "VUID-vkBindBufferMemory-buffer-01030", + "text": " buffer must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-vkBindBufferMemory-memoryOffset-01031", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-01035", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-vkBindBufferMemory-memoryOffset-01036", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-vkBindBufferMemory-size-01037", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset" + }, + { + "vuid": "VUID-vkBindBufferMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindBufferMemory-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkBindBufferMemory-buffer-parent", + "text": " buffer must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01444", + "text": " If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-01508", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkBindBufferMemory-None-01898", + "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + }, + { + "vuid": "VUID-vkBindBufferMemory-None-01899", + "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + } + ], + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01038", + "text": " If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero" + } + ], + "(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01039", + "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ] + }, + "vkBindBufferMemory2": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-vkBindBufferMemory2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindBufferMemory2-pBindInfos-parameter", + "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindBufferMemoryInfo structures" + }, + { + "vuid": "VUID-vkBindBufferMemory2-bindInfoCount-arraylength", + "text": " bindInfoCount must be greater than 0" + } + ] + }, + "VkBindBufferMemoryInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01593", + "text": " buffer must not already be backed by a memory object" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01594", + "text": " buffer must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memoryOffset-01595", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-01599", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memoryOffset-01600", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-size-01601", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-commonparent", + "text": " Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01602", + "text": " If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer and memoryOffset must be zero" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-01900", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer and memoryOffset must be zero." + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01603", + "text": " If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to buffer and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01604", + "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-pNext-01605", + "text": " If the pNext chain includes VkBindBufferMemoryDeviceGroupInfo, all instances of memory specified by VkBindBufferMemoryDeviceGroupInfo::pDeviceIndices must have been allocated" + } + ] + }, + "VkBindBufferMemoryDeviceGroupInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606", + "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" + }, + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607", + "text": " All elements of pDeviceIndices must be valid device indices" + }, + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO" + }, + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter", + "text": " If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values" + } + ] + }, + "vkBindImageMemory": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01608", + "text": " image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT set." + } + ], + "core": [ + { + "vuid": "VUID-vkBindImageMemory-image-01044", + "text": " image must not already be backed by a memory object" + }, + { + "vuid": "VUID-vkBindImageMemory-image-01045", + "text": " image must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-vkBindImageMemory-memoryOffset-01046", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-01047", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-vkBindImageMemory-memoryOffset-01048", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-vkBindImageMemory-size-01049", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image must be less than or equal to the size of memory minus memoryOffset" + }, + { + "vuid": "VUID-vkBindImageMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindImageMemory-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkBindImageMemory-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01445", + "text": " If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-01509", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkBindImageMemory-None-01901", + "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + }, + { + "vuid": "VUID-vkBindImageMemory-None-01902", + "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + } + ], + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01050", + "text": " If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero" + } + ], + "(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01051", + "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ] + }, + "vkBindImageMemory2": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-vkBindImageMemory2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindImageMemory2-pBindInfos-parameter", + "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindImageMemoryInfo structures" + }, + { + "vuid": "VUID-vkBindImageMemory2-bindInfoCount-arraylength", + "text": " bindInfoCount must be greater than 0" + } + ] + }, + "VkBindImageMemoryInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01609", + "text": " image must not already be backed by a memory object" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01610", + "text": " image must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memoryOffset-01611", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, or VkBindImagePlaneMemoryInfo" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-commonparent", + "text": " Both of image, and memory that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01612", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memoryOffset-01613", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01614", + "text": " The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01615", + "text": " If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01616", + "text": " If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01617", + "text": " If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01618", + "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, image must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set." + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01619", + "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2’s pNext chain" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01620", + "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2’s pNext chain" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01621", + "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2’s pNext chain" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01622", + "text": " If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image and memoryOffset must be zero" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01903", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero." + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01623", + "text": " If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to image and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01624", + "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1+VK_KHR_swapchain)+!(VK_KHR_device_group+VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01625", + "text": " memory must be a valid VkDeviceMemory handle" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01626", + "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all instances of memory specified by VkBindImageMemoryDeviceGroupInfo::pDeviceIndices must have been allocated" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01627", + "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, and VkBindImageMemoryDeviceGroupInfo::splitInstanceBindRegionCount is not zero, then image must have been created with the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit set" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01628", + "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions must be valid rectangles contained within the dimensions of image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01629", + "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, the union of the areas of all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions that correspond to the same instance of image must cover the entire image." + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01630", + "text": " If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01631", + "text": " If the pNext chain includes an instance of VkBindImageMemorySwapchainInfoKHR, memory must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01632", + "text": " If the pNext chain does not include an instance of VkBindImageMemorySwapchainInfoKHR, memory must be a valid VkDeviceMemory handle" + } + ] + }, + "VkBindImageMemoryDeviceGroupInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633", + "text": " At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero." + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634", + "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635", + "text": " All elements of pDeviceIndices must be valid device indices." + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636", + "text": " splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637", + "text": " Elements of pSplitInstanceBindRegions that correspond to the same instance of an image must not overlap." + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638", + "text": " The offset.x member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of all non-metadata aspects of the image" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639", + "text": " The offset.y member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of all non-metadata aspects of the image" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640", + "text": " The extent.width member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block width of all non-metadata aspects of the image, or else extent.width + offset.x must equal the width of the image subresource" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641", + "text": " The extent.height member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block height of all non-metadata aspects of the image, or else extent.height
offset.y must equal the width of the image subresource" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter", + "text": " If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter", + "text": " If splitInstanceBindRegionCount is not 0, pSplitInstanceBindRegions must be a valid pointer to an array of splitInstanceBindRegionCount VkRect2D structures" + } + ] + }, + "VkBindImageMemorySwapchainInfoKHR": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644", + "text": " imageIndex must be less than the number of images in swapchain" + }, + { + "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR" + }, + { + "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + } + ] + }, + "VkBindImagePlaneMemoryInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-01642", + "text": " planeAspect must be a single valid plane aspect for the image format (that is, planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT for “_2PLANE” formats and planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT for “_3PLANE” formats)" + }, + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-None-01643", + "text": " A single call to vkBindImageMemory2 must bind all or none of the planes of an image (i.e. bindings to all planes of an image must be made in a single vkBindImageMemory2 call), as separate bindings" + }, + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO" + }, + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter", + "text": " planeAspect must be a valid VkImageAspectFlagBits value" + } + ] + }, + "vkCreateSampler": { + "core": [ + { + "vuid": "VUID-vkCreateSampler-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSampler-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSamplerCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateSampler-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateSampler-pSampler-parameter", + "text": " pSampler must be a valid pointer to a VkSampler handle" + } + ] + }, + "VkSamplerCreateInfo": { + "core": [ + { + "vuid": "VUID-VkSamplerCreateInfo-mipLodBias-01069", + "text": " The absolute value of mipLodBias must be less than or equal to VkPhysicalDeviceLimits::maxSamplerLodBias" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-maxLod-01973", + "text": " maxLod must be greater than or equal to minLod" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01070", + "text": " If the &amp;lt;&amp;lt;features-features-samplerAnisotropy,anisotropic sampling&amp;gt;&amp;gt; feature is not enabled, anisotropyEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01071", + "text": " If anisotropyEnable is VK_TRUE, maxAnisotropy must be between 1.0 and VkPhysicalDeviceLimits::maxSamplerAnisotropy, inclusive" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072", + "text": " If unnormalizedCoordinates is VK_TRUE, minFilter and magFilter must be equal" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073", + "text": " If unnormalizedCoordinates is VK_TRUE, mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074", + "text": " If unnormalizedCoordinates is VK_TRUE, minLod and maxLod must be zero" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075", + "text": " If unnormalizedCoordinates is VK_TRUE, addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076", + "text": " If unnormalizedCoordinates is VK_TRUE, anisotropyEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077", + "text": " If unnormalizedCoordinates is VK_TRUE, compareEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01078", + "text": " If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a valid VkBorderColor value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079", + "text": " If the VK_KHR_sampler_mirror_clamp_to_edge extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01080", + "text": " If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSamplerReductionModeCreateInfoEXT or VkSamplerYcbcrConversionInfo" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-magFilter-parameter", + "text": " magFilter must be a valid VkFilter value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-minFilter-parameter", + "text": " minFilter must be a valid VkFilter value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-mipmapMode-parameter", + "text": " mipmapMode must be a valid VkSamplerMipmapMode value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-parameter", + "text": " addressModeU must be a valid VkSamplerAddressMode value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeV-parameter", + "text": " addressModeV must be a valid VkSamplerAddressMode value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeW-parameter", + "text": " addressModeW must be a valid VkSamplerAddressMode value" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-minFilter-01645", + "text": " If &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; is enabled and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT is not set for the format, minFilter and magFilter must be equal to the sampler Y’CBCR conversion’s chromaFilter" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01646", + "text": " If &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; is enabled, addressModeU, addressModeV, and addressModeW must be VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE, and unnormalizedCoordinates must be VK_FALSE" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-None-01647", + "text": " The sampler reduction mode must be set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT if &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; is enabled" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-magFilter-01081", + "text": " If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, anisotropyEnable must be VK_FALSE" + } + ], + "(VK_IMG_filter_cubic+VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-magFilter-01422", + "text": " If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT" + } + ], + "(VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01423", + "text": " If compareEnable is VK_TRUE, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT" + } + ] + }, + "VkSamplerReductionModeCreateInfoEXT": { + "(VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkSamplerReductionModeCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkSamplerReductionModeCreateInfoEXT-reductionMode-parameter", + "text": " reductionMode must be a valid VkSamplerReductionModeEXT value" + } + ] + }, + "vkDestroySampler": { + "core": [ + { + "vuid": "VUID-vkDestroySampler-sampler-01082", + "text": " All submitted commands that refer to sampler must have completed execution" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-01083", + "text": " If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-01084", + "text": " If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySampler-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-parameter", + "text": " If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle" + }, + { + "vuid": "VUID-vkDestroySampler-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-parent", + "text": " If sampler is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "VkSamplerYcbcrConversionInfo": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionInfo-conversion-parameter", + "text": " conversion must be a valid VkSamplerYcbcrConversion handle" + } + ] + }, + "vkCreateSamplerYcbcrConversion": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-None-01648", + "text": " The &amp;lt;&amp;lt;features-features-sampler-YCbCr-conversion, sampler Y’CBCR conversion feature&amp;gt;&amp;gt; must be enabled" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter", + "text": " pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle" + } + ] + }, + "VkSamplerYcbcrConversionCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01649", + "text": " format must not be VK_FORMAT_UNDEFINED" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01904", + "text": " If an external format conversion is being created, format must be VK_FORMAT_UNDEFINED, otherwise it must not be VK_FORMAT_UNDEFINED." + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01650", + "text": " format must support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651", + "text": " If the format does not support VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_COSITED_EVEN" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652", + "text": " If the format does not support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_MIDPOINT" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01653", + "text": " format must represent unsigned normalized values (i.e. the format must be a UNORM format)" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-None-01654", + "text": " If the format has a _422 or _420 suffix:" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655", + "text": " If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to channels of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a channel which contains zero or one as a consequence of &amp;lt;&amp;lt;textures-conversion-to-rgba,conversion to RGBA&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656", + "text": " If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, forceExplicitReconstruction must be FALSE" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657", + "text": " If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, chromaFilter must be VK_FILTER_NEAREST" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkExternalFormatANDROID" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter", + "text": " ycbcrModel must be a valid VkSamplerYcbcrModelConversion value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter", + "text": " ycbcrRange must be a valid VkSamplerYcbcrRange value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter", + "text": " components must be a valid VkComponentMapping structure" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter", + "text": " xChromaOffset must be a valid VkChromaLocation value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter", + "text": " yChromaOffset must be a valid VkChromaLocation value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter", + "text": " chromaFilter must be a valid VkFilter value" + } + ] + }, + "vkDestroySamplerYcbcrConversion": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", + "text": " If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle" + }, + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent", + "text": " If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateDescriptorSetLayout": { + "core": [ + { + "vuid": "VUID-vkCreateDescriptorSetLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter", + "text": " pSetLayout must be a valid pointer to a VkDescriptorSetLayout handle" + } + ] + }, + "VkDescriptorSetLayoutCreateInfo": { + "core": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-binding-00279", + "text": " The VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values." + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetLayoutBindingFlagsCreateInfoEXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkDescriptorSetLayoutCreateFlagBits values" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter", + "text": " If bindingCount is not 0, pBindings must be a valid pointer to an array of bindingCount valid VkDescriptorSetLayoutBinding structures" + } + ], + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-00280", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-00281", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then the total number of elements of all bindings must be less than or equal to VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors" + } + ], + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-03000", + "text": " If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, flags must include VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001", + "text": " If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + } + ] + }, + "VkDescriptorSetLayoutBinding": { + "core": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283", + "text": " If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-01510", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter", + "text": " descriptorType must be a valid VkDescriptorType value" + } + ] + }, + "VkDescriptorSetLayoutBindingFlagsCreateInfoEXT": { + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-bindingCount-03002", + "text": " If bindingCount is not zero, bindingCount must equal VkDescriptorSetLayoutCreateInfo::bindingCount" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03004", + "text": " If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformBufferUpdateAfterBind-03005", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingSampledImageUpdateAfterBind-03006", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingSampledImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageImageUpdateAfterBind-03007", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageBufferUpdateAfterBind-03008", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformTexelBufferUpdateAfterBind-03009", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageTexelBufferUpdateAfterBind-03010", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-None-03011", + "text": " All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUpdateUnusedWhilePending-03012", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUpdateUnusedWhilePending is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingPartiallyBound-03013", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingPartiallyBound is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingVariableDescriptorCount-03014", + "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingVariableDescriptorCount is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03015", + "text": " If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, that element’s descriptorType must not be VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-parameter", + "text": " If bindingCount is not 0, pBindingFlags must be a valid pointer to an array of bindingCount valid combinations of VkDescriptorBindingFlagBitsEXT values" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-requiredbitmask", + "text": " Each element of pBindingFlags must not be 0" + } + ], + "(VK_EXT_descriptor_indexing)+(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-flags-03003", + "text": " If VkDescriptorSetLayoutCreateInfo::flags includes VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT, or VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT" + } + ] + }, + "vkGetDescriptorSetLayoutSupport": { + "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ + { + "vuid": "VUID-vkGetDescriptorSetLayoutSupport-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure" + }, + { + "vuid": "VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter", + "text": " pSupport must be a valid pointer to a VkDescriptorSetLayoutSupport structure" + } + ] + }, + "VkDescriptorSetLayoutSupport": { + "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutSupport-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutSupport-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountLayoutSupportEXT" + } + ] + }, + "VkDescriptorSetVariableDescriptorCountLayoutSupportEXT": { + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountLayoutSupportEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT" + } + ] + }, + "vkDestroyDescriptorSetLayout": { + "core": [ + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284", + "text": " If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285", + "text": " If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter", + "text": " If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent", + "text": " If descriptorSetLayout is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreatePipelineLayout": { + "core": [ + { + "vuid": "VUID-vkCreatePipelineLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreatePipelineLayout-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkPipelineLayoutCreateInfo structure" + }, + { + "vuid": "VUID-vkCreatePipelineLayout-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreatePipelineLayout-pPipelineLayout-parameter", + "text": " pPipelineLayout must be a valid pointer to a VkPipelineLayout handle" + } + ] + }, + "VkPipelineLayoutCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286", + "text": " setLayoutCount must be less than or equal to VkPhysicalDeviceLimits::maxBoundDescriptorSets" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292", + "text": " Any two elements of pPushConstantRanges must not include the same stage in stageFlags" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", + "text": " If setLayoutCount is not 0, pSetLayouts must be a valid pointer to an array of setLayoutCount valid VkDescriptorSetLayout handles" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter", + "text": " If pushConstantRangeCount is not 0, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures" + } + ], + "!(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00287", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00288", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00289", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00290", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00291", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01676", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01677", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01678", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01679", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01680", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01681", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01682", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01683", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01684", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments" + } + ], + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03016", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03017", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03018", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03019", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03020", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03021", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03022", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03023", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03024", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03025", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03026", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03027", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03028", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03029", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03030", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03031", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03032", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03033", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03034", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03035", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindInputAttachments" + } + ], + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293", + "text": " pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set" + } + ] + }, + "VkPushConstantRange": { + "core": [ + { + "vuid": "VUID-VkPushConstantRange-offset-00294", + "text": " offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize" + }, + { + "vuid": "VUID-VkPushConstantRange-offset-00295", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-VkPushConstantRange-size-00296", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-VkPushConstantRange-size-00297", + "text": " size must be a multiple of 4" + }, + { + "vuid": "VUID-VkPushConstantRange-size-00298", + "text": " size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset" + }, + { + "vuid": "VUID-VkPushConstantRange-stageFlags-parameter", + "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-VkPushConstantRange-stageFlags-requiredbitmask", + "text": " stageFlags must not be 0" + } + ] + }, + "vkDestroyPipelineLayout": { + "core": [ + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00299", + "text": " If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00300", + "text": " If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-parameter", + "text": " If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-parent", + "text": " If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateDescriptorPool": { + "core": [ + { + "vuid": "VUID-vkCreateDescriptorPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateDescriptorPool-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorPoolCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateDescriptorPool-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDescriptorPool-pDescriptorPool-parameter", + "text": " pDescriptorPool must be a valid pointer to a VkDescriptorPool handle" + } + ] + }, + "VkDescriptorPoolCreateInfo": { + "core": [ + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-maxSets-00301", + "text": " maxSets must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkDescriptorPoolCreateFlagBits values" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter", + "text": " pPoolSizes must be a valid pointer to an array of poolSizeCount valid VkDescriptorPoolSize structures" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength", + "text": " poolSizeCount must be greater than 0" + } + ] + }, + "VkDescriptorPoolSize": { + "core": [ + { + "vuid": "VUID-VkDescriptorPoolSize-descriptorCount-00302", + "text": " descriptorCount must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorPoolSize-type-parameter", + "text": " type must be a valid VkDescriptorType value" + } + ] + }, + "vkDestroyDescriptorPool": { + "core": [ + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00303", + "text": " All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00304", + "text": " If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00305", + "text": " If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-parameter", + "text": " If descriptorPool is not VK_NULL_HANDLE, descriptorPool must be a valid VkDescriptorPool handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-parent", + "text": " If descriptorPool is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkAllocateDescriptorSets": { + "core": [ + { + "vuid": "VUID-vkAllocateDescriptorSets-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter", + "text": " pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure" + }, + { + "vuid": "VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter", + "text": " pDescriptorSets must be a valid pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles" + } + ] + }, + "VkDescriptorSetAllocateInfo": { + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-00306", + "text": " descriptorSetCount must not be greater than the number of sets that are currently available for allocation in descriptorPool" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorPool-00307", + "text": " descriptorPool must have enough free descriptor capacity remaining to allocate the descriptor sets of the specified layouts" + } + ], + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308", + "text": " Each element of pSetLayouts must not have been created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set" + } + ], + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044", + "text": " If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set" + } + ], + "core": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountAllocateInfoEXT" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter", + "text": " descriptorPool must be a valid VkDescriptorPool handle" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter", + "text": " pSetLayouts must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSetLayout handles" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength", + "text": " descriptorSetCount must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-commonparent", + "text": " Both of descriptorPool, and the elements of pSetLayouts must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkDescriptorSetVariableDescriptorCountAllocateInfoEXT": { + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-descriptorSetCount-03045", + "text": " If descriptorSetCount is not zero, descriptorSetCount must equal VkDescriptorSetAllocateInfo::descriptorSetCount" + }, + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pSetLayouts-03046", + "text": " If VkDescriptorSetAllocateInfo::pSetLayouts[i] has a variable descriptor count binding, then pDescriptorCounts[i] must be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created." + }, + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pDescriptorCounts-parameter", + "text": " If descriptorSetCount is not 0, pDescriptorCounts must be a valid pointer to an array of descriptorSetCount uint32_t values" + } + ] + }, + "vkFreeDescriptorSets": { + "core": [ + { + "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00309", + "text": " All submitted commands that refer to any element of pDescriptorSets must have completed execution" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00310", + "text": " pDescriptorSets must be a valid pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00311", + "text": " Each valid handle in pDescriptorSets must have been allocated from descriptorPool" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-00312", + "text": " descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-parameter", + "text": " descriptorPool must be a valid VkDescriptorPool handle" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength", + "text": " descriptorSetCount must be greater than 0" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-parent", + "text": " descriptorPool must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-parent", + "text": " Each element of pDescriptorSets that is a valid handle must have been created, allocated, or retrieved from descriptorPool" + } + ] + }, + "vkResetDescriptorPool": { + "core": [ + { + "vuid": "VUID-vkResetDescriptorPool-descriptorPool-00313", + "text": " All uses of descriptorPool (via any allocated descriptor sets) must have completed execution" + }, + { + "vuid": "VUID-vkResetDescriptorPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetDescriptorPool-descriptorPool-parameter", + "text": " descriptorPool must be a valid VkDescriptorPool handle" + }, + { + "vuid": "VUID-vkResetDescriptorPool-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-vkResetDescriptorPool-descriptorPool-parent", + "text": " descriptorPool must have been created, allocated, or retrieved from device" + } + ] + }, + "vkUpdateDescriptorSets": { + "!(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-dstSet-00314", + "text": " The dstSet member of each element of pDescriptorWrites or pDescriptorCopies must not be used by any command that was recorded to a command buffer which is in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." + } + ], + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-None-03047", + "text": " Descriptor bindings updated by this command which were created without the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT bits set must not be used by any command that was recorded to a command buffer which is in the &amp;lt;&amp;lt;commandbuffers-lifecycle,pending state&amp;gt;&amp;gt;." + } + ], + "core": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter", + "text": " If descriptorWriteCount is not 0, pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter", + "text": " If descriptorCopyCount is not 0, pDescriptorCopies must be a valid pointer to an array of descriptorCopyCount valid VkCopyDescriptorSet structures" + } + ] + }, + "VkWriteDescriptorSet": { + "core": [ + { + "vuid": "VUID-VkWriteDescriptorSet-dstBinding-00315", + "text": " dstBinding must be less than or equal to the maximum value of binding of all VkDescriptorSetLayoutBinding structures specified when dstSet’s descriptor set layout was created" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-dstBinding-00316", + "text": " dstBinding must be a binding with a non-zero descriptorCount" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00317", + "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical descriptorType and stageFlags." + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00318", + "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must all either use immutable samplers or must all not use immutable samplers." + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00319", + "text": " descriptorType must match the type of dstBinding within dstSet" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-dstSet-00320", + "text": " dstSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-dstArrayElement-00321", + "text": " The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00322", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pImageInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorImageInfo structures" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00323", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pTexelBufferView must be a valid pointer to an array of descriptorCount valid VkBufferView handles" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00324", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00325", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was not allocated with a layout that included immutable samplers for dstBinding with descriptorType, the sampler member of each element of pImageInfo must be a valid VkSampler object" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00326", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView and imageLayout members of each element of pImageInfo must be a valid VkImageView and VkImageLayout, respectively" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01946", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, then the imageView member of each pImageInfo element must have been created without a VkSamplerYcbcrConversionInfo structure in its pNext chain" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01947", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and if any element of pImageInfo has a imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, then dstSet must have been allocated with a layout that included immutable samplers for dstBinding" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01948", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was allocated with a layout that included immutable samplers for dstBinding, then the imageView member of each element of pImageInfo which corresponds to a immutable sampler that enables &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; must have been created with a VkSamplerYcbcrConversionInfo structure in its pNext chain with an identically defined VkSamplerYcbcrConversionInfo to the corresponding immutable sampler" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01402", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, for each descriptor that will be accessed via load or store operations the imageLayout member for corresponding elements of pImageInfo must be VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00327", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00328", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00329", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, and the buffer member of any element of pBufferInfo is the handle of a non-sparse buffer, then that buffer must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00330", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00331", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00332", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxUniformBufferRange" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00333", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxStorageBufferRange" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00334", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00335", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00336", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the identity swizzle" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00337", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_SAMPLED_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01403", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageLayout member of each element of pImageInfo must be VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00338", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00339", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-parameter", + "text": " descriptorType must be a valid VkDescriptorType value" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-arraylength", + "text": " descriptorCount must be greater than 0" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-commonparent", + "text": " Both of dstSet, and the elements of pTexelBufferView that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-03048", + "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical VkDescriptorBindingFlagBitsEXT." + } + ] + }, + "VkDescriptorBufferInfo": { + "core": [ + { + "vuid": "VUID-VkDescriptorBufferInfo-offset-00340", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-VkDescriptorBufferInfo-range-00341", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorBufferInfo-range-00342", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be less than or equal to the size of buffer minus offset" + }, + { + "vuid": "VUID-VkDescriptorBufferInfo-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ] + }, + "VkDescriptorImageInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkDescriptorImageInfo-imageView-00343", + "text": " imageView must not be 2D or 2D array image view created from a 3D image" + } + ], + "core": [ + { + "vuid": "VUID-VkDescriptorImageInfo-imageView-01976", + "text": " If imageView is created from a depth/stencil image, the aspectMask used to create the imageView must include either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT but not both." + }, + { + "vuid": "VUID-VkDescriptorImageInfo-imageLayout-00344", + "text": " imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time this descriptor is accessed" + }, + { + "vuid": "VUID-VkDescriptorImageInfo-commonparent", + "text": " Both of imageView, and sampler that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkDescriptorImageInfo-sampler-01564", + "text": " If sampler is used and the VkFormat of the image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ] + }, + "VkCopyDescriptorSet": { + "core": [ + { + "vuid": "VUID-VkCopyDescriptorSet-srcBinding-00345", + "text": " srcBinding must be a valid binding within srcSet" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcArrayElement-00346", + "text": " The sum of srcArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by srcBinding, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstBinding-00347", + "text": " dstBinding must be a valid binding within dstSet" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstArrayElement-00348", + "text": " The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-00349", + "text": " If srcSet is equal to dstSet, then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-parameter", + "text": " srcSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstSet-parameter", + "text": " dstSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-commonparent", + "text": " Both of dstSet, and srcSet must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-01918", + "text": " If srcSet’s layout was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet’s layout must also have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-01919", + "text": " If srcSet’s layout was created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet’s layout must also have been created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-01920", + "text": " If the descriptor pool from which srcSet was allocated was created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-01921", + "text": " If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set" + } + ] + }, + "vkCreateDescriptorUpdateTemplate": { + "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-vkCreateDescriptorUpdateTemplate-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateDescriptorUpdateTemplate-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorUpdateTemplateCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateDescriptorUpdateTemplate-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDescriptorUpdateTemplate-pDescriptorUpdateTemplate-parameter", + "text": " pDescriptorUpdateTemplate must be a valid pointer to a VkDescriptorUpdateTemplate handle" + } + ] + }, + "VkDescriptorUpdateTemplateCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-pDescriptorUpdateEntries-parameter", + "text": " pDescriptorUpdateEntries must be a valid pointer to an array of descriptorUpdateEntryCount valid VkDescriptorUpdateTemplateEntry structures" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-parameter", + "text": " templateType must be a valid VkDescriptorUpdateTemplateType value" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter", + "text": " If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorUpdateEntryCount-arraylength", + "text": " descriptorUpdateEntryCount must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent", + "text": " Both of descriptorSetLayout, and pipelineLayout that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineLayout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" + } + ] + }, + "VkDescriptorUpdateTemplateEntry": { + "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354", + "text": " dstBinding must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors." + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355", + "text": " dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding implicitly specified when using a descriptor update template to update descriptors, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateEntry-descriptorType-parameter", + "text": " descriptorType must be a valid VkDescriptorType value" + } + ] + }, + "vkDestroyDescriptorUpdateTemplate": { + "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", + "text": " If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357", + "text": " If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter", + "text": " If descriptorUpdateTemplate is not VK_NULL_HANDLE, descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent", + "text": " If descriptorUpdateTemplate is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkUpdateDescriptorSetWithTemplate": { + "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-pData-01685", + "text": " pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate" + }, + { + "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter", + "text": " descriptorSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter", + "text": " descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle" + }, + { + "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent", + "text": " descriptorUpdateTemplate must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdBindDescriptorSets": { + "core": [ + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358", + "text": " Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359", + "text": " dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-firstSet-00360", + "text": " The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361", + "text": " pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01971", + "text": " Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01972", + "text": " Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter", + "text": " pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter", + "text": " If dynamicOffsetCount is not 0, pDynamicOffsets must be a valid pointer to an array of dynamicOffsetCount uint32_t values" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength", + "text": " descriptorSetCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commonparent", + "text": " Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdPushDescriptorSetKHR": { + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363", + "text": " pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00364", + "text": " set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00365", + "text": " set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter", + "text": " pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength", + "text": " descriptorWriteCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-commonparent", + "text": " Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdPushDescriptorSetWithTemplateKHR": { + "(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366", + "text": " The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer’s parent VkCommandPool’s queue family" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686", + "text": " pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplateKHR" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter", + "text": " descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent", + "text": " Each of commandBuffer, descriptorUpdateTemplate, and layout must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdPushConstants": { + "core": [ + { + "vuid": "VUID-vkCmdPushConstants-offset-01795", + "text": " For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage" + }, + { + "vuid": "VUID-vkCmdPushConstants-offset-01796", + "text": " For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range’s VkPushConstantRange::stageFlags" + }, + { + "vuid": "VUID-vkCmdPushConstants-offset-00368", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdPushConstants-size-00369", + "text": " size must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdPushConstants-offset-00370", + "text": " offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize" + }, + { + "vuid": "VUID-vkCmdPushConstants-size-00371", + "text": " size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset" + }, + { + "vuid": "VUID-vkCmdPushConstants-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdPushConstants-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkCmdPushConstants-stageFlags-parameter", + "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdPushConstants-stageFlags-requiredbitmask", + "text": " stageFlags must not be 0" + }, + { + "vuid": "VUID-vkCmdPushConstants-pValues-parameter", + "text": " pValues must be a valid pointer to an array of size bytes" + }, + { + "vuid": "VUID-vkCmdPushConstants-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdPushConstants-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdPushConstants-size-arraylength", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-vkCmdPushConstants-commonparent", + "text": " Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCreateQueryPool": { + "core": [ + { + "vuid": "VUID-vkCreateQueryPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateQueryPool-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkQueryPoolCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateQueryPool-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateQueryPool-pQueryPool-parameter", + "text": " pQueryPool must be a valid pointer to a VkQueryPool handle" + } + ] + }, + "VkQueryPoolCreateInfo": { + "core": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-00791", + "text": " If the &amp;lt;&amp;lt;features-features-pipelineStatisticsQuery,pipeline statistics queries&amp;gt;&amp;gt; feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-00792", + "text": " If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-parameter", + "text": " queryType must be a valid VkQueryType value" + } + ] + }, + "vkDestroyQueryPool": { + "core": [ + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-00793", + "text": " All submitted commands that refer to queryPool must have completed execution" + }, + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-00794", + "text": " If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-00795", + "text": " If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyQueryPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-parameter", + "text": " If queryPool is not VK_NULL_HANDLE, queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkDestroyQueryPool-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-parent", + "text": " If queryPool is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdResetQueryPool": { + "core": [ + { + "vuid": "VUID-vkCmdResetQueryPool-firstQuery-00796", + "text": " firstQuery must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-firstQuery-00797", + "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdBeginQuery": { + "core": [ + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-01922", + "text": " queryPool must have been created with a queryType that differs from that of any queries that are &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt; within commandBuffer" + }, + { + "vuid": "VUID-vkCmdBeginQuery-None-00807", + "text": " All queries used by the command must be unavailable" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00800", + "text": " If the &amp;lt;&amp;lt;features-features-occlusionQueryPrecise,precise occlusion queries&amp;gt;&amp;gt; feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT" + }, + { + "vuid": "VUID-vkCmdBeginQuery-query-00802", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00803", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00804", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00805", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdBeginQuery-flags-parameter", + "text": " flags must be a valid combination of VkQueryControlFlagBits values" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-01885", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdBeginQuery-query-00808", + "text": " If vkCmdBeginQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ] + }, + "vkCmdEndQuery": { + "core": [ + { + "vuid": "VUID-vkCmdEndQuery-None-01923", + "text": " All queries used by the command must be &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdEndQuery-query-00810", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdEndQuery-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdEndQuery-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-01886", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdEndQuery-query-00812", + "text": " If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ] + }, + "vkGetQueryPoolResults": { + "core": [ + { + "vuid": "VUID-vkGetQueryPoolResults-firstQuery-00813", + "text": " firstQuery must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-flags-00814", + "text": " If VK_QUERY_RESULT_64_BIT is not set in flags then pData and stride must be multiples of 4" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-flags-00815", + "text": " If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-firstQuery-00816", + "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-dataSize-00817", + "text": " dataSize must be large enough to contain the result of each query, as described &amp;lt;&amp;lt;queries-operation-memorylayout,here&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-00818", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-pData-parameter", + "text": " pData must be a valid pointer to an array of dataSize bytes" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-flags-parameter", + "text": " flags must be a valid combination of VkQueryResultFlagBits values" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-dataSize-arraylength", + "text": " dataSize must be greater than 0" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryPool-parent", + "text": " queryPool must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdCopyQueryPoolResults": { + "core": [ + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstOffset-00819", + "text": " dstOffset must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-firstQuery-00820", + "text": " firstQuery must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-firstQuery-00821", + "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-00822", + "text": " If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-00823", + "text": " If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824", + "text": " dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described &amp;lt;&amp;lt;queries-operation-memorylayout,here&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-00827", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-parameter", + "text": " flags must be a valid combination of VkQueryResultFlagBits values" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commonparent", + "text": " Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdWriteTimestamp": { + "core": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-queryPool-01416", + "text": " queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-queryPool-00828", + "text": " The query identified by queryPool and query must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-timestampValidBits-00829", + "text": " The command pool’s queue family must support a non-zero timestampValidBits" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-parameter", + "text": " pipelineStage must be a valid VkPipelineStageFlagBits value" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-None-00830", + "text": " All queries used by the command must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-query-00831", + "text": " If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ] + }, + "vkCmdClearColorImage": { + "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdClearColorImage-image-00001", + "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdClearColorImage-image-01935", + "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdClearColorImage-image-00002", + "text": " image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdClearColorImage-image-00003", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-00004", + "text": " imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdClearColorImage-baseMipLevel-01470", + "text": " The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pRanges-01692", + "text": " For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-baseArrayLayer-01472", + "text": " The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pRanges-01693", + "text": " For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-image-00007", + "text": " image must not have a compressed or depth/stencil format" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdClearColorImage-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-parameter", + "text": " imageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pColor-parameter", + "text": " pColor must be a valid pointer to a valid VkClearColorValue union" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pRanges-parameter", + "text": " pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdClearColorImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdClearColorImage-rangeCount-arraylength", + "text": " rangeCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commonparent", + "text": " Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdClearColorImage-image-01545", + "text": " image must not use a format listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-00005", + "text": " imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-01394", + "text": " imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01805", + "text": " If commandBuffer is an unprotected command buffer, then image must not be a protected image" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01806", + "text": " If commandBuffer is a protected command buffer, then image must not be an unprotected image" + } + ] + }, + "vkCmdClearDepthStencilImage": { + "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-00008", + "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-01936", + "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-00009", + "text": " image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-00010", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-00011", + "text": " imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-00012", + "text": " imageLayout must be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474", + "text": " The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-01694", + "text": " For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476", + "text": " The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-01695", + "text": " For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-00014", + "text": " image must have a depth/stencil format" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-parameter", + "text": " imageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter", + "text": " pDepthStencil must be a valid pointer to a valid VkClearDepthStencilValue structure" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-parameter", + "text": " pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength", + "text": " rangeCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commonparent", + "text": " Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01807", + "text": " If commandBuffer is an unprotected command buffer, then image must not be a protected image" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01808", + "text": " If commandBuffer is a protected command buffer, then image must not be an unprotected image" + } + ] + }, + "vkCmdClearAttachments": { + "core": [ + { + "vuid": "VUID-vkCmdClearAttachments-aspectMask-00015", + "text": " If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, the colorAttachment member of that element must refer to a valid color attachment in the current subpass" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pRects-00016", + "text": " The rectangular region specified by each element of pRects must be contained within the render area of the current render pass instance" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pRects-00017", + "text": " The layers specified by each element of pRects must be contained within every attachment that pAttachments refers to" + }, + { + "vuid": "VUID-vkCmdClearAttachments-layerCount-01934", + "text": " The layerCount member of each element of pRects must not be 0" + }, + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pAttachments-parameter", + "text": " pAttachments must be a valid pointer to an array of attachmentCount valid VkClearAttachment structures" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pRects-parameter", + "text": " pRects must be a valid pointer to an array of rectCount VkClearRect structures" + }, + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdClearAttachments-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdClearAttachments-attachmentCount-arraylength", + "text": " attachmentCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdClearAttachments-rectCount-arraylength", + "text": " rectCount must be greater than 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdClearAttachments-baseArrayLayer-00018", + "text": " If the render pass instance this is recorded in uses multiview, then baseArrayLayer must be zero and layerCount must be one." + } + ] + }, + "VkClearAttachment": { + "core": [ + { + "vuid": "VUID-VkClearAttachment-aspectMask-00019", + "text": " If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, it must not include VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkClearAttachment-aspectMask-00020", + "text": " aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT" + }, + { + "vuid": "VUID-VkClearAttachment-clearValue-00021", + "text": " clearValue must be a valid VkClearValue union" + }, + { + "vuid": "VUID-VkClearAttachment-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkClearAttachment-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkClearAttachment-commandBuffer-01809", + "text": " If commandBuffer is an unprotected command buffer, then the attachment to be cleared must not be a protected image." + }, + { + "vuid": "VUID-VkClearAttachment-commandBuffer-01810", + "text": " If commandBuffer is a protected command buffer, then the attachment to be cleared must not be an unprotected image." + } + ] + }, + "VkClearDepthStencilValue": { + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkClearDepthStencilValue-depth-00022", + "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled depth must be between 0.0 and 1.0, inclusive" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkClearDepthStencilValue-depth-00022", + "text": " depth must be between 0.0 and 1.0, inclusive" + } + ] + }, + "VkClearValue": { + "core": [ + { + "vuid": "VUID-VkClearValue-depthStencil-00023", + "text": " depthStencil must be a valid VkClearDepthStencilValue structure" + } + ] + }, + "vkCmdFillBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdFillBuffer-dstOffset-00024", + "text": " dstOffset must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstOffset-00025", + "text": " dstOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdFillBuffer-size-00026", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" + }, + { + "vuid": "VUID-vkCmdFillBuffer-size-00027", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset" + }, + { + "vuid": "VUID-vkCmdFillBuffer-size-00028", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstBuffer-00029", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstBuffer-00031", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations" + }, + { + "vuid": "VUID-vkCmdFillBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commonparent", + "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-00030", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01811", + "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01812", + "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" + } + ] + }, + "vkCmdUpdateBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdUpdateBuffer-dstOffset-00032", + "text": " dstOffset must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00033", + "text": " dataSize must be less than or equal to the size of dstBuffer minus dstOffset" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-00034", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-00035", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstOffset-00036", + "text": " dstOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00037", + "text": " dataSize must be less than or equal to 65536" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00038", + "text": " dataSize must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-pData-parameter", + "text": " pData must be a valid pointer to an array of dataSize bytes" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-arraylength", + "text": " dataSize must be greater than 0" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commonparent", + "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01813", + "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01814", + "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" + } + ] + }, + "vkCmdCopyBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdCopyBuffer-size-00112", + "text": " The size member of each element of pRegions must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-srcOffset-00113", + "text": " The srcOffset member of each element of pRegions must be less than the size of srcBuffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstOffset-00114", + "text": " The dstOffset member of each element of pRegions must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-size-00115", + "text": " The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-size-00116", + "text": " The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-pRegions-00117", + "text": " The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-00118", + "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-00119", + "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-00120", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-00121", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-parameter", + "text": " srcBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount VkBufferCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commonparent", + "text": " Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01822", + "text": " If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01823", + "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01824", + "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" + } + ] + }, + "vkCmdCopyImage": { + "core": [ + { + "vuid": "VUID-vkCmdCopyImage-pRegions-00122", + "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-pRegions-00123", + "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-pRegions-00124", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00126", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-00128", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-00131", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-00133", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00136", + "text": " The sample count of srcImage and dstImage must match" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcSubresource-01696", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstSubresource-01697", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcSubresource-01698", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstSubresource-01699", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcOffset-01783", + "text": " The srcOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstOffset-01784", + "text": " The dstOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00125", + "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-00130", + "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01938", + "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01939", + "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00127", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-00132", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00135", + "text": " The VkFormat of each of srcImage and dstImage must be compatible, as defined &amp;lt;&amp;lt;copies-images-format-compatibility, below&amp;gt;&amp;gt;" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01546", + "text": " If srcImage is non-sparse then the image or disjoint plane to be copied must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01547", + "text": " If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01548", + "text": " If the VkFormat of each of srcImage and dstImage is not a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, the VkFormat of each of srcImage and dstImage must be compatible, as defined &amp;lt;&amp;lt;copies-images-format-compatibility, below&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdCopyImage-None-01549", + "text": " In a copy to or from a plane of a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar image&amp;gt;&amp;gt;, the VkFormat of the image and plane must be compatible according to &amp;lt;&amp;lt;features-formats-compatible-planes,the description of compatible planes&amp;gt;&amp;gt; for the plane being copied" + }, + { + "vuid": "VUID-vkCmdCopyImage-aspectMask-01550", + "text": " When a copy is performed to or from an image with a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, the aspectMask of the srcSubresource and/or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for a VkFormat with three planes)" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-00129", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-00134", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-01917", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-01395", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-01825", + "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-01826", + "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-01827", + "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" + } + ] + }, + "VkImageCopy": { + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageCopy-aspectMask-00137", + "text": " The aspectMask member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageCopy-srcOffset-00157", + "text": " If the calling command’s srcImage is a compressed image, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkImageCopy-extent-00158", + "text": " If the calling command’s srcImage is a compressed image, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width" + }, + { + "vuid": "VUID-VkImageCopy-extent-00159", + "text": " If the calling command’s srcImage is a compressed image, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height" + }, + { + "vuid": "VUID-VkImageCopy-extent-00160", + "text": " If the calling command’s srcImage is a compressed image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth" + }, + { + "vuid": "VUID-VkImageCopy-dstOffset-00162", + "text": " If the calling command’s dstImage is a compressed format image, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkImageCopy-extent-00163", + "text": " If the calling command’s dstImage is a compressed format image, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width" + }, + { + "vuid": "VUID-VkImageCopy-extent-00164", + "text": " If the calling command’s dstImage is a compressed format image, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height" + }, + { + "vuid": "VUID-VkImageCopy-extent-00165", + "text": " If the calling command’s dstImage is a compressed format image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageCopy-srcImage-01551", + "text": " If neither the calling command’s srcImage nor the calling command’s dstImage has a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion, multi-planar image format&amp;gt;&amp;gt; then the aspectMask member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01552", + "text": " If the calling command’s srcImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,two planes&amp;gt;&amp;gt; then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01553", + "text": " If the calling command’s srcImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,three planes&amp;gt;&amp;gt; then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01554", + "text": " If the calling command’s dstImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,two planes&amp;gt;&amp;gt; then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01555", + "text": " If the calling command’s dstImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,three planes&amp;gt;&amp;gt; then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01556", + "text": " If the calling command’s srcImage has a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar image format&amp;gt;&amp;gt; and the dstImage does not have a multi-planar image format, the dstSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01557", + "text": " If the calling command’s dstImage has a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar image format&amp;gt;&amp;gt; and the srcImage does not have a multi-planar image format, the srcSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01727", + "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01728", + "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01729", + "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01730", + "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01731", + "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01732", + "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01733", + "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01734", + "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCopy-layerCount-00138", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-00139", + "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01789", + "text": " If the calling command’s srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then extent.depth must be 1." + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCopy-extent-00140", + "text": " The number of slices of the extent (for 3D) or layers of the srcSubresource (for non-3D) must match the number of slices of the extent (for 3D) or layers of the dstSubresource (for non-3D)" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-00141", + "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of the corresponding subresource must be 0 and 1, respectively" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01790", + "text": " If both srcImage and dstImage are of type VK_IMAGE_TYPE_2D then then extent.depth must be 1." + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01791", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_2D, and the dstImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of srcSubresource." + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01792", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_2D, and the srcImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of dstSubresource." + } + ], + "core": [ + { + "vuid": "VUID-VkImageCopy-aspectMask-00142", + "text": " The aspectMask member of srcSubresource must specify aspects present in the calling command’s srcImage" + }, + { + "vuid": "VUID-VkImageCopy-aspectMask-00143", + "text": " The aspectMask member of dstSubresource must specify aspects present in the calling command’s dstImage" + }, + { + "vuid": "VUID-VkImageCopy-srcOffset-00144", + "text": " srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width" + }, + { + "vuid": "VUID-VkImageCopy-srcOffset-00145", + "text": " srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-00146", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1." + }, + { + "vuid": "VUID-VkImageCopy-srcOffset-00147", + "text": " srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth" + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01785", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.z must be 0 and extent.depth must be 1." + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01786", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.z must be 0 and extent.depth must be 1." + }, + { + "vuid": "VUID-VkImageCopy-srcImage-01787", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_2D, then srcOffset.z must be 0." + }, + { + "vuid": "VUID-VkImageCopy-dstImage-01788", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_2D, then dstOffset.z must be 0." + }, + { + "vuid": "VUID-VkImageCopy-dstOffset-00150", + "text": " dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width" + }, + { + "vuid": "VUID-VkImageCopy-dstOffset-00151", + "text": " dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height" + }, + { + "vuid": "VUID-VkImageCopy-dstImage-00152", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1." + }, + { + "vuid": "VUID-VkImageCopy-dstOffset-00153", + "text": " dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth" + }, + { + "vuid": "VUID-VkImageCopy-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageCopy-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "VkImageSubresourceLayers": { + "core": [ + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-00167", + "text": " If aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-00168", + "text": " aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-layerCount-01700", + "text": " layerCount must be greater than 0" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ] + }, + "vkCmdCopyBufferToImage": { + "core": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00171", + "text": " srcBuffer must be large enough to contain all buffer locations that are accessed according to &amp;lt;&amp;lt;copies-buffers-images-addressing,Buffer and Image Addressing&amp;gt;&amp;gt;, for each element of pRegions" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00172", + "text": " The image region specified by each element of pRegions must be a region that is contained within dstImage" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00173", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-00174", + "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-00176", + "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00177", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00178", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00179", + "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageSubresource-01701", + "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageSubresource-01702", + "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-01793", + "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-parameter", + "text": " srcBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00175", + "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-01940", + "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-00181", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-01396", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01828", + "text": " If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01829", + "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01830", + "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" + } + ] + }, + "vkCmdCopyImageToBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00182", + "text": " The image region specified by each element of pRegions must be a region that is contained within srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00183", + "text": " dstBuffer must be large enough to contain all buffer locations that are accessed according to &amp;lt;&amp;lt;copies-buffers-images-addressing,Buffer and Image Addressing&amp;gt;&amp;gt;, for each element of pRegions" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00184", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00186", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00187", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00188", + "text": " srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-00192", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703", + "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704", + "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-01794", + "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commonparent", + "text": " Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00185", + "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-01941", + "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01831", + "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01832", + "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01833", + "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" + } + ] + }, + "VkBufferImageCopy": { + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBufferImageCopy-bufferOffset-00193", + "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format, then bufferOffset must be a multiple of the format’s element size" + }, + { + "vuid": "VUID-VkBufferImageCopy-bufferRowLength-00203", + "text": " If the calling command’s VkImage parameter is a compressed image, bufferRowLength must be a multiple of the compressed texel block width" + }, + { + "vuid": "VUID-VkBufferImageCopy-bufferImageHeight-00204", + "text": " If the calling command’s VkImage parameter is a compressed image, bufferImageHeight must be a multiple of the compressed texel block height" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageOffset-00205", + "text": " If the calling command’s VkImage parameter is a compressed image, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkBufferImageCopy-bufferOffset-00206", + "text": " If the calling command’s VkImage parameter is a compressed image, bufferOffset must be a multiple of the compressed texel block size in bytes" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageExtent-00207", + "text": " If the calling command’s VkImage parameter is a compressed image, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageExtent-00208", + "text": " If the calling command’s VkImage parameter is a compressed image, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageExtent-00209", + "text": " If the calling command’s VkImage parameter is a compressed image, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBufferImageCopy-bufferOffset-01558", + "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format or a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, then bufferOffset must be a multiple of the format’s element size" + }, + { + "vuid": "VUID-VkBufferImageCopy-bufferOffset-01559", + "text": " If the calling command’s VkImage parameter’s format is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, then bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in &amp;lt;&amp;lt;features-formats-compatible-planes&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-01735", + "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferRowLength must be a multiple of the compressed texel block width" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-01736", + "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferImageHeight must be a multiple of the compressed texel block height" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-01737", + "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-01738", + "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferOffset must be a multiple of the compressed texel block size in bytes" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-01739", + "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-01740", + "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-01741", + "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth" + }, + { + "vuid": "VUID-VkBufferImageCopy-aspectMask-01560", + "text": " If the calling command’s VkImage parameter’s format is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, then the aspectMask member of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)" + } + ], + "core": [ + { + "vuid": "VUID-VkBufferImageCopy-bufferOffset-00194", + "text": " bufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-VkBufferImageCopy-bufferRowLength-00195", + "text": " bufferRowLength must be 0, or greater than or equal to the width member of imageExtent" + }, + { + "vuid": "VUID-VkBufferImageCopy-bufferImageHeight-00196", + "text": " bufferImageHeight must be 0, or greater than or equal to the height member of imageExtent" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageOffset-00197", + "text": " imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the image subresource width" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageOffset-00198", + "text": " imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the image subresource height" + }, + { + "vuid": "VUID-VkBufferImageCopy-srcImage-00199", + "text": " If the calling command’s srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D, then imageOffset.y must be 0 and imageExtent.height must be 1." + }, + { + "vuid": "VUID-VkBufferImageCopy-imageOffset-00200", + "text": " imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the image subresource depth" + }, + { + "vuid": "VUID-VkBufferImageCopy-srcImage-00201", + "text": " If the calling command’s srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then imageOffset.z must be 0 and imageExtent.depth must be 1" + }, + { + "vuid": "VUID-VkBufferImageCopy-aspectMask-00211", + "text": " The aspectMask member of imageSubresource must specify aspects present in the calling command’s VkImage parameter" + }, + { + "vuid": "VUID-VkBufferImageCopy-aspectMask-00212", + "text": " The aspectMask member of imageSubresource must only have a single bit set" + }, + { + "vuid": "VUID-VkBufferImageCopy-baseArrayLayer-00213", + "text": " If the calling command’s VkImage parameter is of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of imageSubresource must be 0 and 1, respectively" + }, + { + "vuid": "VUID-VkBufferImageCopy-None-00214", + "text": " When copying to the depth aspect of an image subresource, the data in the source buffer must be in the range [0,1]" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageSubresource-parameter", + "text": " imageSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdBlitImage": { + "core": [ + { + "vuid": "VUID-vkCmdBlitImage-pRegions-00215", + "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-pRegions-00216", + "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-pRegions-00217", + "text": " The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00219", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00220", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-00221", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00224", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00225", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-00226", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00228", + "text": " The sample count of srcImage and dstImage must both be equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00229", + "text": " If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00230", + "text": " If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00231", + "text": " If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00232", + "text": " If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00233", + "text": " srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00234", + "text": " dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcSubresource-01705", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstSubresource-01706", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcSubresource-01707", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstSubresource-01708", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdBlitImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageBlit structures" + }, + { + "vuid": "VUID-vkCmdBlitImage-filter-parameter", + "text": " filter must be a valid VkFilter value" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBlitImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdBlitImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBlitImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00218", + "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_BLIT_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00223", + "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_BLIT_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + }, + { + "vuid": "VUID-vkCmdBlitImage-filter-00235", + "text": " If filter is VK_FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImage-01942", + "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-01943", + "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + }, + { + "vuid": "VUID-vkCmdBlitImage-filter-01944", + "text": " If filter is VK_FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImage-01561", + "text": " srcImage must not use a format listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-01562", + "text": " dstImage must not use a format listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-00222", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-00227", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-01398", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-01399", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdBlitImage-filter-00236", + "text": " If filter is VK_FILTER_CUBIC_IMG, srcImage must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdBlitImage-filter-01945", + "text": " If filter is VK_FILTER_CUBIC_IMG, srcImage must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned byvkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdBlitImage-filter-00237", + "text": " If filter is VK_FILTER_CUBIC_IMG, srcImage must have a VkImageType of VK_IMAGE_TYPE_2D" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-01834", + "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-01835", + "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-01836", + "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" + } + ] + }, + "VkImageBlit": { + "core": [ + { + "vuid": "VUID-VkImageBlit-aspectMask-00238", + "text": " The aspectMask member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageBlit-layerCount-00239", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageBlit-srcImage-00240", + "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively" + }, + { + "vuid": "VUID-VkImageBlit-aspectMask-00241", + "text": " The aspectMask member of srcSubresource must specify aspects present in the calling command’s srcImage" + }, + { + "vuid": "VUID-VkImageBlit-aspectMask-00242", + "text": " The aspectMask member of dstSubresource must specify aspects present in the calling command’s dstImage" + }, + { + "vuid": "VUID-VkImageBlit-srcOffset-00243", + "text": " srcOffset[0].x and srcOffset[1].x must both be greater than or equal to 0 and less than or equal to the source image subresource width" + }, + { + "vuid": "VUID-VkImageBlit-srcOffset-00244", + "text": " srcOffset[0].y and srcOffset[1].y must both be greater than or equal to 0 and less than or equal to the source image subresource height" + }, + { + "vuid": "VUID-VkImageBlit-srcImage-00245", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset[0].y must be 0 and srcOffset[1].y must be 1." + }, + { + "vuid": "VUID-VkImageBlit-srcOffset-00246", + "text": " srcOffset[0].z and srcOffset[1].z must both be greater than or equal to 0 and less than or equal to the source image subresource depth" + }, + { + "vuid": "VUID-VkImageBlit-srcImage-00247", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset[0].z must be 0 and srcOffset[1].z must be 1." + }, + { + "vuid": "VUID-VkImageBlit-dstOffset-00248", + "text": " dstOffset[0].x and dstOffset[1].x must both be greater than or equal to 0 and less than or equal to the destination image subresource width" + }, + { + "vuid": "VUID-VkImageBlit-dstOffset-00249", + "text": " dstOffset[0].y and dstOffset[1].y must both be greater than or equal to 0 and less than or equal to the destination image subresource height" + }, + { + "vuid": "VUID-VkImageBlit-dstImage-00250", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset[0].y must be 0 and dstOffset[1].y must be 1." + }, + { + "vuid": "VUID-VkImageBlit-dstOffset-00251", + "text": " dstOffset[0].z and dstOffset[1].z must both be greater than or equal to 0 and less than or equal to the destination image subresource depth" + }, + { + "vuid": "VUID-VkImageBlit-dstImage-00252", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset[0].z must be 0 and dstOffset[1].z must be 1." + }, + { + "vuid": "VUID-VkImageBlit-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageBlit-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdResolveImage": { + "core": [ + { + "vuid": "VUID-vkCmdResolveImage-pRegions-00253", + "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-pRegions-00254", + "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-pRegions-00255", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-00256", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-00257", + "text": " srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00258", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00259", + "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-00260", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-00262", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00264", + "text": " If dstImage was created with tiling equal to VK_IMAGE_TILING_LINEAR, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00265", + "text": " If dstImage was created with tiling equal to VK_IMAGE_TILING_OPTIMAL, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-01386", + "text": " srcImage and dstImage must have been created with the same image format" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcSubresource-01709", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstSubresource-01710", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcSubresource-01711", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstSubresource-01712", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdResolveImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageResolve structures" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdResolveImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdResolveImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdResolveImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-00261", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-00263", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-01400", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-01401", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-01837", + "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-01838", + "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-01839", + "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" + } + ] + }, + "VkImageResolve": { + "core": [ + { + "vuid": "VUID-VkImageResolve-aspectMask-00266", + "text": " The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageResolve-layerCount-00267", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageResolve-srcImage-00268", + "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively" + }, + { + "vuid": "VUID-VkImageResolve-srcOffset-00269", + "text": " srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width" + }, + { + "vuid": "VUID-VkImageResolve-srcOffset-00270", + "text": " srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height" + }, + { + "vuid": "VUID-VkImageResolve-srcImage-00271", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1." + }, + { + "vuid": "VUID-VkImageResolve-srcOffset-00272", + "text": " srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth" + }, + { + "vuid": "VUID-VkImageResolve-srcImage-00273", + "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset.z must be 0 and extent.depth must be 1." + }, + { + "vuid": "VUID-VkImageResolve-dstOffset-00274", + "text": " dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width" + }, + { + "vuid": "VUID-VkImageResolve-dstOffset-00275", + "text": " dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height" + }, + { + "vuid": "VUID-VkImageResolve-dstImage-00276", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1." + }, + { + "vuid": "VUID-VkImageResolve-dstOffset-00277", + "text": " dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth" + }, + { + "vuid": "VUID-VkImageResolve-dstImage-00278", + "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset.z must be 0 and extent.depth must be 1." + }, + { + "vuid": "VUID-VkImageResolve-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageResolve-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdWriteBufferMarkerAMD": { + "(VK_AMD_buffer_marker)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798", + "text": " dstOffset must be less than or equal to the size of dstBuffer minus 4." + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801", + "text": " dstOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter", + "text": " pipelineStage must be a valid VkPipelineStageFlagBits value" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commonparent", + "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkPipelineInputAssemblyStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428", + "text": " If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, primitiveRestartEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429", + "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, topology must not be any of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430", + "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, topology must not be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter", + "text": " topology must be a valid VkPrimitiveTopology value" + } + ] + }, + "vkCmdBindIndexBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdBindIndexBuffer-offset-00431", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-offset-00432", + "text": " The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-buffer-00433", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-buffer-00434", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-indexType-parameter", + "text": " indexType must be a valid VkIndexType value" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdDraw": { + "core": [ + { + "vuid": "VUID-vkCmdDraw-renderPass-00435", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDraw-subpass-00436", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDraw-None-00437", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDraw-None-00438", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDraw-None-00439", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDraw-None-00440", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDraw-None-00441", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDraw-None-00442", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDraw-None-00443", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDraw-None-00444", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDraw-None-00445", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-00446", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-00447", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-00448", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDraw-None-00449", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDraw-None-01499", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDraw-renderpass", + "text": " This command must only be called inside of a render pass instance" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDraw-linearTilingFeatures-00450", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDraw-formatFeatures-01953", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDraw-linearTilingFeatures-00451", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDraw-formatFeatures-01954", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDraw-None-00452", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDraw-maxMultiviewInstanceIndex-00453", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDraw-commandBuffer-01850", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-01851", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-01852", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDraw-sampleLocationsEnable-01512", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "vkCmdDrawIndexed": { + "core": [ + { + "vuid": "VUID-vkCmdDrawIndexed-renderPass-00454", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexed-subpass-00455", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00456", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00457", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00458", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00459", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00460", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00461", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00462", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-indexSize-00463", + "text": " (indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00464", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00465", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00466", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00467", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00468", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-00469", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-01500", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-renderpass", + "text": " This command must only be called inside of a render pass instance" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-linearTilingFeatures-00470", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-formatFeatures-01955", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-linearTilingFeatures-00471", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-formatFeatures-01956", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-00472", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-00473", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-01853", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-01854", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-01855", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-sampleLocationsEnable-01513", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "vkCmdDrawIndirect": { + "core": [ + { + "vuid": "VUID-vkCmdDrawIndirect-buffer-00474", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-buffer-01660", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-offset-00475", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00476", + "text": " If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00477", + "text": " If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-firstInstance-00478", + "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-renderPass-00479", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndirect-subpass-00480", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00481", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00482", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00483", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00484", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00485", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00486", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00487", + "text": " If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00488", + "text": " If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00489", + "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00490", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00491", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00492", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00493", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00494", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-00495", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-01501", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-linearTilingFeatures-00496", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-formatFeatures-01957", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-linearTilingFeatures-00497", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-formatFeatures-01958", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-00498", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-00499", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-01856", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-01857", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-01858", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-sampleLocationsEnable-01514", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "VkDrawIndirectCommand": { + "core": [ + { + "vuid": "VUID-VkDrawIndirectCommand-None-00500", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkDrawIndirectCommand-firstInstance-00501", + "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, firstInstance must be 0" + } + ] + }, + "vkCmdDrawIndirectCountKHR": { + "(VK_KHR_draw_indirect_count)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-buffer-03104", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-buffer-03105", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03106", + "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03107", + "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-offset-03108", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBufferOffset-03109", + "text": " countBufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-stride-03110", + "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-maxDrawCount-03111", + "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-firstInstance-03112", + "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-renderPass-03113", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-subpass-03114", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03115", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03116", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03117", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03118", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03119", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03120", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03121", + "text": " If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03122", + "text": " If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03123", + "text": " The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03124", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03125", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03126", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03127", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03128", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03129", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-linearTilingFeatures-03130", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03131", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-parameter", + "text": " countBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-commonparent", + "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-linearTilingFeatures-03169", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03170", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-maxMultiviewInstanceIndex-03132", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-03133", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-03134", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-03135", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountKHR-sampleLocationsEnable-03171", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "vkCmdDrawIndirectCountAMD": { + "(VK_AMD_draw_indirect_count)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-buffer-01661", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-buffer-01662", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-01663", + "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-01664", + "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-offset-00502", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBufferOffset-00503", + "text": " countBufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-stride-00504", + "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-maxDrawCount-00505", + "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-firstInstance-00506", + "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-renderPass-00507", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-subpass-00508", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00509", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00510", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00511", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00512", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00513", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00514", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-00515", + "text": " If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-00516", + "text": " If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-00517", + "text": " The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00518", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00519", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00520", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00521", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00522", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00523", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-01502", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-parameter", + "text": " countBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-commonparent", + "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_AMD_draw_indirect_count)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-linearTilingFeatures-00524", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_AMD_draw_indirect_count)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-formatFeatures-01959", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-maxMultiviewInstanceIndex-00525", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01859", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01860", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01861", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_AMD_draw_indirect_count)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCountAMD-sampleLocationsEnable-01515", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "vkCmdDrawIndexedIndirect": { + "core": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-00526", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-01665", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-offset-00527", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00528", + "text": " If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00529", + "text": " If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-firstInstance-00530", + "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-renderPass-00531", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-subpass-00532", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00533", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00534", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00535", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00536", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00537", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00538", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00539", + "text": " If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00540", + "text": " If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00541", + "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00542", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00543", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00544", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00545", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00546", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00547", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-01503", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00548", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-formatFeatures-01960", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00549", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-formatFeatures-01961", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00550", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-00551", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-01862", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-01863", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-01864", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-01516", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "VkDrawIndexedIndirectCommand": { + "core": [ + { + "vuid": "VUID-VkDrawIndexedIndirectCommand-None-00552", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkDrawIndexedIndirectCommand-indexSize-00553", + "text": " (indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer" + }, + { + "vuid": "VUID-VkDrawIndexedIndirectCommand-firstInstance-00554", + "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, firstInstance must be 0" + } + ] + }, + "vkCmdDrawIndexedIndirectCountKHR": { + "(VK_KHR_draw_indirect_count)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-03136", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-03137", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03138", + "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03139", + "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-offset-03140", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBufferOffset-03141", + "text": " countBufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-stride-03142", + "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-maxDrawCount-03143", + "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-firstInstance-03144", + "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-renderPass-03145", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-subpass-03146", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03147", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03148", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03149", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03150", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03151", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03152", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03153", + "text": " If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03154", + "text": " If count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-drawCount-03155", + "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03156", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03157", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03158", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03159", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03160", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03161", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-linearTilingFeatures-03162", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03163", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-parameter", + "text": " countBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent", + "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-linearTilingFeatures-03172", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03173", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-maxMultiviewInstanceIndex-03164", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-03165", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-03166", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-03167", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-sampleLocationsEnable-03174", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "vkCmdDrawIndexedIndirectCountAMD": { + "(VK_AMD_draw_indirect_count)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01666", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01667", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01668", + "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01669", + "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-offset-00555", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBufferOffset-00556", + "text": " countBufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-stride-00557", + "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-maxDrawCount-00558", + "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-firstInstance-00559", + "text": " If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-renderPass-00560", + "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-subpass-00561", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00562", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00563", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00564", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00565", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00566", + "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00567", + "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00568", + "text": " If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00569", + "text": " If count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-drawCount-00570", + "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00571", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00572", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00573", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00574", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00575", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00576", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-01504", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-parameter", + "text": " countBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commonparent", + "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_AMD_draw_indirect_count)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-linearTilingFeatures-00577", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_AMD_draw_indirect_count)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-formatFeatures-01962", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-maxMultiviewInstanceIndex-00578", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." + } + ], + "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01865", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01866", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01867", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ], + "(VK_AMD_draw_indirect_count)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-sampleLocationsEnable-01517", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ] + }, + "VkPipelineVertexInputStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613", + "text": " vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614", + "text": " vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-binding-00615", + "text": " For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription must exist in pVertexBindingDescriptions with the same value of binding" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616", + "text": " All elements of pVertexBindingDescriptions must describe distinct binding numbers" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617", + "text": " All elements of pVertexAttributeDescriptions must describe distinct attribute locations" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineVertexInputDivisorStateCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter", + "text": " If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription structures" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter", + "text": " If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription structures" + } + ] + }, + "VkVertexInputBindingDescription": { + "core": [ + { + "vuid": "VUID-VkVertexInputBindingDescription-binding-00618", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription-stride-00619", + "text": " stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription-inputRate-parameter", + "text": " inputRate must be a valid VkVertexInputRate value" + } + ] + }, + "VkVertexInputAttributeDescription": { + "core": [ + { + "vuid": "VUID-VkVertexInputAttributeDescription-location-00620", + "text": " location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-binding-00621", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-offset-00622", + "text": " offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-format-00623", + "text": " format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-format-parameter", + "text": " format must be a valid VkFormat value" + } + ] + }, + "vkCmdBindVertexBuffers": { + "core": [ + { + "vuid": "VUID-vkCmdBindVertexBuffers-firstBinding-00624", + "text": " firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-firstBinding-00625", + "text": " The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pOffsets-00626", + "text": " All elements of pOffsets must be less than the size of the corresponding element in pBuffers" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-00627", + "text": " All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-00628", + "text": " Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-parameter", + "text": " pBuffers must be a valid pointer to an array of bindingCount valid VkBuffer handles" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pOffsets-parameter", + "text": " pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-bindingCount-arraylength", + "text": " bindingCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commonparent", + "text": " Both of commandBuffer, and the elements of pBuffers must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkPipelineVertexInputDivisorStateCreateInfoEXT": { + "(VK_EXT_vertex_attribute_divisor)": [ + { + "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter", + "text": " pVertexBindingDivisors must be a valid pointer to an array of vertexBindingDivisorCount VkVertexInputBindingDivisorDescriptionEXT structures" + }, + { + "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength", + "text": " vertexBindingDivisorCount must be greater than 0" + } + ] + }, + "VkVertexInputBindingDivisorDescriptionEXT": { + "(VK_EXT_vertex_attribute_divisor)": [ + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870", + "text": " divisor must be a value between 0 and VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive." + }, + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871", + "text": " VkVertexInputBindingDescription::inputRate must be of type VK_VERTEX_INPUT_RATE_INSTANCE for this binding." + } + ] + }, + "VkPipelineTessellationStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214", + "text": " patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" + }, + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineTessellationDomainOriginStateCreateInfo" + }, + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "VkPipelineTessellationDomainOriginStateCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter", + "text": " domainOrigin must be a valid VkTessellationDomainOrigin value" + } + ] + }, + "VkPipelineViewportSwizzleStateCreateInfoNV": { + "(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215", + "text": " viewportCount must match the viewportCount set in VkPipelineViewportStateCreateInfo" + }, + { + "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV" + }, + { + "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + } + ] + }, + "VkViewportSwizzleNV": { + "(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-VkViewportSwizzleNV-x-parameter", + "text": " x must be a valid VkViewportCoordinateSwizzleNV value" + }, + { + "vuid": "VUID-VkViewportSwizzleNV-y-parameter", + "text": " y must be a valid VkViewportCoordinateSwizzleNV value" + }, + { + "vuid": "VUID-VkViewportSwizzleNV-z-parameter", + "text": " z must be a valid VkViewportCoordinateSwizzleNV value" + }, + { + "vuid": "VUID-VkViewportSwizzleNV-w-parameter", + "text": " w must be a valid VkViewportCoordinateSwizzleNV value" + } + ] + }, + "VkPipelineViewportWScalingStateCreateInfoNV": { + "(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV" + }, + { + "vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + } + ] + }, + "vkCmdSetViewportWScalingNV": { + "(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-None-01322", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-firstViewport-01323", + "text": " firstViewport must be less than VkPhysicalDeviceLimits::maxViewports" + }, + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-firstViewport-01324", + "text": " The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-pViewportWScalings-parameter", + "text": " pViewportWScalings must be a valid pointer to an array of viewportCount VkViewportWScalingNV structures" + }, + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + } + ] + }, + "VkPipelineViewportStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216", + "text": " If the multiple viewports feature is not enabled, viewportCount must be 1" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217", + "text": " If the multiple viewports feature is not enabled, scissorCount must be 1" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218", + "text": " viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219", + "text": " scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220", + "text": " scissorCount and viewportCount must be identical" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineViewportSwizzleStateCreateInfoNV or VkPipelineViewportWScalingStateCreateInfoNV" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength", + "text": " scissorCount must be greater than 0" + } + ], + "(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726", + "text": " If the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure chained to the pNext chain is VK_TRUE, the viewportCount member of the VkPipelineViewportWScalingStateCreateInfoNV structure must be equal to viewportCount" + } + ] + }, + "vkCmdSetViewport": { + "core": [ + { + "vuid": "VUID-vkCmdSetViewport-None-01221", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetViewport-firstViewport-01222", + "text": " firstViewport must be less than VkPhysicalDeviceLimits::maxViewports" + }, + { + "vuid": "VUID-vkCmdSetViewport-firstViewport-01223", + "text": " The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetViewport-firstViewport-01224", + "text": " If the multiple viewports feature is not enabled, firstViewport must be 0" + }, + { + "vuid": "VUID-vkCmdSetViewport-viewportCount-01225", + "text": " If the multiple viewports feature is not enabled, viewportCount must be 1" + }, + { + "vuid": "VUID-vkCmdSetViewport-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetViewport-pViewports-parameter", + "text": " pViewports must be a valid pointer to an array of viewportCount VkViewport structures" + }, + { + "vuid": "VUID-vkCmdSetViewport-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetViewport-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetViewport-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + } + ] + }, + "VkViewport": { + "core": [ + { + "vuid": "VUID-VkViewport-width-01770", + "text": " width must be greater than 0.0" + }, + { + "vuid": "VUID-VkViewport-width-01771", + "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]" + }, + { + "vuid": "VUID-VkViewport-height-01773", + "text": " The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]" + }, + { + "vuid": "VUID-VkViewport-x-01774", + "text": " x must be greater than or equal to viewportBoundsRange[0]" + }, + { + "vuid": "VUID-VkViewport-x-01232", + "text": " (x + width) must be less than or equal to viewportBoundsRange[1]" + }, + { + "vuid": "VUID-VkViewport-y-01775", + "text": " y must be greater than or equal to viewportBoundsRange[0]" + }, + { + "vuid": "VUID-VkViewport-y-01233", + "text": " (y + height) must be less than or equal to viewportBoundsRange[1]" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)": [ + { + "vuid": "VUID-VkViewport-height-01772", + "text": " height must be greater than 0.0" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)": [ + { + "vuid": "VUID-VkViewport-y-01776", + "text": " y must be less than or equal to viewportBoundsRange[1]" + }, + { + "vuid": "VUID-VkViewport-y-01777", + "text": " (y + height) must be greater than or equal to viewportBoundsRange[0]" + } + ], + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkViewport-minDepth-01234", + "text": " Unless VK_EXT_depth_range_unrestricted extension is enabled minDepth must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-VkViewport-maxDepth-01235", + "text": " Unless VK_EXT_depth_range_unrestricted extension is enabled maxDepth must be between 0.0 and 1.0, inclusive" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkViewport-minDepth-01234", + "text": " minDepth must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-VkViewport-maxDepth-01235", + "text": " maxDepth must be between 0.0 and 1.0, inclusive" + } + ] + }, + "VkPipelineRasterizationStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782", + "text": " If the &amp;lt;&amp;lt;features-features-depthClamp,depth clamping&amp;gt;&amp;gt; feature is not enabled, depthClampEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT or VkPipelineRasterizationStateRasterizationOrderAMD" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter", + "text": " polygonMode must be a valid VkPolygonMode value" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter", + "text": " cullMode must be a valid combination of VkCullModeFlagBits values" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter", + "text": " frontFace must be a valid VkFrontFace value" + } + ], + "!(VK_NV_fill_rectangle)": [ + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413", + "text": " If the &amp;lt;&amp;lt;features-features-fillModeNonSolid,non-solid fill modes&amp;gt;&amp;gt; feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL" + } + ], + "(VK_NV_fill_rectangle)": [ + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", + "text": " If the &amp;lt;&amp;lt;features-features-fillModeNonSolid,non-solid fill modes&amp;gt;&amp;gt; feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414", + "text": " If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV" + } + ] + }, + "VkPipelineMultisampleStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784", + "text": " If the &amp;lt;&amp;lt;features-features-sampleRateShading,sample rate shading&amp;gt;&amp;gt; feature is not enabled, sampleShadingEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785", + "text": " If the &amp;lt;&amp;lt;features-features-alphaToOne,alpha to one&amp;gt;&amp;gt; feature is not enabled, alphaToOneEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786", + "text": " minSampleShading must be in the range [0,1]" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, or VkPipelineSampleLocationsStateCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter", + "text": " rasterizationSamples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter", + "text": " If pSampleMask is not NULL, pSampleMask must be a valid pointer to an array of \\(\\lceil{\\mathit{rasterizationSamples} \\over 32}\\rceil\\) VkSampleMask values" + } + ], + "(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415", + "text": " If the subpass has any color attachments and rasterizationSamples is greater than the number of color samples, then sampleShadingEnable must be VK_FALSE" + } + ] + }, + "VkPipelineRasterizationStateRasterizationOrderAMD": { + "(VK_AMD_rasterization_order)": [ + { + "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter", + "text": " rasterizationOrder must be a valid VkRasterizationOrderAMD value" + } + ] + }, + "VkPipelineSampleLocationsStateCreateInfoEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter", + "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" + } + ] + }, + "VkSampleLocationsInfoEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526", + "text": " sampleLocationsPerPixel must be a bit value that is set in VkPhysicalDeviceSampleLocationsPropertiesEXT::sampleLocationSampleCounts" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527", + "text": " sampleLocationsCount must equal sampleLocationsPerPixel {times} sampleLocationGridSize.width {times} sampleLocationGridSize.height" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter", + "text": " sampleLocationsPerPixel must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter", + "text": " pSampleLocations must be a valid pointer to an array of sampleLocationsCount VkSampleLocationEXT structures" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength", + "text": " sampleLocationsCount must be greater than 0" + } + ] + }, + "vkCmdSetSampleLocationsEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-None-01528", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529", + "text": " The sampleLocationsPerPixel member of pSampleLocationsInfo must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530", + "text": " If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE then the current render pass must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sample locations state pointed to by pSampleLocationsInfo" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter", + "text": " pSampleLocationsInfo must be a valid pointer to a valid VkSampleLocationsInfoEXT structure" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetLineWidth": { + "core": [ + { + "vuid": "VUID-vkCmdSetLineWidth-None-00787", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetLineWidth-lineWidth-00788", + "text": " If the wide lines feature is not enabled, lineWidth must be 1.0" + }, + { + "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetDepthBias": { + "core": [ + { + "vuid": "VUID-vkCmdSetDepthBias-None-00789", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetDepthBias-depthBiasClamp-00790", + "text": " If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0" + }, + { + "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineRasterizationConservativeStateCreateInfoEXT": { + "(VK_EXT_conservative_rasterization)": [ + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769", + "text": " extraPrimitiveOverestimationSize must be in the range of 0.0 to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive" + }, + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter", + "text": " conservativeRasterizationMode must be a valid VkConservativeRasterizationModeEXT value" + } + ] + }, + "VkPipelineDiscardRectangleStateCreateInfoEXT": { + "(VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582", + "text": " discardRectangleCount must be between 0 and VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles, inclusive" + }, + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter", + "text": " discardRectangleMode must be a valid VkDiscardRectangleModeEXT value" + } + ] + }, + "vkCmdSetDiscardRectangleEXT": { + "(VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-None-00583", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585", + "text": " The sum of firstDiscardRectangle and discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-x-00587", + "text": " The x and y member of offset in each VkRect2D element of pDiscardRectangles must be greater than or equal to 0" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-offset-00588", + "text": " Evaluation of (offset.x + extent.width) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-offset-00589", + "text": " Evaluation of (offset.y + extent.height) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter", + "text": " pDiscardRectangles must be a valid pointer to an array of discardRectangleCount VkRect2D structures" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength", + "text": " discardRectangleCount must be greater than 0" + } + ] + }, + "vkCmdSetScissor": { + "core": [ + { + "vuid": "VUID-vkCmdSetScissor-None-00590", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetScissor-firstScissor-00591", + "text": " firstScissor must be less than VkPhysicalDeviceLimits::maxViewports" + }, + { + "vuid": "VUID-vkCmdSetScissor-firstScissor-00592", + "text": " The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetScissor-firstScissor-00593", + "text": " If the multiple viewports feature is not enabled, firstScissor must be 0" + }, + { + "vuid": "VUID-vkCmdSetScissor-scissorCount-00594", + "text": " If the multiple viewports feature is not enabled, scissorCount must be 1" + }, + { + "vuid": "VUID-vkCmdSetScissor-x-00595", + "text": " The x and y members of offset must be greater than or equal to 0" + }, + { + "vuid": "VUID-vkCmdSetScissor-offset-00596", + "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow" + }, + { + "vuid": "VUID-vkCmdSetScissor-offset-00597", + "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow" + }, + { + "vuid": "VUID-vkCmdSetScissor-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetScissor-pScissors-parameter", + "text": " pScissors must be a valid pointer to an array of scissorCount VkRect2D structures" + }, + { + "vuid": "VUID-vkCmdSetScissor-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetScissor-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetScissor-scissorCount-arraylength", + "text": " scissorCount must be greater than 0" + } + ] + }, + "VkPipelineDepthStencilStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598", + "text": " If the &amp;lt;&amp;lt;features-features-depthBounds,depth bounds testing&amp;gt;&amp;gt; feature is not enabled, depthBoundsTestEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter", + "text": " depthCompareOp must be a valid VkCompareOp value" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter", + "text": " front must be a valid VkStencilOpState structure" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter", + "text": " back must be a valid VkStencilOpState structure" + } + ] + }, + "vkCmdSetDepthBounds": { + "core": [ + { + "vuid": "VUID-vkCmdSetDepthBounds-None-00599", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ], + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-00600", + "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-00601", + "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled maxDepthBounds must be between 0.0 and 1.0, inclusive" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-00600", + "text": " minDepthBounds must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-00601", + "text": " maxDepthBounds must be between 0.0 and 1.0, inclusive" + } + ] + }, + "VkStencilOpState": { + "core": [ + { + "vuid": "VUID-VkStencilOpState-failOp-parameter", + "text": " failOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-VkStencilOpState-passOp-parameter", + "text": " passOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-VkStencilOpState-depthFailOp-parameter", + "text": " depthFailOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-VkStencilOpState-compareOp-parameter", + "text": " compareOp must be a valid VkCompareOp value" + } + ] + }, + "vkCmdSetStencilCompareMask": { + "core": [ + { + "vuid": "VUID-vkCmdSetStencilCompareMask-None-00602", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-faceMask-parameter", + "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask", + "text": " faceMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetStencilWriteMask": { + "core": [ + { + "vuid": "VUID-vkCmdSetStencilWriteMask-None-00603", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-faceMask-parameter", + "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask", + "text": " faceMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetStencilReference": { + "core": [ + { + "vuid": "VUID-vkCmdSetStencilReference-None-00604", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-faceMask-parameter", + "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-faceMask-requiredbitmask", + "text": " faceMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineCoverageToColorStateCreateInfoNV": { + "(VK_NV_fragment_coverage_to_color)": [ + { + "vuid": "VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404", + "text": " If coverageToColorEnable is VK_TRUE, then the render pass subpass indicated by VkGraphicsPipelineCreateInfo::renderPass and VkGraphicsPipelineCreateInfo::subpass must have a color attachment at the location selected by coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" + }, + { + "vuid": "VUID-VkPipelineCoverageToColorStateCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV" + }, + { + "vuid": "VUID-VkPipelineCoverageToColorStateCreateInfoNV-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "VkPipelineCoverageModulationStateCreateInfoNV": { + "(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405", + "text": " If coverageModulationTableEnable is VK_TRUE, coverageModulationTableCount must be equal to the number of rasterization samples divided by the number of color samples in the subpass." + }, + { + "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV" + }, + { + "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter", + "text": " coverageModulationMode must be a valid VkCoverageModulationModeNV value" + }, + { + "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableCount-arraylength", + "text": " coverageModulationTableCount must be greater than 0" + } + ] + }, + "VkPipelineColorBlendStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605", + "text": " If the &amp;lt;&amp;lt;features-features-independentBlend,independent blending&amp;gt;&amp;gt; feature is not enabled, all elements of pAttachments must be identical" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606", + "text": " If the &amp;lt;&amp;lt;features-features-logicOp,logic operations&amp;gt;&amp;gt; feature is not enabled, logicOpEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607", + "text": " If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter", + "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures" + } + ] + }, + "VkPipelineColorBlendAttachmentState": { + "core": [ + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608", + "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609", + "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, dstColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610", + "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, srcAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611", + "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, dstAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter", + "text": " srcColorBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter", + "text": " dstColorBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter", + "text": " colorBlendOp must be a valid VkBlendOp value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter", + "text": " srcAlphaBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter", + "text": " dstAlphaBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter", + "text": " alphaBlendOp must be a valid VkBlendOp value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter", + "text": " colorWriteMask must be a valid combination of VkColorComponentFlagBits values" + } + ], + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406", + "text": " If either of colorBlendOp or alphaBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then colorBlendOp must equal alphaBlendOp" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407", + "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and colorBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then colorBlendOp must be the same for all attachments." + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408", + "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and alphaBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then alphaBlendOp must be the same for all attachments." + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409", + "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendAllOperations is VK_FALSE, then colorBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410", + "text": " If colorBlendOp or alphaBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then VkSubpassDescription::colorAttachmentCount of the subpass this pipeline is compiled against must be less than or equal to VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendMaxColorAttachments" + } + ] + }, + "vkCmdSetBlendConstants": { + "core": [ + { + "vuid": "VUID-vkCmdSetBlendConstants-None-00612", + "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_BLEND_CONSTANTS dynamic state enabled" + }, + { + "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineColorBlendAdvancedStateCreateInfoEXT": { + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424", + "text": " If the &amp;lt;&amp;lt;features-limits-advancedBlendNonPremultipliedSrcColor,non-premultiplied source color&amp;gt;&amp;gt; property is not supported, srcPremultiplied must be VK_TRUE" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425", + "text": " If the &amp;lt;&amp;lt;features-limits-advancedBlendNonPremultipliedDstColor,non-premultiplied destination color&amp;gt;&amp;gt; property is not supported, dstPremultiplied must be VK_TRUE" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426", + "text": " If the &amp;lt;&amp;lt;features-limits-advancedBlendCorrelatedOverlap,correlated overlap&amp;gt;&amp;gt; property is not supported, blendOverlap must be VK_BLEND_OVERLAP_UNCORRELATED_EXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter", + "text": " blendOverlap must be a valid VkBlendOverlapEXT value" + } + ] + }, + "vkCmdDispatch": { + "core": [ + { + "vuid": "VUID-vkCmdDispatch-groupCountX-00386", + "text": " groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, + { + "vuid": "VUID-vkCmdDispatch-groupCountY-00387", + "text": " groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-vkCmdDispatch-groupCountZ-00388", + "text": " groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00389", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00390", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00391", + "text": " A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00392", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00393", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00394", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00395", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00396", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDispatch-None-00397", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdDispatch-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatch-linearTilingFeatures-00398", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatch-formatFeatures-01949", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatch-linearTilingFeatures-00399", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatch-formatFeatures-01950", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatch-None-00400", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-01844", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-01845", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-01846", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ] + }, + "vkCmdDispatchIndirect": { + "core": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-buffer-00401", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00402", + "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00403", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00404", + "text": " A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-buffer-00405", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-offset-00406", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-offset-00407", + "text": " The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00408", + "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00409", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00410", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00411", + "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00412", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00413", + "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-linearTilingFeatures-00414", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-formatFeatures-01951", + "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-linearTilingFeatures-00415", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-formatFeatures-01952", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" + } + ], + "(VK_IMG_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-00416", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-01847", + "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-01848", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-01849", + "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer." + } + ] + }, + "VkDispatchIndirectCommand": { + "core": [ + { + "vuid": "VUID-VkDispatchIndirectCommand-x-00417", + "text": " x must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, + { + "vuid": "VUID-VkDispatchIndirectCommand-y-00418", + "text": " y must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-VkDispatchIndirectCommand-z-00419", + "text": " z must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + } + ] + }, + "vkCmdDispatchBase": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-00420", + "text": " All valid usage rules from vkCmdDispatch apply" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00421", + "text": " baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00422", + "text": " baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupZ-00423", + "text": " baseGroupZ must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + }, + { + "vuid": "VUID-vkCmdDispatchBase-groupCountX-00424", + "text": " groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] minus baseGroupX" + }, + { + "vuid": "VUID-vkCmdDispatchBase-groupCountY-00425", + "text": " groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] minus baseGroupY" + }, + { + "vuid": "VUID-vkCmdDispatchBase-groupCountZ-00426", + "text": " groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] minus baseGroupZ" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00427", + "text": " If any of baseGroupX, baseGroupY, or baseGroupZ are not zero, then the bound compute pipeline must have been created with the VK_PIPELINE_CREATE_DISPATCH_BASE flag." + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdDispatchBase-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pFeatures-parameter", + "text": " pFeatures must be a valid pointer to a VkDeviceGeneratedCommandsFeaturesNVX structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pLimits-parameter", + "text": " pLimits must be a valid pointer to a VkDeviceGeneratedCommandsLimitsNVX structure" + } + ] + }, + "VkDeviceGeneratedCommandsFeaturesNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkDeviceGeneratedCommandsFeaturesNVX-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX" + }, + { + "vuid": "VUID-VkDeviceGeneratedCommandsFeaturesNVX-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkDeviceGeneratedCommandsLimitsNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkDeviceGeneratedCommandsLimitsNVX-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX" + }, + { + "vuid": "VUID-VkDeviceGeneratedCommandsLimitsNVX-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkCreateObjectTableNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkCreateObjectTableNVX-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateObjectTableNVX-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkObjectTableCreateInfoNVX structure" + }, + { + "vuid": "VUID-vkCreateObjectTableNVX-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateObjectTableNVX-pObjectTable-parameter", + "text": " pObjectTable must be a valid pointer to a VkObjectTableNVX handle" + } + ] + }, + "VkObjectTableCreateInfoNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-computeBindingPointSupport-01355", + "text": " If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, pObjectEntryUsageFlags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-01356", + "text": " Any value within pObjectEntryCounts must not exceed VkDeviceGeneratedCommandsLimitsNVX::maxObjectEntryCounts" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-maxUniformBuffersPerDescriptor-01357", + "text": " maxUniformBuffersPerDescriptor must be within the limits supported by the device." + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-maxStorageBuffersPerDescriptor-01358", + "text": " maxStorageBuffersPerDescriptor must be within the limits supported by the device." + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-maxStorageImagesPerDescriptor-01359", + "text": " maxStorageImagesPerDescriptor must be within the limits supported by the device." + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-maxSampledImagesPerDescriptor-01360", + "text": " maxSampledImagesPerDescriptor must be within the limits supported by the device." + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryTypes-parameter", + "text": " pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-parameter", + "text": " pObjectEntryCounts must be a valid pointer to an array of objectCount uint32_t values" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-parameter", + "text": " pObjectEntryUsageFlags must be a valid pointer to an array of objectCount valid combinations of VkObjectEntryUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-requiredbitmask", + "text": " Each element of pObjectEntryUsageFlags must not be 0" + }, + { + "vuid": "VUID-VkObjectTableCreateInfoNVX-objectCount-arraylength", + "text": " objectCount must be greater than 0" + } + ] + }, + "vkDestroyObjectTableNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-01361", + "text": " All submitted commands that refer to objectTable must have completed execution." + }, + { + "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-01362", + "text": " If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here." + }, + { + "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-01363", + "text": " If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL." + }, + { + "vuid": "VUID-vkDestroyObjectTableNVX-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-parameter", + "text": " objectTable must be a valid VkObjectTableNVX handle" + }, + { + "vuid": "VUID-vkDestroyObjectTableNVX-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-parent", + "text": " objectTable must have been created, allocated, or retrieved from device" + } + ] + }, + "vkRegisterObjectsNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkRegisterObjectsNVX-pObjectTableEntry-01364", + "text": " The contents of pObjectTableEntry must yield plausible bindings supported by the device." + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-pObjectIndices-01365", + "text": " At any pObjectIndices there must not be a registered resource already." + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-pObjectIndices-01366", + "text": " Any value inside pObjectIndices must be below the appropriate VkObjectTableCreateInfoNVX::pObjectEntryCounts limits provided at objectTable creation time." + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-objectTable-parameter", + "text": " objectTable must be a valid VkObjectTableNVX handle" + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-ppObjectTableEntries-parameter", + "text": " ppObjectTableEntries must be a valid pointer to an array of objectCount valid VkObjectTableEntryNVX structures" + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-pObjectIndices-parameter", + "text": " pObjectIndices must be a valid pointer to an array of objectCount uint32_t values" + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-objectCount-arraylength", + "text": " objectCount must be greater than 0" + }, + { + "vuid": "VUID-vkRegisterObjectsNVX-objectTable-parent", + "text": " objectTable must have been created, allocated, or retrieved from device" + } + ] + }, + "VkObjectTableEntryNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkObjectTableEntryNVX-computeBindingPointSupport-01367", + "text": " If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, flags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX" + }, + { + "vuid": "VUID-VkObjectTableEntryNVX-type-parameter", + "text": " type must be a valid VkObjectEntryTypeNVX value" + }, + { + "vuid": "VUID-VkObjectTableEntryNVX-flags-parameter", + "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkObjectTableEntryNVX-flags-requiredbitmask", + "text": " flags must not be 0" + } + ] + }, + "VkObjectTablePipelineEntryNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkObjectTablePipelineEntryNVX-type-01368", + "text": " type must be VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX" + }, + { + "vuid": "VUID-VkObjectTablePipelineEntryNVX-type-parameter", + "text": " type must be a valid VkObjectEntryTypeNVX value" + }, + { + "vuid": "VUID-VkObjectTablePipelineEntryNVX-flags-parameter", + "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkObjectTablePipelineEntryNVX-flags-requiredbitmask", + "text": " flags must not be 0" + }, + { + "vuid": "VUID-VkObjectTablePipelineEntryNVX-pipeline-parameter", + "text": " pipeline must be a valid VkPipeline handle" + } + ] + }, + "VkObjectTableDescriptorSetEntryNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-type-01369", + "text": " type must be VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX" + }, + { + "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-type-parameter", + "text": " type must be a valid VkObjectEntryTypeNVX value" + }, + { + "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-flags-parameter", + "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-flags-requiredbitmask", + "text": " flags must not be 0" + }, + { + "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-pipelineLayout-parameter", + "text": " pipelineLayout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-descriptorSet-parameter", + "text": " descriptorSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-commonparent", + "text": " Both of descriptorSet, and pipelineLayout must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkObjectTableVertexBufferEntryNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-type-01370", + "text": " type must be VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX" + }, + { + "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-type-parameter", + "text": " type must be a valid VkObjectEntryTypeNVX value" + }, + { + "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-flags-parameter", + "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-flags-requiredbitmask", + "text": " flags must not be 0" + }, + { + "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ] + }, + "VkObjectTableIndexBufferEntryNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-type-01371", + "text": " type must be VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX" + }, + { + "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-type-parameter", + "text": " type must be a valid VkObjectEntryTypeNVX value" + }, + { + "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter", + "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask", + "text": " flags must not be 0" + }, + { + "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter", + "text": " indexType must be a valid VkIndexType value" + } + ] + }, + "VkObjectTablePushConstantEntryNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkObjectTablePushConstantEntryNVX-type-01372", + "text": " type must be VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX" + }, + { + "vuid": "VUID-VkObjectTablePushConstantEntryNVX-type-parameter", + "text": " type must be a valid VkObjectEntryTypeNVX value" + }, + { + "vuid": "VUID-VkObjectTablePushConstantEntryNVX-flags-parameter", + "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkObjectTablePushConstantEntryNVX-flags-requiredbitmask", + "text": " flags must not be 0" + }, + { + "vuid": "VUID-VkObjectTablePushConstantEntryNVX-pipelineLayout-parameter", + "text": " pipelineLayout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkObjectTablePushConstantEntryNVX-stageFlags-parameter", + "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-VkObjectTablePushConstantEntryNVX-stageFlags-requiredbitmask", + "text": " stageFlags must not be 0" + } + ] + }, + "vkUnregisterObjectsNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkUnregisterObjectsNVX-pObjectIndices-01373", + "text": " At any pObjectIndices there must be a registered resource already." + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-01374", + "text": " The pObjectEntryTypes of the resource at pObjectIndices must match." + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-None-01375", + "text": " All operations on the device using the registered resource must have been completed." + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-objectTable-parameter", + "text": " objectTable must be a valid VkObjectTableNVX handle" + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-parameter", + "text": " pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values" + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-pObjectIndices-parameter", + "text": " pObjectIndices must be a valid pointer to an array of objectCount uint32_t values" + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-objectCount-arraylength", + "text": " objectCount must be greater than 0" + }, + { + "vuid": "VUID-vkUnregisterObjectsNVX-objectTable-parent", + "text": " objectTable must have been created, allocated, or retrieved from device" + } + ] + }, + "VkIndirectCommandsLayoutTokenNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-bindingUnit-01342", + "text": " bindingUnit must stay within device supported limits for the appropriate commands." + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-dynamicCount-01343", + "text": " dynamicCount must stay within device supported limits for the appropriate commands." + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-divisor-01344", + "text": " divisor must be greater than 0 and a power of two." + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-tokenType-parameter", + "text": " tokenType must be a valid VkIndirectCommandsTokenTypeNVX value" + } + ] + }, + "VkIndirectCommandsTokenNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkIndirectCommandsTokenNVX-buffer-01345", + "text": " The buffer’s usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set." + }, + { + "vuid": "VUID-VkIndirectCommandsTokenNVX-offset-01346", + "text": " The offset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minCommandsTokenBufferOffsetAlignment." + }, + { + "vuid": "VUID-VkIndirectCommandsTokenNVX-tokenType-parameter", + "text": " tokenType must be a valid VkIndirectCommandsTokenTypeNVX value" + }, + { + "vuid": "VUID-VkIndirectCommandsTokenNVX-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ] + }, + "vkCreateIndirectCommandsLayoutNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkIndirectCommandsLayoutCreateInfoNVX structure" + }, + { + "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-pIndirectCommandsLayout-parameter", + "text": " pIndirectCommandsLayout must be a valid pointer to a VkIndirectCommandsLayoutNVX handle" + } + ] + }, + "VkIndirectCommandsLayoutCreateInfoNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347", + "text": " tokenCount must be greater than 0 and below VkDeviceGeneratedCommandsLimitsNVX::maxIndirectCommandsLayoutTokenCount" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348", + "text": " If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, then pipelineBindPoint must not be VK_PIPELINE_BIND_POINT_COMPUTE" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349", + "text": " If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX it must be the first element of the array and there must be only a single element of such token type." + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01350", + "text": " All state binding tokens in pTokens must occur prior work provoking tokens (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX)." + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01351", + "text": " The content of pTokens must include one single work provoking token that is compatible with the pipelineBindPoint." + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter", + "text": " flags must be a valid combination of VkIndirectCommandsLayoutUsageFlagBitsNVX values" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask", + "text": " flags must not be 0" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter", + "text": " pTokens must be a valid pointer to an array of tokenCount valid VkIndirectCommandsLayoutTokenNVX structures" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength", + "text": " tokenCount must be greater than 0" + } + ] + }, + "vkDestroyIndirectCommandsLayoutNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-01352", + "text": " All submitted commands that refer to indirectCommandsLayout must have completed execution" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01353", + "text": " If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01354", + "text": " If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter", + "text": " indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent", + "text": " indirectCommandsLayout must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdReserveSpaceForCommandsNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01329", + "text": " The provided commandBuffer must not have had a prior space reservation since its creation or the last reset." + }, + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01330", + "text": " The state of the commandBuffer must be legal to execute all commands within the sequence provided by the indirectCommandsLayout member of pProcessCommandsInfo." + }, + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-pReserveSpaceInfo-parameter", + "text": " pReserveSpaceInfo must be a valid pointer to a valid VkCmdReserveSpaceForCommandsInfoNVX structure" + }, + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-bufferlevel", + "text": " commandBuffer must be a secondary VkCommandBuffer" + } + ] + }, + "VkCmdReserveSpaceForCommandsInfoNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX" + }, + { + "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter", + "text": " objectTable must be a valid VkObjectTableNVX handle" + }, + { + "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter", + "text": " indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle" + }, + { + "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent", + "text": " Both of indirectCommandsLayout, and objectTable must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdProcessCommandsNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdProcessCommandsNVX-pProcessCommandsInfo-parameter", + "text": " pProcessCommandsInfo must be a valid pointer to a valid VkCmdProcessCommandsInfoNVX structure" + }, + { + "vuid": "VUID-vkCmdProcessCommandsNVX-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdProcessCommandsNVX-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdProcessCommandsNVX-renderpass", + "text": " This command must only be called inside of a render pass instance" + } + ] + }, + "VkCmdProcessCommandsInfoNVX": { + "(VK_NVX_device_generated_commands)": [ + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-objectTable-01331", + "text": " The provided objectTable must include all objects referenced by the generation process." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-01332", + "text": " indirectCommandsTokenCount must match the indirectCommandsLayout’s tokenCount." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-tokenType-01333", + "text": " The tokenType member of each entry in the pIndirectCommandsTokens array must match the values used at creation time of indirectCommandsLayout" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01334", + "text": " If targetCommandBuffer is provided, it must have reserved command space." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01335", + "text": " If targetCommandBuffer is provided, the objectTable must match the reservation’s objectTable and must have had all referenced objects registered at reservation time." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01336", + "text": " If targetCommandBuffer is provided, the indirectCommandsLayout must match the reservation’s indirectCommandsLayout." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01337", + "text": " If targetCommandBuffer is provided, the maxSequencesCount must not exceed the reservation’s maxSequencesCount." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01338", + "text": " If sequencesCountBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01339", + "text": " If sequencesCountBuffer is used, sequencesCountOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceCountBufferOffsetAlignment." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01340", + "text": " If sequencesIndexBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01341", + "text": " If sequencesIndexBuffer is used, sequencesIndexOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceIndexBufferOffsetAlignment." + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter", + "text": " objectTable must be a valid VkObjectTableNVX handle" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter", + "text": " indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-pIndirectCommandsTokens-parameter", + "text": " pIndirectCommandsTokens must be a valid pointer to an array of indirectCommandsTokenCount valid VkIndirectCommandsTokenNVX structures" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter", + "text": " If targetCommandBuffer is not NULL, targetCommandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter", + "text": " If sequencesCountBuffer is not VK_NULL_HANDLE, sequencesCountBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter", + "text": " If sequencesIndexBuffer is not VK_NULL_HANDLE, sequencesIndexBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-arraylength", + "text": " indirectCommandsTokenCount must be greater than 0" + }, + { + "vuid": "VUID-VkCmdProcessCommandsInfoNVX-commonparent", + "text": " Each of indirectCommandsLayout, objectTable, sequencesCountBuffer, sequencesIndexBuffer, and targetCommandBuffer that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkGetPhysicalDeviceSparseImageFormatProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094", + "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter", + "text": " type must be a valid VkImageType value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties structures" + } + ] + }, + "vkGetPhysicalDeviceSparseImageFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pFormatInfo-parameter", + "text": " pFormatInfo must be a valid pointer to a valid VkPhysicalDeviceSparseImageFormatInfo2 structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties2 structures" + } + ] + }, + "VkPhysicalDeviceSparseImageFormatInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095", + "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter", + "text": " type must be a valid VkImageType value" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + } + ] + }, + "VkSparseImageFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkSparseImageFormatProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2" + }, + { + "vuid": "VUID-VkSparseImageFormatProperties2-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetImageSparseMemoryRequirements": { + "core": [ + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirementCount-parameter", + "text": " pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirements-parameter", + "text": " If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures" + }, + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetImageSparseMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements2-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkImageSparseMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirementCount-parameter", + "text": " pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirements-parameter", + "text": " If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements2 structures" + } + ] + }, + "VkImageSparseMemoryRequirementsInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2" + }, + { + "vuid": "VUID-VkImageSparseMemoryRequirementsInfo2-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter", + "text": " image must be a valid VkImage handle" + } + ] + }, + "VkSparseImageMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkSparseImageMemoryRequirements2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2" + }, + { + "vuid": "VUID-VkSparseImageMemoryRequirements2-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkSparseMemoryBind": { + "core": [ + { + "vuid": "VUID-VkSparseMemoryBind-memory-01096", + "text": " If memory is not VK_NULL_HANDLE, memory and memoryOffset must match the memory requirements of the resource, as described in section &amp;lt;&amp;lt;resources-association&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkSparseMemoryBind-memory-01097", + "text": " If memory is not VK_NULL_HANDLE, memory must not have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set" + }, + { + "vuid": "VUID-VkSparseMemoryBind-size-01098", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-VkSparseMemoryBind-resourceOffset-01099", + "text": " resourceOffset must be less than the size of the resource" + }, + { + "vuid": "VUID-VkSparseMemoryBind-size-01100", + "text": " size must be less than or equal to the size of the resource minus resourceOffset" + }, + { + "vuid": "VUID-VkSparseMemoryBind-memoryOffset-01101", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkSparseMemoryBind-size-01102", + "text": " size must be less than or equal to the size of memory minus memoryOffset" + }, + { + "vuid": "VUID-VkSparseMemoryBind-memory-parameter", + "text": " If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-VkSparseMemoryBind-flags-parameter", + "text": " flags must be a valid combination of VkSparseMemoryBindFlagBits values" + } + ] + }, + "VkSparseBufferMemoryBindInfo": { + "core": [ + { + "vuid": "VUID-VkSparseBufferMemoryBindInfo-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkSparseBufferMemoryBindInfo-pBinds-parameter", + "text": " pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures" + }, + { + "vuid": "VUID-VkSparseBufferMemoryBindInfo-bindCount-arraylength", + "text": " bindCount must be greater than 0" + } + ] + }, + "VkSparseImageOpaqueMemoryBindInfo": { + "core": [ + { + "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103", + "text": " If the flags member of any element of pBinds contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must be within the mip tail region of the metadata aspect of image" + }, + { + "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-parameter", + "text": " pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures" + }, + { + "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-bindCount-arraylength", + "text": " bindCount must be greater than 0" + } + ] + }, + "VkSparseImageMemoryBindInfo": { + "core": [ + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-subresource-01722", + "text": " The subresource.mipLevel member of each element of pBinds must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-subresource-01723", + "text": " The subresource.arrayLayer member of each element of pBinds must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-pBinds-parameter", + "text": " pBinds must be a valid pointer to an array of bindCount valid VkSparseImageMemoryBind structures" + }, + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-bindCount-arraylength", + "text": " bindCount must be greater than 0" + } + ] + }, + "VkSparseImageMemoryBind": { + "core": [ + { + "vuid": "VUID-VkSparseImageMemoryBind-memory-01104", + "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyAliased,sparse aliased residency&amp;gt;&amp;gt; feature is not enabled, and if any other resources are bound to ranges of memory, the range of memory being bound must not overlap with those bound ranges" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-memory-01105", + "text": " memory and memoryOffset must match the memory requirements of the calling command’s image, as described in section &amp;lt;&amp;lt;resources-association&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-subresource-01106", + "text": " subresource must be a valid image subresource for image (see &amp;lt;&amp;lt;resources-image-views&amp;gt;&amp;gt;)" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-offset-01107", + "text": " offset.x must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of the image" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-extent-01108", + "text": " extent.width must either be a multiple of the sparse image block width of the image, or else (extent.width + offset.x) must equal the width of the image subresource" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-offset-01109", + "text": " offset.y must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of the image" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-extent-01110", + "text": " extent.height must either be a multiple of the sparse image block height of the image, or else (extent.height + offset.y) must equal the height of the image subresource" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-offset-01111", + "text": " offset.z must be a multiple of the sparse image block depth (VkSparseImageFormatProperties::imageGranularity.depth) of the image" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-extent-01112", + "text": " extent.depth must either be a multiple of the sparse image block depth of the image, or else (extent.depth + offset.z) must equal the depth of the image subresource" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-subresource-parameter", + "text": " subresource must be a valid VkImageSubresource structure" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-memory-parameter", + "text": " If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-flags-parameter", + "text": " flags must be a valid combination of VkSparseMemoryBindFlagBits values" + } + ] + }, + "vkQueueBindSparse": { + "core": [ + { + "vuid": "VUID-vkQueueBindSparse-fence-01113", + "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" + }, + { + "vuid": "VUID-vkQueueBindSparse-fence-01114", + "text": " If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkQueueBindSparse-pSignalSemaphores-01115", + "text": " Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device" + }, + { + "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01116", + "text": " When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, no other queue must be waiting on the same semaphore." + }, + { + "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01117", + "text": " All elements of the pWaitSemaphores member of all elements of pBindInfo must be semaphores that are signaled, or have &amp;lt;&amp;lt;synchronization-semaphores-signaling, semaphore signal operations&amp;gt;&amp;gt; previously submitted for execution." + }, + { + "vuid": "VUID-vkQueueBindSparse-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueBindSparse-pBindInfo-parameter", + "text": " If bindInfoCount is not 0, pBindInfo must be a valid pointer to an array of bindInfoCount valid VkBindSparseInfo structures" + }, + { + "vuid": "VUID-vkQueueBindSparse-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkQueueBindSparse-queuetype", + "text": " The queue must support sparse binding operations" + }, + { + "vuid": "VUID-vkQueueBindSparse-commonparent", + "text": " Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkBindSparseInfo": { + "core": [ + { + "vuid": "VUID-VkBindSparseInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO" + }, + { + "vuid": "VUID-VkBindSparseInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceGroupBindSparseInfo" + }, + { + "vuid": "VUID-VkBindSparseInfo-pWaitSemaphores-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkBindSparseInfo-pBufferBinds-parameter", + "text": " If bufferBindCount is not 0, pBufferBinds must be a valid pointer to an array of bufferBindCount valid VkSparseBufferMemoryBindInfo structures" + }, + { + "vuid": "VUID-VkBindSparseInfo-pImageOpaqueBinds-parameter", + "text": " If imageOpaqueBindCount is not 0, pImageOpaqueBinds must be a valid pointer to an array of imageOpaqueBindCount valid VkSparseImageOpaqueMemoryBindInfo structures" + }, + { + "vuid": "VUID-VkBindSparseInfo-pImageBinds-parameter", + "text": " If imageBindCount is not 0, pImageBinds must be a valid pointer to an array of imageBindCount valid VkSparseImageMemoryBindInfo structures" + }, + { + "vuid": "VUID-VkBindSparseInfo-pSignalSemaphores-parameter", + "text": " If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkBindSparseInfo-commonparent", + "text": " Both of the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkDeviceGroupBindSparseInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118", + "text": " resourceDeviceIndex and memoryDeviceIndex must both be valid device indices." + }, + { + "vuid": "VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119", + "text": " Each memory allocation bound in this batch must have allocated an instance for memoryDeviceIndex." + }, + { + "vuid": "VUID-VkDeviceGroupBindSparseInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO" + } + ] + }, + "vkCreateAndroidSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_android_surface)": [ + { + "vuid": "VUID-vkCreateAndroidSurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateAndroidSurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkAndroidSurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateAndroidSurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateAndroidSurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkAndroidSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_android_surface)": [ + { + "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-window-01248", + "text": " window must point to a valid Android ANativeWindow." + }, + { + "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateMirSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ + { + "vuid": "VUID-vkCreateMirSurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateMirSurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkMirSurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateMirSurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateMirSurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkMirSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ + { + "vuid": "VUID-VkMirSurfaceCreateInfoKHR-connection-01263", + "text": " connection must point to a valid MirConnection." + }, + { + "vuid": "VUID-VkMirSurfaceCreateInfoKHR-surface-01264", + "text": " surface must point to a valid MirSurface." + }, + { + "vuid": "VUID-VkMirSurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkMirSurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMirSurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateWaylandSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ + { + "vuid": "VUID-vkCreateWaylandSurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateWaylandSurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkWaylandSurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateWaylandSurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateWaylandSurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkWaylandSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ + { + "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-display-01304", + "text": " display must point to a valid Wayland wl_display." + }, + { + "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305", + "text": " surface must point to a valid Wayland wl_surface." + }, + { + "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateWin32SurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ + { + "vuid": "VUID-vkCreateWin32SurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateWin32SurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkWin32SurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateWin32SurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateWin32SurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkWin32SurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ + { + "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307", + "text": " hinstance must be a valid Win32 HINSTANCE." + }, + { + "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308", + "text": " hwnd must be a valid Win32 HWND." + }, + { + "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateXcbSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ + { + "vuid": "VUID-vkCreateXcbSurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateXcbSurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkXcbSurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateXcbSurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateXcbSurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkXcbSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ + { + "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-connection-01310", + "text": " connection must point to a valid X11 xcb_connection_t." + }, + { + "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-window-01311", + "text": " window must be a valid X11 xcb_window_t." + }, + { + "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateXlibSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ + { + "vuid": "VUID-vkCreateXlibSurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateXlibSurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkXlibSurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateXlibSurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateXlibSurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkXlibSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ + { + "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313", + "text": " dpy must point to a valid Xlib Display." + }, + { + "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-window-01314", + "text": " window must be a valid Xlib Window." + }, + { + "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateIOSSurfaceMVK": { + "(VK_KHR_surface)+(VK_MVK_ios_surface)": [ + { + "vuid": "VUID-vkCreateIOSSurfaceMVK-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateIOSSurfaceMVK-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkIOSSurfaceCreateInfoMVK structure" + }, + { + "vuid": "VUID-vkCreateIOSSurfaceMVK-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateIOSSurfaceMVK-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkIOSSurfaceCreateInfoMVK": { + "(VK_KHR_surface)+(VK_MVK_ios_surface)": [ + { + "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-pView-01316", + "text": " pView must be a valid UIView and must be backed by a CALayer instance of type CAMetalLayer." + }, + { + "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK" + }, + { + "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateMacOSSurfaceMVK": { + "(VK_KHR_surface)+(VK_MVK_macos_surface)": [ + { + "vuid": "VUID-vkCreateMacOSSurfaceMVK-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateMacOSSurfaceMVK-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkMacOSSurfaceCreateInfoMVK structure" + }, + { + "vuid": "VUID-vkCreateMacOSSurfaceMVK-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateMacOSSurfaceMVK-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkMacOSSurfaceCreateInfoMVK": { + "(VK_KHR_surface)+(VK_MVK_macos_surface)": [ + { + "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317", + "text": " pView must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer." + }, + { + "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK" + }, + { + "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkCreateViSurfaceNN": { + "(VK_KHR_surface)+(VK_NN_vi_surface)": [ + { + "vuid": "VUID-vkCreateViSurfaceNN-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateViSurfaceNN-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkViSurfaceCreateInfoNN structure" + }, + { + "vuid": "VUID-vkCreateViSurfaceNN-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateViSurfaceNN-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkViSurfaceCreateInfoNN": { + "(VK_KHR_surface)+(VK_NN_vi_surface)": [ + { + "vuid": "VUID-VkViSurfaceCreateInfoNN-window-01318", + "text": " window must be a valid nn::vi::NativeWindowHandle" + }, + { + "vuid": "VUID-VkViSurfaceCreateInfoNN-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN" + }, + { + "vuid": "VUID-VkViSurfaceCreateInfoNN-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkViSurfaceCreateInfoNN-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkDestroySurfaceKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01266", + "text": " All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01267", + "text": " If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01268", + "text": " If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-parameter", + "text": " If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-parent", + "text": " If surface is a valid handle, it must have been created, allocated, or retrieved from instance" + } + ] + }, + "vkGetPhysicalDeviceDisplayPropertiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures" + } + ] + }, + "vkGetPhysicalDeviceDisplayProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayProperties2KHR structures" + } + ] + }, + "VkDisplayProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayProperties2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayProperties2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkAcquireXlibDisplayEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)": [ + { + "vuid": "VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkAcquireXlibDisplayEXT-dpy-parameter", + "text": " dpy must be a valid pointer to a Display value" + }, + { + "vuid": "VUID-vkAcquireXlibDisplayEXT-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + } + ] + }, + "vkGetRandROutputDisplayEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)": [ + { + "vuid": "VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetRandROutputDisplayEXT-dpy-parameter", + "text": " dpy must be a valid pointer to a Display value" + }, + { + "vuid": "VUID-vkGetRandROutputDisplayEXT-pDisplay-parameter", + "text": " pDisplay must be a valid pointer to a VkDisplayKHR handle" + } + ] + }, + "vkReleaseDisplayEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)": [ + { + "vuid": "VUID-vkReleaseDisplayEXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkReleaseDisplayEXT-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + } + ] + }, + "vkGetPhysicalDeviceDisplayPlanePropertiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlanePropertiesKHR structures" + } + ] + }, + "vkGetPhysicalDeviceDisplayPlaneProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlaneProperties2KHR structures" + } + ] + }, + "VkDisplayPlaneProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayPlaneProperties2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayPlaneProperties2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetDisplayPlaneSupportedDisplaysKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249", + "text": " planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR" + }, + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter", + "text": " pDisplayCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter", + "text": " If the value referenced by pDisplayCount is not 0, and pDisplays is not NULL, pDisplays must be a valid pointer to an array of pDisplayCount VkDisplayKHR handles" + } + ] + }, + "vkGetDisplayModePropertiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModePropertiesKHR structures" + } + ] + }, + "vkGetDisplayModeProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModeProperties2KHR structures" + } + ] + }, + "VkDisplayModeProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayModeProperties2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayModeProperties2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkCreateDisplayModeKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkCreateDisplayModeKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDisplayModeCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-pMode-parameter", + "text": " pMode must be a valid pointer to a VkDisplayModeKHR handle" + } + ] + }, + "VkDisplayModeCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-width-01250", + "text": " The width and height members of the visibleRegion member of parameters must be greater than 0" + }, + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-refreshRate-01251", + "text": " The refreshRate member of parameters must be greater than 0" + }, + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkGetDisplayPlaneCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter", + "text": " mode must be a valid VkDisplayModeKHR handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter", + "text": " pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilitiesKHR structure" + } + ] + }, + "vkGetDisplayPlaneCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-pDisplayPlaneInfo-parameter", + "text": " pDisplayPlaneInfo must be a valid pointer to a valid VkDisplayPlaneInfo2KHR structure" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-pCapabilities-parameter", + "text": " pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilities2KHR structure" + } + ] + }, + "VkDisplayPlaneInfo2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayPlaneInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkDisplayPlaneInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayPlaneInfo2KHR-mode-parameter", + "text": " mode must be a valid VkDisplayModeKHR handle" + } + ] + }, + "VkDisplayPlaneCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayPlaneCapabilities2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayPlaneCapabilities2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkDisplayPowerControlEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkDisplayPowerControlEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDisplayPowerControlEXT-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter", + "text": " pDisplayPowerInfo must be a valid pointer to a valid VkDisplayPowerInfoEXT structure" + } + ] + }, + "VkDisplayPowerInfoEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkDisplayPowerInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT" + }, + { + "vuid": "VUID-VkDisplayPowerInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayPowerInfoEXT-powerState-parameter", + "text": " powerState must be a valid VkDisplayPowerStateEXT value" + } + ] + }, + "vkCreateDisplayPlaneSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDisplaySurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkDisplaySurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252", + "text": " planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253", + "text": " If the planeReorderPossible member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display corresponding to displayMode is VK_TRUE then planeStackIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR; otherwise planeStackIndex must equal the currentStackIndex member of VkDisplayPlanePropertiesKHR returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR for the display plane corresponding to displayMode" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254", + "text": " If alphaMode is VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR then globalAlpha must be between 0 and 1, inclusive" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255", + "text": " alphaMode must be 0 or one of the bits present in the supportedAlpha member of VkDisplayPlaneCapabilitiesKHR returned by vkGetDisplayPlaneCapabilitiesKHR for the display plane corresponding to displayMode" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-width-01256", + "text": " The width and height members of imageExtent must be less than the maxImageDimensions2D member of VkPhysicalDeviceLimits" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter", + "text": " displayMode must be a valid VkDisplayModeKHR handle" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter", + "text": " transform must be a valid VkSurfaceTransformFlagBitsKHR value" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter", + "text": " alphaMode must be a valid VkDisplayPlaneAlphaFlagBitsKHR value" + } + ] + }, + "vkGetPhysicalDeviceSurfaceSupportKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter", + "text": " pSupported must be a valid pointer to a VkBool32 value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDeviceMirPresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-queueFamilyIndex-01265", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-connection-parameter", + "text": " connection must be a valid pointer to a MirConnection value" + } + ] + }, + "vkGetPhysicalDeviceWaylandPresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-display-parameter", + "text": " display must be a valid pointer to a wl_display value" + } + ] + }, + "vkGetPhysicalDeviceWin32PresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + } + ] + }, + "vkGetPhysicalDeviceXcbPresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-connection-parameter", + "text": " connection must be a valid pointer to a xcb_connection_t value" + } + ] + }, + "vkGetPhysicalDeviceXlibPresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-dpy-parameter", + "text": " dpy must be a valid pointer to a Display value" + } + ] + }, + "vkGetPhysicalDeviceSurfaceCapabilitiesKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter", + "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilitiesKHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDeviceSurfaceCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter", + "text": " pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter", + "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2KHR structure" + } + ] + }, + "VkPhysicalDeviceSurfaceInfo2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + } + ] + }, + "VkSurfaceCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-VkSurfaceCapabilities2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR" + }, + { + "vuid": "VUID-VkSurfaceCapabilities2KHR-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkSharedPresentSurfaceCapabilitiesKHR" + } + ] + }, + "VkSharedPresentSurfaceCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR" + } + ] + }, + "vkGetPhysicalDeviceSurfaceCapabilities2EXT": { + "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter", + "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2EXT structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "VkSurfaceCapabilities2EXT": { + "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [ + { + "vuid": "VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246", + "text": " supportedSurfaceCounters must not include VK_SURFACE_COUNTER_VBLANK_EXT unless the surface queried is a &amp;lt;&amp;lt;wsi-display-surfaces,display surface&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkSurfaceCapabilities2EXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT" + }, + { + "vuid": "VUID-VkSurfaceCapabilities2EXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceSurfaceFormatsKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter", + "text": " pSurfaceFormatCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter", + "text": " If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormatKHR structures" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDeviceSurfaceFormats2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter", + "text": " pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter", + "text": " pSurfaceFormatCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter", + "text": " If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormat2KHR structures" + } + ] + }, + "VkSurfaceFormat2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-VkSurfaceFormat2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR" + }, + { + "vuid": "VUID-VkSurfaceFormat2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceSurfacePresentModesKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter", + "text": " pPresentModeCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter", + "text": " If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetDeviceGroupPresentCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter", + "text": " pDeviceGroupPresentCapabilities must be a valid pointer to a VkDeviceGroupPresentCapabilitiesKHR structure" + } + ] + }, + "VkDeviceGroupPresentCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR" + }, + { + "vuid": "VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetDeviceGroupSurfacePresentModesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter", + "text": " pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value" + }, + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent", + "text": " Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDevicePresentRectanglesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter", + "text": " pRectCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter", + "text": " If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetRefreshCycleDurationGOOGLE": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [ + { + "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-pDisplayTimingProperties-parameter", + "text": " pDisplayTimingProperties must be a valid pointer to a VkRefreshCycleDurationGOOGLE structure" + }, + { + "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPastPresentationTimingGOOGLE": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [ + { + "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter", + "text": " pPresentationTimingCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter", + "text": " If the value referenced by pPresentationTimingCount is not 0, and pPresentationTimings is not NULL, pPresentationTimings must be a valid pointer to an array of pPresentationTimingCount VkPastPresentationTimingGOOGLE structures" + }, + { + "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetSwapchainStatusKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkGetSwapchainStatusKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSwapchainStatusKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetSwapchainStatusKHR-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkCreateSwapchainKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkCreateSwapchainKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSwapchainKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateSwapchainKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateSwapchainKHR-pSwapchain-parameter", + "text": " pSwapchain must be a valid pointer to a VkSwapchainKHR handle" + } + ] + }, + "VkSwapchainCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-surface-01270", + "text": " surface must be a surface that is supported by the device as determined using vkGetPhysicalDeviceSurfaceSupportKHR" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01271", + "text": " minImageCount must be greater than or equal to the value returned in the minImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01272", + "text": " minImageCount must be less than or equal to the value returned in the maxImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface if the returned maxImageCount is not zero" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-01273", + "text": " imageFormat and imageColorSpace must match the format and colorSpace members, respectively, of one of the VkSurfaceFormatKHR structures returned by vkGetPhysicalDeviceSurfaceFormatsKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageExtent-01274", + "text": " imageExtent must be between minImageExtent and maxImageExtent, inclusive, where minImageExtent and maxImageExtent are members of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageExtent-01689", + "text": " imageExtent members width and height must both be non-zero" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275", + "text": " imageArrayLayers must be greater than 0 and less than or equal to the maxImageArrayLayers member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-preTransform-01279", + "text": " preTransform must be one of the bits present in the supportedTransforms member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280", + "text": " compositeAlpha must be one of the bits present in the supportedCompositeAlpha member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-01281", + "text": " presentMode must be one of the VkPresentModeKHR values returned by vkGetPhysicalDeviceSurfacePresentModesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933", + "text": " If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-01778", + "text": " imageFormat, imageUsage, imageExtent, and imageArrayLayers must be supported for VK_IMAGE_TYPE_2D VK_IMAGE_TILING_OPTIMAL images as reported by vkGetPhysicalDeviceImageFormatProperties." + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHR or VkSwapchainCounterCreateInfoEXT" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkSwapchainCreateFlagBitsKHR values" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter", + "text": " imageFormat must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter", + "text": " imageColorSpace must be a valid VkColorSpaceKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter", + "text": " imageUsage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask", + "text": " imageUsage must not be 0" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter", + "text": " imageSharingMode must be a valid VkSharingMode value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter", + "text": " preTransform must be a valid VkSurfaceTransformFlagBitsKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter", + "text": " compositeAlpha must be a valid VkCompositeAlphaFlagBitsKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-parameter", + "text": " presentMode must be a valid VkPresentModeKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter", + "text": " If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent", + "text": " If oldSwapchain is a valid handle, it must have been created, allocated, or retrieved from surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-commonparent", + "text": " Both of oldSwapchain, and surface that are valid handles must have been created, allocated, or retrieved from the same VkInstance" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01383", + "text": " minImageCount must be 1 if presentMode is either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-01427", + "text": " If presentMode is VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_FIFO_RELAXED_KHR, imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-01384", + "text": " If presentMode is VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, imageUsage must be a subset of the supported usage flags present in the sharedPresentSupportedUsageFlags member of the VkSharedPresentSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-01276", + "text": " imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01393", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429", + "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" + } + ] + }, + "VkDeviceGroupSwapchainCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter", + "text": " modes must be a valid combination of VkDeviceGroupPresentModeFlagBitsKHR values" + }, + { + "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask", + "text": " modes must not be 0" + } + ] + }, + "VkSwapchainCounterCreateInfoEXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244", + "text": " The bits in surfaceCounters must be supported by VkSwapchainCreateInfoKHR::surface, as reported by vkGetPhysicalDeviceSurfaceCapabilities2EXT." + }, + { + "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter", + "text": " surfaceCounters must be a valid combination of VkSurfaceCounterFlagBitsEXT values" + } + ] + }, + "vkGetSwapchainCounterEXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkGetSwapchainCounterEXT-swapchain-01245", + "text": " One or more present commands on swapchain must have been processed by the presentation engine." + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-counter-parameter", + "text": " counter must be a valid VkSurfaceCounterFlagBitsEXT value" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter", + "text": " pCounterValue must be a valid pointer to a uint64_t value" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkDestroySwapchainKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01282", + "text": " All uses of presentable images acquired from swapchain must have completed execution" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01283", + "text": " If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01284", + "text": " If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-parameter", + "text": " If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-commonparent", + "text": " Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkCreateSharedSwapchainsKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of swapchainCount valid VkSwapchainCreateInfoKHR structures" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter", + "text": " pSwapchains must be a valid pointer to an array of swapchainCount VkSwapchainKHR handles" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + } + ] + }, + "vkGetSwapchainImagesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkGetSwapchainImagesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter", + "text": " pSwapchainImageCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter", + "text": " If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkAcquireNextImageKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkAcquireNextImageKHR-swapchain-01285", + "text": " swapchain must not be in the retired state" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01286", + "text": " If semaphore is not VK_NULL_HANDLE it must be unsignaled" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01779", + "text": " If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-fence-01287", + "text": " If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01780", + "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-swapchain-01802", + "text": " If the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-parameter", + "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-pImageIndex-parameter", + "text": " pImageIndex must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-parent", + "text": " If semaphore is a valid handle, it must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-fence-parent", + "text": " If fence is a valid handle, it must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-commonparent", + "text": " Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkAcquireNextImage2KHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkAcquireNextImage2KHR-swapchain-01803", + "text": " If the number of currently acquired images is greater than the difference between the number of images in the swapchain member of pAcquireInfo and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, the timeout member of pAcquireInfo must not be UINT64_MAX" + }, + { + "vuid": "VUID-vkAcquireNextImage2KHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter", + "text": " pAcquireInfo must be a valid pointer to a valid VkAcquireNextImageInfoKHR structure" + }, + { + "vuid": "VUID-vkAcquireNextImage2KHR-pImageIndex-parameter", + "text": " pImageIndex must be a valid pointer to a uint32_t value" + } + ] + }, + "VkAcquireNextImageInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-swapchain-01675", + "text": " swapchain must not be in the retired state" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01288", + "text": " If semaphore is not VK_NULL_HANDLE it must be unsignaled" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01781", + "text": " If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-fence-01289", + "text": " If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01782", + "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-deviceMask-01290", + "text": " deviceMask must be a valid device mask" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-deviceMask-01291", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01804", + "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE." + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-parameter", + "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-commonparent", + "text": " Each of fence, semaphore, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkQueuePresentKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkQueuePresentKHR-pSwapchains-01292", + "text": " Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR" + }, + { + "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01294", + "text": " When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, no other queue must be waiting on the same semaphore." + }, + { + "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01295", + "text": " All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have &amp;lt;&amp;lt;synchronization-semaphores-signaling, semaphore signal operations&amp;gt;&amp;gt; previously submitted for execution." + }, + { + "vuid": "VUID-vkQueuePresentKHR-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueuePresentKHR-pPresentInfo-parameter", + "text": " pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ + { + "vuid": "VUID-vkQueuePresentKHR-pSwapchains-01293", + "text": " If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode" + } + ] + }, + "VkPresentInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkPresentInfoKHR-pImageIndices-01296", + "text": " Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR layout at the time the operation is executed on a VkDevice" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkPresentInfoKHR-pImageIndices-01430", + "text": " Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkPresentInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupPresentInfoKHR, VkDisplayPresentInfoKHR, VkPresentRegionsKHR, or VkPresentTimesInfoGOOGLE" + }, + { + "vuid": "VUID-VkPresentInfoKHR-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pWaitSemaphores-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pSwapchains-parameter", + "text": " pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pImageIndices-parameter", + "text": " pImageIndices must be a valid pointer to an array of swapchainCount uint32_t values" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pResults-parameter", + "text": " If pResults is not NULL, pResults must be a valid pointer to an array of swapchainCount VkResult values" + }, + { + "vuid": "VUID-VkPresentInfoKHR-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + }, + { + "vuid": "VUID-VkPresentInfoKHR-commonparent", + "text": " Both of the elements of pSwapchains, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "VkPresentRegionsKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ + { + "vuid": "VUID-VkPresentRegionsKHR-swapchainCount-01260", + "text": " swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext-chain of this VkPresentRegionsKHR structure." + }, + { + "vuid": "VUID-VkPresentRegionsKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR" + }, + { + "vuid": "VUID-VkPresentRegionsKHR-pRegions-parameter", + "text": " If pRegions is not NULL, pRegions must be a valid pointer to an array of swapchainCount valid VkPresentRegionKHR structures" + }, + { + "vuid": "VUID-VkPresentRegionsKHR-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + } + ] + }, + "VkPresentRegionKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ + { + "vuid": "VUID-VkPresentRegionKHR-pRectangles-parameter", + "text": " If rectangleCount is not 0, and pRectangles is not NULL, pRectangles must be a valid pointer to an array of rectangleCount VkRectLayerKHR structures" + } + ] + }, + "VkRectLayerKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ + { + "vuid": "VUID-VkRectLayerKHR-offset-01261", + "text": " The sum of offset and extent must be no greater than the imageExtent member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR." + }, + { + "vuid": "VUID-VkRectLayerKHR-layer-01262", + "text": " layer must be less than imageArrayLayers member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR." + } + ] + }, + "VkDisplayPresentInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ + { + "vuid": "VUID-VkDisplayPresentInfoKHR-srcRect-01257", + "text": " srcRect must specify a rectangular region that is a subset of the image being presented" + }, + { + "vuid": "VUID-VkDisplayPresentInfoKHR-dstRect-01258", + "text": " dstRect must specify a rectangular region that is a subset of the visibleRegion parameter of the display mode the swapchain being presented uses" + }, + { + "vuid": "VUID-VkDisplayPresentInfoKHR-persistentContent-01259", + "text": " If the persistentContent member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display the present operation targets then persistent must be VK_FALSE" + }, + { + "vuid": "VUID-VkDisplayPresentInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR" + } + ] + }, + "VkDeviceGroupPresentInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297", + "text": " swapchainCount must equal 0 or VkPresentInfoKHR::swapchainCount" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01298", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01299", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and some physical device in the logical device must include that bit in its VkDeviceGroupPresentCapabilitiesKHR::presentMask." + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01300", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, then each element of pDeviceMasks must have a value for which all set bits are set in one of the elements of VkDeviceGroupPresentCapabilitiesKHR::presentMask" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01301", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, then for each bit set in each element of pDeviceMasks, the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302", + "text": " The value of each element of pDeviceMasks must be equal to the device mask passed in VkAcquireNextImageInfoKHR::deviceMask when the image index was last acquired" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01303", + "text": " mode must have exactly one bit set, and that bit must have been included in VkDeviceGroupSwapchainCreateInfoKHR::modes" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter", + "text": " If swapchainCount is not 0, pDeviceMasks must be a valid pointer to an array of swapchainCount uint32_t values" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-parameter", + "text": " mode must be a valid VkDeviceGroupPresentModeFlagBitsKHR value" + } + ] + }, + "VkPresentTimesInfoGOOGLE": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [ + { + "vuid": "VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247", + "text": " swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext chain of this VkPresentTimesInfoGOOGLE structure." + }, + { + "vuid": "VUID-VkPresentTimesInfoGOOGLE-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE" + }, + { + "vuid": "VUID-VkPresentTimesInfoGOOGLE-pTimes-parameter", + "text": " If pTimes is not NULL, pTimes must be a valid pointer to an array of swapchainCount VkPresentTimeGOOGLE structures" + }, + { + "vuid": "VUID-VkPresentTimesInfoGOOGLE-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + } + ] + }, + "vkSetHdrMetadataEXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)": [ + { + "vuid": "VUID-vkSetHdrMetadataEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-pSwapchains-parameter", + "text": " pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-pMetadata-parameter", + "text": " pMetadata must be a valid pointer to an array of swapchainCount valid VkHdrMetadataEXT structures" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-commonparent", + "text": " Both of device, and the elements of pSwapchains must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkEnumerateInstanceLayerProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures" + } + ] + }, + "vkEnumerateDeviceLayerProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures" + } + ] + }, + "vkEnumerateInstanceExtensionProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter", + "text": " If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures" + } + ] + }, + "vkEnumerateDeviceExtensionProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter", + "text": " If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures" + } + ] + }, + "vkGetPhysicalDeviceFeatures": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter", + "text": " pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure" + } + ] + }, + "vkGetPhysicalDeviceFeatures2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter", + "text": " pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure" + } + ] + }, + "VkPhysicalDeviceFeatures2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceFeatures2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2" + } + ] + }, + "VkPhysicalDeviceVariablePointerFeatures": { + "(VK_VERSION_1_1,VK_KHR_variable_pointers)": [ + { + "vuid": "VUID-VkPhysicalDeviceVariablePointerFeatures-variablePointers-01431", + "text": " If variablePointers is enabled then variablePointersStorageBuffer must also be enabled." + }, + { + "vuid": "VUID-VkPhysicalDeviceVariablePointerFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES" + } + ] + }, + "VkPhysicalDeviceMultiviewFeatures": { + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580", + "text": " If multiviewGeometryShader is enabled then multiview must also be enabled." + }, + { + "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581", + "text": " If multiviewTessellationShader is enabled then multiview must also be enabled." + }, + { + "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES" + } + ] + }, + "VkPhysicalDevice16BitStorageFeatures": { + "(VK_VERSION_1_1,VK_KHR_16bit_storage)": [ + { + "vuid": "VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES" + } + ] + }, + "VkPhysicalDeviceSamplerYcbcrConversionFeatures": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES" + } + ] + }, + "VkPhysicalDeviceProtectedMemoryFeatures": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES" + } + ] + }, + "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT": { + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceShaderDrawParameterFeatures": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderDrawParameterFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES" + } + ] + }, + "VkPhysicalDeviceDescriptorIndexingFeaturesEXT": { + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPhysicalDeviceDescriptorIndexingFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT" + } + ] + }, + "VkPhysicalDevicePushDescriptorPropertiesKHR": { + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR" + } + ] + }, + "VkPhysicalDeviceMultiviewProperties": { + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkPhysicalDeviceMultiviewProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceDiscardRectanglePropertiesEXT": { + "(VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceSampleLocationsPropertiesEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceExternalMemoryHostPropertiesEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX": { + "(VK_NVX_multiview_per_view_attributes)": [ + { + "vuid": "VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX" + } + ] + }, + "VkPhysicalDevicePointClippingProperties": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkPhysicalDevicePointClippingProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceSubgroupProperties": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceSubgroupProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT": { + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT": { + "(VK_EXT_vertex_attribute_divisor)": [ + { + "vuid": "VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT": { + "(VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceProtectedMemoryProperties": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceMaintenance3Properties": { + "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ + { + "vuid": "VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceDescriptorIndexingPropertiesEXT": { + "(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPhysicalDeviceDescriptorIndexingPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceConservativeRasterizationPropertiesEXT": { + "(VK_EXT_conservative_rasterization)": [ + { + "vuid": "VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceShaderCorePropertiesAMD": { + "(VK_AMD_shader_core_properties)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD" + } + ] + }, + "vkGetPhysicalDeviceMultisamplePropertiesEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter", + "text": " pMultisampleProperties must be a valid pointer to a VkMultisamplePropertiesEXT structure" + } + ] + }, + "VkMultisamplePropertiesEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkMultisamplePropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT" + }, + { + "vuid": "VUID-VkMultisamplePropertiesEXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceFormatProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter", + "text": " pFormatProperties must be a valid pointer to a VkFormatProperties structure" + } + ] + }, + "vkGetPhysicalDeviceFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter", + "text": " pFormatProperties must be a valid pointer to a VkFormatProperties2 structure" + } + ] + }, + "VkFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkFormatProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2" + }, + { + "vuid": "VUID-VkFormatProperties2-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceImageFormatProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter", + "text": " type must be a valid VkImageType value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter", + "text": " pImageFormatProperties must be a valid pointer to a VkImageFormatProperties structure" + } + ] + }, + "vkGetPhysicalDeviceExternalImageFormatPropertiesNV": { + "(VK_NV_external_memory_capabilities)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter", + "text": " type must be a valid VkImageType value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter", + "text": " externalHandleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter", + "text": " pExternalImageFormatProperties must be a valid pointer to a VkExternalImageFormatPropertiesNV structure" + } + ] + }, + "vkGetPhysicalDeviceImageFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868", + "text": " If the pNext chain of pImageFormatProperties contains an instance of VkAndroidHardwareBufferUsageANDROID, the pNext chain of pImageFormatInfo must contain an instance of VkPhysicalDeviceExternalImageFormatInfo with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID." + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter", + "text": " pImageFormatInfo must be a valid pointer to a valid VkPhysicalDeviceImageFormatInfo2 structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", + "text": " pImageFormatProperties must be a valid pointer to a VkImageFormatProperties2 structure" + } + ] + }, + "VkPhysicalDeviceImageFormatInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceExternalImageFormatInfo" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter", + "text": " type must be a valid VkImageType value" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + } + ] + }, + "VkImageFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkImageFormatProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2" + }, + { + "vuid": "VUID-VkImageFormatProperties2-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkSamplerYcbcrConversionImageFormatProperties, or VkTextureLODGatherFormatPropertiesAMD" + }, + { + "vuid": "VUID-VkImageFormatProperties2-sType-unique", + "text": " Each sType member in the pNext chain must be unique" + } + ] + }, + "VkPhysicalDeviceExternalImageFormatInfo": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter", + "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "VkExternalImageFormatProperties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkExternalImageFormatProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES" + } + ] + }, + "VkSamplerYcbcrConversionImageFormatProperties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES" + } + ] + }, + "VkAndroidHardwareBufferUsageANDROID": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkAndroidHardwareBufferUsageANDROID-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID" + } + ] + }, + "vkGetPhysicalDeviceExternalBufferProperties": { + "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter", + "text": " pExternalBufferInfo must be a valid pointer to a valid VkPhysicalDeviceExternalBufferInfo structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter", + "text": " pExternalBufferProperties must be a valid pointer to a VkExternalBufferProperties structure" + } + ] + }, + "VkPhysicalDeviceExternalBufferInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter", + "text": " flags must be a valid combination of VkBufferCreateFlagBits values" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter", + "text": " usage must be a valid combination of VkBufferUsageFlagBits values" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "VkExternalBufferProperties": { + "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkExternalBufferProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES" + }, + { + "vuid": "VUID-VkExternalBufferProperties-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceExternalSemaphoreProperties": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter", + "text": " pExternalSemaphoreInfo must be a valid pointer to a valid VkPhysicalDeviceExternalSemaphoreInfo structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter", + "text": " pExternalSemaphoreProperties must be a valid pointer to a VkExternalSemaphoreProperties structure" + } + ] + }, + "VkPhysicalDeviceExternalSemaphoreInfo": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter", + "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ] + }, + "VkExternalSemaphoreProperties": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ + { + "vuid": "VUID-VkExternalSemaphoreProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES" + }, + { + "vuid": "VUID-VkExternalSemaphoreProperties-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceExternalFenceProperties": { + "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter", + "text": " pExternalFenceInfo must be a valid pointer to a valid VkPhysicalDeviceExternalFenceInfo structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter", + "text": " pExternalFenceProperties must be a valid pointer to a VkExternalFenceProperties structure" + } + ] + }, + "VkPhysicalDeviceExternalFenceInfo": { + "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter", + "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "VkExternalFenceProperties": { + "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-VkExternalFenceProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES" + }, + { + "vuid": "VUID-VkExternalFenceProperties-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkSetDebugUtilsObjectNameEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter", + "text": " pNameInfo must be a valid pointer to a valid VkDebugUtilsObjectNameInfoEXT structure" + } + ] + }, + "VkDebugUtilsObjectNameInfoEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-01905", + "text": " objectType must not be VK_OBJECT_TYPE_UNKNOWN" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01906", + "text": " objectHandle must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01907", + "text": " objectHandle must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debugging-object-types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter", + "text": " objectType must be a valid VkObjectType value" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter", + "text": " If pObjectName is not NULL, pObjectName must be a null-terminated UTF-8 string" + } + ] + }, + "vkSetDebugUtilsObjectTagEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkSetDebugUtilsObjectTagEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter", + "text": " pTagInfo must be a valid pointer to a valid VkDebugUtilsObjectTagInfoEXT structure" + } + ] + }, + "VkDebugUtilsObjectTagInfoEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908", + "text": " objectType must not be VK_OBJECT_TYPE_UNKNOWN" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01909", + "text": " objectHandle must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910", + "text": " objectHandle must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debugging-object-types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter", + "text": " objectType must be a valid VkObjectType value" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter", + "text": " pTag must be a valid pointer to an array of tagSize bytes" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength", + "text": " tagSize must be greater than 0" + } + ] + }, + "vkQueueBeginDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + } + ] + }, + "VkDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsLabelEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsLabelEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsLabelEXT-pLabelName-parameter", + "text": " pLabelName must be a null-terminated UTF-8 string" + } + ] + }, + "vkQueueEndDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkQueueEndDebugUtilsLabelEXT-None-01911", + "text": " There must be an outstanding vkQueueBeginDebugUtilsLabelEXT command prior to the vkQueueEndDebugUtilsLabelEXT on the queue" + }, + { + "vuid": "VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter", + "text": " queue must be a valid VkQueue handle" + } + ] + }, + "vkQueueInsertDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + } + ] + }, + "vkCmdBeginDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + }, + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCmdEndDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912", + "text": " There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to" + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913", + "text": " If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT." + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCmdInsertDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + }, + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCreateDebugUtilsMessengerEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDebugUtilsMessengerCreateInfoEXT structure" + }, + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter", + "text": " pMessenger must be a valid pointer to a VkDebugUtilsMessengerEXT handle" + } + ] + }, + "VkDebugUtilsMessengerCreateInfoEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914", + "text": " pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter", + "text": " messageSeverity must be a valid combination of VkDebugUtilsMessageSeverityFlagBitsEXT values" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask", + "text": " messageSeverity must not be 0" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter", + "text": " messageType must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask", + "text": " messageType must not be 0" + } + ] + }, + "VkDebugUtilsMessengerCallbackDataEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter", + "text": " If pMessageIdName is not NULL, pMessageIdName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter", + "text": " pMessage must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-objectCount-arraylength", + "text": " objectCount must be greater than 0" + } + ] + }, + "vkSubmitDebugUtilsMessageEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter", + "text": " messageSeverity must be a valid VkDebugUtilsMessageSeverityFlagBitsEXT value" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter", + "text": " messageTypes must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask", + "text": " messageTypes must not be 0" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter", + "text": " pCallbackData must be a valid pointer to a valid VkDebugUtilsMessengerCallbackDataEXT structure" + } + ] + }, + "vkDestroyDebugUtilsMessengerEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915", + "text": " If VkAllocationCallbacks were provided when messenger was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916", + "text": " If no VkAllocationCallbacks were provided when messenger was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter", + "text": " messenger must be a valid VkDebugUtilsMessengerEXT handle" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent", + "text": " messenger must have been created, allocated, or retrieved from instance" + } + ] + }, + "vkDebugMarkerSetObjectNameEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkDebugMarkerSetObjectNameEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDebugMarkerSetObjectNameEXT-pNameInfo-parameter", + "text": " pNameInfo must be a valid pointer to a valid VkDebugMarkerObjectNameInfoEXT structure" + } + ] + }, + "VkDebugMarkerObjectNameInfoEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490", + "text": " objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT" + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-object-01491", + "text": " object must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-object-01492", + "text": " object must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debug-report-object-types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-objectType-parameter", + "text": " objectType must be a valid VkDebugReportObjectTypeEXT value" + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-pObjectName-parameter", + "text": " pObjectName must be a null-terminated UTF-8 string" + } + ] + }, + "vkDebugMarkerSetObjectTagEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkDebugMarkerSetObjectTagEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDebugMarkerSetObjectTagEXT-pTagInfo-parameter", + "text": " pTagInfo must be a valid pointer to a valid VkDebugMarkerObjectTagInfoEXT structure" + } + ] + }, + "VkDebugMarkerObjectTagInfoEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493", + "text": " objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-object-01494", + "text": " object must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-object-01495", + "text": " object must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debug-report-object-types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-objectType-parameter", + "text": " objectType must be a valid VkDebugReportObjectTypeEXT value" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-pTag-parameter", + "text": " pTag must be a valid pointer to an array of tagSize bytes" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-tagSize-arraylength", + "text": " tagSize must be greater than 0" + } + ] + }, + "vkCmdDebugMarkerBeginEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDebugMarkerBeginEXT-pMarkerInfo-parameter", + "text": " pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure" + }, + { + "vuid": "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "VkDebugMarkerMarkerInfoEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-VkDebugMarkerMarkerInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter", + "text": " pMarkerName must be a null-terminated UTF-8 string" + } + ] + }, + "vkCmdDebugMarkerEndEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239", + "text": " There must be an outstanding vkCmdDebugMarkerBeginEXT command prior to the vkCmdDebugMarkerEndEXT on the queue that commandBuffer is submitted to" + }, + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240", + "text": " If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT." + }, + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCmdDebugMarkerInsertEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDebugMarkerInsertEXT-pMarkerInfo-parameter", + "text": " pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure" + }, + { + "vuid": "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-recording", + "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" + }, + { + "vuid": "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCreateDebugReportCallbackEXT": { + "(VK_EXT_debug_report)": [ + { + "vuid": "VUID-vkCreateDebugReportCallbackEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateDebugReportCallbackEXT-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDebugReportCallbackCreateInfoEXT structure" + }, + { + "vuid": "VUID-vkCreateDebugReportCallbackEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateDebugReportCallbackEXT-pCallback-parameter", + "text": " pCallback must be a valid pointer to a VkDebugReportCallbackEXT handle" + } + ] + }, + "VkDebugReportCallbackCreateInfoEXT": { + "(VK_EXT_debug_report)": [ + { + "vuid": "VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-01385", + "text": " pfnCallback must be a valid PFN_vkDebugReportCallbackEXT" + }, + { + "vuid": "VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter", + "text": " flags must be a valid combination of VkDebugReportFlagBitsEXT values" + } + ] + }, + "vkDebugReportMessageEXT": { + "(VK_EXT_debug_report)": [ + { + "vuid": "VUID-vkDebugReportMessageEXT-object-01241", + "text": " object must be a Vulkan object or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-objectType-01498", + "text": " If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in &amp;lt;&amp;lt;debug-report-object-types&amp;gt;&amp;gt;." + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-flags-parameter", + "text": " flags must be a valid combination of VkDebugReportFlagBitsEXT values" + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-flags-requiredbitmask", + "text": " flags must not be 0" + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-objectType-parameter", + "text": " objectType must be a valid VkDebugReportObjectTypeEXT value" + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter", + "text": " pLayerPrefix must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-pMessage-parameter", + "text": " pMessage must be a null-terminated UTF-8 string" + } + ] + }, + "vkDestroyDebugReportCallbackEXT": { + "(VK_EXT_debug_report)": [ + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01242", + "text": " If VkAllocationCallbacks were provided when callback was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01243", + "text": " If no VkAllocationCallbacks were provided when callback was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-callback-parameter", + "text": " callback must be a valid VkDebugReportCallbackEXT handle" + }, + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-callback-parent", + "text": " callback must have been created, allocated, or retrieved from instance" + } + ] + } + } +} \ No newline at end of file diff --git a/generator/Vulkan-Headers/registry/vk.xml b/generator/Vulkan-Headers/registry/vk.xml new file mode 100644 index 0000000..99f0c6a --- /dev/null +++ b/generator/Vulkan-Headers/registry/vk.xml @@ -0,0 +1,8842 @@ + + + +Copyright (c) 2015-2018 The Khronos Group Inc. + +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. + +---- Exceptions to the Apache 2.0 License: ---- + +As an exception, if you use this Software to generate code and portions of +this Software are embedded into the generated code as a result, you may +redistribute such product without providing attribution as would otherwise +be required by Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link code generated by this Software with +software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1 +("`Combined Software`") and if a court of competent jurisdiction determines +that the patent provision (Section 3), the indemnity provision (Section 9) +or other Section of the License conflicts with the conditions of the +applicable GPL or LGPL license, you may retroactively and prospectively +choose to deem waived or otherwise exclude such Section(s) of the License, +but only in their entirety and only with respect to the Combined Software. + + + +This file, vk.xml, is the Vulkan API Registry. It is a critically important +and normative part of the Vulkan Specification, including a canonical +machine-readable definition of the API, parameter and member validation +language incorporated into the Specification and reference pages, and other +material which is registered by Khronos, such as tags used by extension and +layer authors. The authoritative public version of vk.xml is maintained in +the master branch of the Khronos Vulkan GitHub project. The authoritative +private version is maintained in the master branch of the member gitlab +server. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + #include "vk_platform.h" + + WSI extensions + + + + + + + + + In the current header structure, each platform's interfaces + are confined to a platform-specific header (vulkan_xlib.h, + vulkan_win32.h, etc.). These headers are not self-contained, + and should not include native headers (X11/Xlib.h, + windows.h, etc.). Code should either include vulkan.h after + defining the appropriate VK_USE_PLATFORM_platform_KHR + macros, or include the required native headers prior to + explicitly including the corresponding platform header. + + To accomplish this, the dependencies of native types require + native headers, but the XML defines the content for those + native headers as empty. The actual native header includes + can be restored by modifying the native header tags above + to #include the header file in the 'name' attribute. + + + + + + + + + + + + + + + + + + + + + #define VK_MAKE_VERSION(major, minor, patch) \ + (((major) << 22) | ((minor) << 12) | (patch)) + #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) + #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) + #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) + + // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 + // Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 + // Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 + // Version of this file +#define VK_HEADER_VERSION 79 + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +#else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +#endif +#endif + + + +#define VK_NULL_HANDLE 0 + + + struct ANativeWindow; + struct AHardwareBuffer; + + typedef uint32_t VkSampleMask; + typedef uint32_t VkBool32; + typedef uint32_t VkFlags; + typedef uint64_t VkDeviceSize; + + Basic C types, pulled in via vk_platform.h + + + + + + + + + + + Bitmask types + typedef VkFlags VkFramebufferCreateFlags; + typedef VkFlags VkQueryPoolCreateFlags; + typedef VkFlags VkRenderPassCreateFlags; + typedef VkFlags VkSamplerCreateFlags; + typedef VkFlags VkPipelineLayoutCreateFlags; + typedef VkFlags VkPipelineCacheCreateFlags; + typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + typedef VkFlags VkPipelineDynamicStateCreateFlags; + typedef VkFlags VkPipelineColorBlendStateCreateFlags; + typedef VkFlags VkPipelineMultisampleStateCreateFlags; + typedef VkFlags VkPipelineRasterizationStateCreateFlags; + typedef VkFlags VkPipelineViewportStateCreateFlags; + typedef VkFlags VkPipelineTessellationStateCreateFlags; + typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; + typedef VkFlags VkPipelineVertexInputStateCreateFlags; + typedef VkFlags VkPipelineShaderStageCreateFlags; + typedef VkFlags VkDescriptorSetLayoutCreateFlags; + typedef VkFlags VkBufferViewCreateFlags; + typedef VkFlags VkInstanceCreateFlags; + typedef VkFlags VkDeviceCreateFlags; + typedef VkFlags VkDeviceQueueCreateFlags; + typedef VkFlags VkQueueFlags; + typedef VkFlags VkMemoryPropertyFlags; + typedef VkFlags VkMemoryHeapFlags; + typedef VkFlags VkAccessFlags; + typedef VkFlags VkBufferUsageFlags; + typedef VkFlags VkBufferCreateFlags; + typedef VkFlags VkShaderStageFlags; + typedef VkFlags VkImageUsageFlags; + typedef VkFlags VkImageCreateFlags; + typedef VkFlags VkImageViewCreateFlags; + typedef VkFlags VkPipelineCreateFlags; + typedef VkFlags VkColorComponentFlags; + typedef VkFlags VkFenceCreateFlags; + typedef VkFlags VkSemaphoreCreateFlags; + typedef VkFlags VkFormatFeatureFlags; + typedef VkFlags VkQueryControlFlags; + typedef VkFlags VkQueryResultFlags; + typedef VkFlags VkShaderModuleCreateFlags; + typedef VkFlags VkEventCreateFlags; + typedef VkFlags VkCommandPoolCreateFlags; + typedef VkFlags VkCommandPoolResetFlags; + typedef VkFlags VkCommandBufferResetFlags; + typedef VkFlags VkCommandBufferUsageFlags; + typedef VkFlags VkQueryPipelineStatisticFlags; + typedef VkFlags VkMemoryMapFlags; + typedef VkFlags VkImageAspectFlags; + typedef VkFlags VkSparseMemoryBindFlags; + typedef VkFlags VkSparseImageFormatFlags; + typedef VkFlags VkSubpassDescriptionFlags; + typedef VkFlags VkPipelineStageFlags; + typedef VkFlags VkSampleCountFlags; + typedef VkFlags VkAttachmentDescriptionFlags; + typedef VkFlags VkStencilFaceFlags; + typedef VkFlags VkCullModeFlags; + typedef VkFlags VkDescriptorPoolCreateFlags; + typedef VkFlags VkDescriptorPoolResetFlags; + typedef VkFlags VkDependencyFlags; + typedef VkFlags VkSubgroupFeatureFlags; + typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; + typedef VkFlags VkObjectEntryUsageFlagsNVX; + + typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + + + WSI extensions + typedef VkFlags VkCompositeAlphaFlagsKHR; + typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; + typedef VkFlags VkSurfaceTransformFlagsKHR; + typedef VkFlags VkSwapchainCreateFlagsKHR; + typedef VkFlags VkDisplayModeCreateFlagsKHR; + typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + typedef VkFlags VkMirSurfaceCreateFlagsKHR; + typedef VkFlags VkViSurfaceCreateFlagsNN; + typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + typedef VkFlags VkPeerMemoryFeatureFlags; + + typedef VkFlags VkMemoryAllocateFlags; + + typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; + + typedef VkFlags VkDebugReportFlagsEXT; + typedef VkFlags VkCommandPoolTrimFlags; + + typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + typedef VkFlags VkExternalMemoryFeatureFlagsNV; + typedef VkFlags VkExternalMemoryHandleTypeFlags; + + typedef VkFlags VkExternalMemoryFeatureFlags; + + typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + + typedef VkFlags VkExternalSemaphoreFeatureFlags; + + typedef VkFlags VkSemaphoreImportFlags; + + typedef VkFlags VkExternalFenceHandleTypeFlags; + + typedef VkFlags VkExternalFenceFeatureFlags; + + typedef VkFlags VkFenceImportFlags; + + typedef VkFlags VkSurfaceCounterFlagsEXT; + typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + typedef VkFlags VkValidationCacheCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; + typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + typedef VkFlags VkDescriptorBindingFlagsEXT; + + Types which can be void pointers or class pointers, selected at compile time + VK_DEFINE_HANDLE(VkInstance) + VK_DEFINE_HANDLE(VkPhysicalDevice) + VK_DEFINE_HANDLE(VkDevice) + VK_DEFINE_HANDLE(VkQueue) + VK_DEFINE_HANDLE(VkCommandBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) + + WSI extensions + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) + + Types generated from corresponding enums tags below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Extensions + + + + + + + + + + + + + + + + + + WSI extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Enumerated types in the header, but not used by the API + + + The PFN_vk*Function types are used by VkAllocationCallbacks below + typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + + The PFN_vkVoidFunction type are used by VkGet*ProcAddr below + typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); + + The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + + The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + + Struct types + + VkStructureType sType + struct VkBaseOutStructure* pNext + + + VkStructureType sType + const struct VkBaseInStructure* pNext + + + int32_t x + int32_t y + + + int32_t x + int32_t y + int32_t z + + + uint32_t width + uint32_t height + + + uint32_t width + uint32_t height + uint32_t depth + + + float x + float y + float width + float height + float minDepth + float maxDepth + + + VkOffset2D offset + VkExtent2D extent + + + VkRect2D rect + uint32_t baseArrayLayer + uint32_t layerCount + + + VkComponentSwizzle r + VkComponentSwizzle g + VkComponentSwizzle b + VkComponentSwizzle a + + + uint32_t apiVersion + uint32_t driverVersion + uint32_t vendorID + uint32_t deviceID + VkPhysicalDeviceType deviceType + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + VkPhysicalDeviceLimits limits + VkPhysicalDeviceSparseProperties sparseProperties + + + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]extension name + uint32_t specVersionversion of the extension specification implemented + + + char layerName[VK_MAX_EXTENSION_NAME_SIZE]layer name + uint32_t specVersionversion of the layer specification implemented + uint32_t implementationVersionbuild or release version of the layer's library + char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the layer + + + VkStructureType sType + const void* pNext + const char* pApplicationName + uint32_t applicationVersion + const char* pEngineName + uint32_t engineVersion + uint32_t apiVersion + + + void* pUserData + PFN_vkAllocationFunction pfnAllocation + PFN_vkReallocationFunction pfnReallocation + PFN_vkFreeFunction pfnFree + PFN_vkInternalAllocationNotification pfnInternalAllocation + PFN_vkInternalFreeNotification pfnInternalFree + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueCount + const float* pQueuePriorities + + + VkStructureType sType + const void* pNext + VkDeviceCreateFlags flags + uint32_t queueCreateInfoCount + const VkDeviceQueueCreateInfo* pQueueCreateInfos + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNames + const VkPhysicalDeviceFeatures* pEnabledFeatures + + + VkStructureType sType + const void* pNext + VkInstanceCreateFlags flags + const VkApplicationInfo* pApplicationInfo + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNamesExtension names to be enabled + + + VkQueueFlags queueFlagsQueue flags + uint32_t queueCount + uint32_t timestampValidBits + VkExtent3D minImageTransferGranularityMinimum alignment requirement for image transfers + + + uint32_t memoryTypeCount + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES] + uint32_t memoryHeapCount + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] + + + VkStructureType sType + const void* pNext + VkDeviceSize allocationSizeSize of memory allocation + uint32_t memoryTypeIndexIndex of the of the memory type to allocate from + + + VkDeviceSize sizeSpecified in bytes + VkDeviceSize alignmentSpecified in bytes + uint32_t memoryTypeBitsBitmask of the allowed memory type indices into memoryTypes[] for this object + + + VkImageAspectFlags aspectMask + VkExtent3D imageGranularity + VkSparseImageFormatFlags flags + + + VkSparseImageFormatProperties formatProperties + uint32_t imageMipTailFirstLod + VkDeviceSize imageMipTailSizeSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailOffsetSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailStrideSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + + + VkMemoryPropertyFlags propertyFlagsMemory properties of this memory type + uint32_t heapIndexIndex of the memory heap allocations of this memory type are taken from + + + VkDeviceSize sizeAvailable memory in the heap + VkMemoryHeapFlags flagsFlags for the heap + + + VkStructureType sType + const void* pNext + VkDeviceMemory memoryMapped memory object + VkDeviceSize offsetOffset within the memory object where the range starts + VkDeviceSize sizeSize of the range within the memory object + + + VkFormatFeatureFlags linearTilingFeaturesFormat features in case of linear tiling + VkFormatFeatureFlags optimalTilingFeaturesFormat features in case of optimal tiling + VkFormatFeatureFlags bufferFeaturesFormat features supported by buffers + + + VkExtent3D maxExtentmax image dimensions for this resource type + uint32_t maxMipLevelsmax number of mipmap levels for this resource type + uint32_t maxArrayLayersmax array size for this resource type + VkSampleCountFlags sampleCountssupported sample counts for this resource type + VkDeviceSize maxResourceSizemax size (in bytes) of this resource type + + + VkBuffer bufferBuffer used for this descriptor slot when the descriptor is UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC]. VK_NULL_HANDLE otherwise. + VkDeviceSize offsetBase offset from buffer start in bytes to update in the descriptor set. + VkDeviceSize rangeSize in bytes of the buffer resource for this descriptor update. + + + VkSampler samplerSampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise. + VkImageView imageViewImage view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise. + VkImageLayout imageLayoutLayout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE). + + + VkStructureType sType + const void* pNext + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + VkDescriptorType descriptorTypeDescriptor type to write (determines which members of the array pointed by pDescriptors are going to be used) + const VkDescriptorImageInfo* pImageInfoSampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types. + const VkDescriptorBufferInfo* pBufferInfoRaw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types. + const VkBufferView* pTexelBufferViewBuffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types. + + + VkStructureType sType + const void* pNext + VkDescriptorSet srcSetSource descriptor set + uint32_t srcBindingBinding within the source descriptor set to copy from + uint32_t srcArrayElementArray element within the source binding to copy from + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to copy to + uint32_t dstArrayElementArray element within the destination binding to copy to + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flagsBuffer creation flags + VkDeviceSize sizeSpecified in bytes + VkBufferUsageFlags usageBuffer usage flags + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + + + VkStructureType sType + const void* pNext + VkBufferViewCreateFlagsflags + VkBuffer buffer + VkFormat formatOptionally specifies format of elements + VkDeviceSize offsetSpecified in bytes + VkDeviceSize rangeView size specified in bytes + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t arrayLayer + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t baseArrayLayer + uint32_t layerCount + + + VkImageAspectFlags aspectMask + uint32_t baseMipLevel + uint32_t levelCount + uint32_t baseArrayLayer + uint32_t layerCount + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkBuffer bufferBuffer to sync + VkDeviceSize offsetOffset within the buffer to sync + VkDeviceSize sizeAmount of bytes to sync + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkImageLayout oldLayoutCurrent layout of the image + VkImageLayout newLayoutNew layout to transition the image to + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkImage imageImage to sync + VkImageSubresourceRange subresourceRangeSubresource range to sync + + + VkStructureType sType + const void* pNext + VkImageCreateFlags flagsImage creation flags + VkImageType imageType + VkFormat format + VkExtent3D extent + uint32_t mipLevels + uint32_t arrayLayers + VkSampleCountFlagBits samples + VkImageTiling tiling + VkImageUsageFlags usageImage usage flags + VkSharingMode sharingModeCross-queue-family sharing mode + uint32_t queueFamilyIndexCountNumber of queue families to share across + const uint32_t* pQueueFamilyIndicesArray of queue family indices to share across + VkImageLayout initialLayoutInitial image layout for all subresources + + + VkDeviceSize offsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceSize rowPitchSpecified in bytes + VkDeviceSize arrayPitchSpecified in bytes + VkDeviceSize depthPitchSpecified in bytes + + + VkStructureType sType + const void* pNext + VkImageViewCreateFlags flags + VkImage image + VkImageViewType viewType + VkFormat format + VkComponentMapping components + VkImageSubresourceRange subresourceRange + + + VkDeviceSize srcOffsetSpecified in bytes + VkDeviceSize dstOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + + + VkDeviceSize resourceOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlagsflags + + + VkImageSubresource subresource + VkOffset3D offset + VkExtent3D extent + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlagsflags + + + VkBuffer buffer + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseImageMemoryBind* pBinds + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + uint32_t bufferBindCount + const VkSparseBufferMemoryBindInfo* pBufferBinds + uint32_t imageOpaqueBindCount + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds + uint32_t imageBindCount + const VkSparseImageMemoryBindInfo* pImageBinds + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D extentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images + + + VkDeviceSize bufferOffsetSpecified in bytes + uint32_t bufferRowLengthSpecified in texels + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + + VkStructureType sType + const void* pNext + VkShaderModuleCreateFlags flags + size_t codeSizeSpecified in bytes + const uint32_t* pCodeBinary code of size codeSize + + + uint32_t bindingBinding number for this entry + VkDescriptorType descriptorTypeType of the descriptors in this binding + uint32_t descriptorCountNumber of descriptors in this binding + VkShaderStageFlags stageFlagsShader stages this binding is visible to + const VkSampler* pImmutableSamplersImmutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements) + + + VkStructureType sType + const void* pNext + VkDescriptorSetLayoutCreateFlags flags + uint32_t bindingCountNumber of bindings in the descriptor set layout + const VkDescriptorSetLayoutBinding* pBindingsArray of descriptor set layout bindings + + + VkDescriptorType type + uint32_t descriptorCount + + + VkStructureType sType + const void* pNext + VkDescriptorPoolCreateFlags flags + uint32_t maxSets + uint32_t poolSizeCount + const VkDescriptorPoolSize* pPoolSizes + + + VkStructureType sType + const void* pNext + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSetLayout* pSetLayouts + + + uint32_t constantIDThe SpecConstant ID specified in the BIL + uint32_t offsetOffset of the value in the data block + size_t sizeSize in bytes of the SpecConstant + + + uint32_t mapEntryCountNumber of entries in the map + const VkSpecializationMapEntry* pMapEntriesArray of map entries + size_t dataSizeSize in bytes of pData + const void* pDataPointer to SpecConstant data + + + VkStructureType sType + const void* pNext + VkPipelineShaderStageCreateFlags flags + VkShaderStageFlagBits stageShader stage + VkShaderModule moduleModule containing entry point + const char* pNameNull-terminated entry point name + const VkSpecializationInfo* pSpecializationInfo + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + VkPipelineShaderStageCreateInfo stage + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + uint32_t bindingVertex buffer binding id + uint32_t strideDistance between vertices in bytes (0 = no advancement) + VkVertexInputRate inputRateThe rate at which the vertex data is consumed + + + uint32_t locationlocation of the shader vertex attrib + uint32_t bindingVertex buffer binding id + VkFormat formatformat of source data + uint32_t offsetOffset of first element in bytes from base of vertex + + + VkStructureType sType + const void* pNext + VkPipelineVertexInputStateCreateFlags flags + uint32_t vertexBindingDescriptionCountnumber of bindings + const VkVertexInputBindingDescription* pVertexBindingDescriptions + uint32_t vertexAttributeDescriptionCountnumber of attributes + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions + + + VkStructureType sType + const void* pNext + VkPipelineInputAssemblyStateCreateFlags flags + VkPrimitiveTopology topology + VkBool32 primitiveRestartEnable + + + VkStructureType sType + const void* pNext + VkPipelineTessellationStateCreateFlags flags + uint32_t patchControlPoints + + + VkStructureType sType + const void* pNext + VkPipelineViewportStateCreateFlags flags + uint32_t viewportCount + const VkViewport* pViewports + uint32_t scissorCount + const VkRect2D* pScissors + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationStateCreateFlags flags + VkBool32 depthClampEnable + VkBool32 rasterizerDiscardEnable + VkPolygonMode polygonModeoptional (GL45) + VkCullModeFlags cullMode + VkFrontFace frontFace + VkBool32 depthBiasEnable + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + float lineWidth + + + VkStructureType sType + const void* pNext + VkPipelineMultisampleStateCreateFlags flags + VkSampleCountFlagBits rasterizationSamplesNumber of samples used for rasterization + VkBool32 sampleShadingEnableoptional (GL45) + float minSampleShadingoptional (GL45) + const VkSampleMask* pSampleMaskArray of sampleMask words + VkBool32 alphaToCoverageEnable + VkBool32 alphaToOneEnable + + + VkBool32 blendEnable + VkBlendFactor srcColorBlendFactor + VkBlendFactor dstColorBlendFactor + VkBlendOp colorBlendOp + VkBlendFactor srcAlphaBlendFactor + VkBlendFactor dstAlphaBlendFactor + VkBlendOp alphaBlendOp + VkColorComponentFlags colorWriteMask + + + VkStructureType sType + const void* pNext + VkPipelineColorBlendStateCreateFlags flags + VkBool32 logicOpEnable + VkLogicOp logicOp + uint32_t attachmentCount# of pAttachments + const VkPipelineColorBlendAttachmentState* pAttachments + float blendConstants[4] + + + VkStructureType sType + const void* pNext + VkPipelineDynamicStateCreateFlags flags + uint32_t dynamicStateCount + const VkDynamicState* pDynamicStates + + + VkStencilOp failOp + VkStencilOp passOp + VkStencilOp depthFailOp + VkCompareOp compareOp + uint32_t compareMask + uint32_t writeMask + uint32_t reference + + + VkStructureType sType + const void* pNext + VkPipelineDepthStencilStateCreateFlags flags + VkBool32 depthTestEnable + VkBool32 depthWriteEnable + VkCompareOp depthCompareOp + VkBool32 depthBoundsTestEnableoptional (depth_bounds_test) + VkBool32 stencilTestEnable + VkStencilOpState front + VkStencilOpState back + float minDepthBounds + float maxDepthBounds + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + const VkPipelineVertexInputStateCreateInfo* pVertexInputState + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState + const VkPipelineTessellationStateCreateInfo* pTessellationState + const VkPipelineViewportStateCreateInfo* pViewportState + const VkPipelineRasterizationStateCreateInfo* pRasterizationState + const VkPipelineMultisampleStateCreateInfo* pMultisampleState + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState + const VkPipelineColorBlendStateCreateInfo* pColorBlendState + const VkPipelineDynamicStateCreateInfo* pDynamicState + VkPipelineLayout layoutInterface layout of the pipeline + VkRenderPass renderPass + uint32_t subpass + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkPipelineCacheCreateFlags flags + size_t initialDataSizeSize of initial data to populate cache, in bytes + const void* pInitialDataInitial data to populate cache + + + VkShaderStageFlags stageFlagsWhich stages use the range + uint32_t offsetStart of the range, in bytes + uint32_t sizeSize of the range, in bytes + + + VkStructureType sType + const void* pNext + VkPipelineLayoutCreateFlags flags + uint32_t setLayoutCountNumber of descriptor sets interfaced by the pipeline + const VkDescriptorSetLayout* pSetLayoutsArray of setCount number of descriptor set layout objects defining the layout of the + uint32_t pushConstantRangeCountNumber of push-constant ranges used by the pipeline + const VkPushConstantRange* pPushConstantRangesArray of pushConstantRangeCount number of ranges used by various shader stages + + + VkStructureType sType + const void* pNext + VkSamplerCreateFlags flags + VkFilter magFilterFilter mode for magnification + VkFilter minFilterFilter mode for minifiation + VkSamplerMipmapMode mipmapModeMipmap selection mode + VkSamplerAddressMode addressModeU + VkSamplerAddressMode addressModeV + VkSamplerAddressMode addressModeW + float mipLodBias + VkBool32 anisotropyEnable + float maxAnisotropy + VkBool32 compareEnable + VkCompareOp compareOp + float minLod + float maxLod + VkBorderColor borderColor + VkBool32 unnormalizedCoordinates + + + VkStructureType sType + const void* pNext + VkCommandPoolCreateFlags flagsCommand pool creation flags + uint32_t queueFamilyIndex + + + VkStructureType sType + const void* pNext + VkCommandPool commandPool + VkCommandBufferLevel level + uint32_t commandBufferCount + + + VkStructureType sType + const void* pNext + VkRenderPass renderPassRender pass for secondary command buffers + uint32_t subpass + VkFramebuffer framebufferFramebuffer for secondary command buffers + VkBool32 occlusionQueryEnableWhether this secondary command buffer may be executed during an occlusion query + VkQueryControlFlags queryFlagsQuery flags used by this secondary command buffer, if executed during an occlusion query + VkQueryPipelineStatisticFlags pipelineStatisticsPipeline statistics that may be counted for this secondary command buffer + + + VkStructureType sType + const void* pNext + VkCommandBufferUsageFlags flagsCommand buffer usage flags + const VkCommandBufferInheritanceInfo* pInheritanceInfoPointer to inheritance info for secondary command buffers + + + VkStructureType sType + const void* pNext + VkRenderPass renderPass + VkFramebuffer framebuffer + VkRect2D renderArea + uint32_t clearValueCount + const VkClearValue* pClearValues + + + float float32[4] + int32_t int32[4] + uint32_t uint32[4] + + + float depth + uint32_t stencil + + + VkClearColorValue color + VkClearDepthStencilValue depthStencil + + + VkImageAspectFlags aspectMask + uint32_t colorAttachment + VkClearValue clearValue + + + VkAttachmentDescriptionFlags flags + VkFormat format + VkSampleCountFlagBits samples + VkAttachmentLoadOp loadOpLoad operation for color or depth data + VkAttachmentStoreOp storeOpStore operation for color or depth data + VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data + VkAttachmentStoreOp stencilStoreOpStore operation for stencil data + VkImageLayout initialLayout + VkImageLayout finalLayout + + + uint32_t attachment + VkImageLayout layout + + + VkSubpassDescriptionFlags flags + VkPipelineBindPoint pipelineBindPointMust be VK_PIPELINE_BIND_POINT_GRAPHICS for now + uint32_t inputAttachmentCount + const VkAttachmentReference* pInputAttachments + uint32_t colorAttachmentCount + const VkAttachmentReference* pColorAttachments + const VkAttachmentReference* pResolveAttachments + const VkAttachmentReference* pDepthStencilAttachment + uint32_t preserveAttachmentCount + const uint32_t* pPreserveAttachments + + + uint32_t srcSubpass + uint32_t dstSubpass + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkDependencyFlags dependencyFlags + + + VkStructureType sType + const void* pNext + VkRenderPassCreateFlags flags + uint32_t attachmentCount + const VkAttachmentDescription* pAttachments + uint32_t subpassCount + const VkSubpassDescription* pSubpasses + uint32_t dependencyCount + const VkSubpassDependency* pDependencies + + + VkStructureType sType + const void* pNext + VkEventCreateFlags flagsEvent creation flags + + + VkStructureType sType + const void* pNext + VkFenceCreateFlags flagsFence creation flags + + + VkBool32 robustBufferAccessout of bounds buffer accesses are well defined + VkBool32 fullDrawIndexUint32full 32-bit range of indices for indexed draw calls + VkBool32 imageCubeArrayimage views which are arrays of cube maps + VkBool32 independentBlendblending operations are controlled per-attachment + VkBool32 geometryShadergeometry stage + VkBool32 tessellationShadertessellation control and evaluation stage + VkBool32 sampleRateShadingper-sample shading and interpolation + VkBool32 dualSrcBlendblend operations which take two sources + VkBool32 logicOplogic operations + VkBool32 multiDrawIndirectmulti draw indirect + VkBool32 drawIndirectFirstInstanceindirect draws can use non-zero firstInstance + VkBool32 depthClampdepth clamping + VkBool32 depthBiasClampdepth bias clamping + VkBool32 fillModeNonSolidpoint and wireframe fill modes + VkBool32 depthBoundsdepth bounds test + VkBool32 wideLineslines with width greater than 1 + VkBool32 largePointspoints with size greater than 1 + VkBool32 alphaToOnethe fragment alpha component can be forced to maximum representable alpha value + VkBool32 multiViewportviewport arrays + VkBool32 samplerAnisotropyanisotropic sampler filtering + VkBool32 textureCompressionETC2ETC texture compression formats + VkBool32 textureCompressionASTC_LDRASTC LDR texture compression formats + VkBool32 textureCompressionBCBC1-7 texture compressed formats + VkBool32 occlusionQueryPreciseprecise occlusion queries returning actual sample counts + VkBool32 pipelineStatisticsQuerypipeline statistics query + VkBool32 vertexPipelineStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages + VkBool32 fragmentStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in the fragment stage + VkBool32 shaderTessellationAndGeometryPointSizetessellation and geometry stages can export point size + VkBool32 shaderImageGatherExtendedimage gather with run-time values and independent offsets + VkBool32 shaderStorageImageExtendedFormatsthe extended set of formats can be used for storage images + VkBool32 shaderStorageImageMultisamplemultisample images can be used for storage images + VkBool32 shaderStorageImageReadWithoutFormatread from storage image does not require format qualifier + VkBool32 shaderStorageImageWriteWithoutFormatwrite to storage image does not require format qualifier + VkBool32 shaderUniformBufferArrayDynamicIndexingarrays of uniform buffers can be accessed with dynamically uniform indices + VkBool32 shaderSampledImageArrayDynamicIndexingarrays of sampled images can be accessed with dynamically uniform indices + VkBool32 shaderStorageBufferArrayDynamicIndexingarrays of storage buffers can be accessed with dynamically uniform indices + VkBool32 shaderStorageImageArrayDynamicIndexingarrays of storage images can be accessed with dynamically uniform indices + VkBool32 shaderClipDistanceclip distance in shaders + VkBool32 shaderCullDistancecull distance in shaders + VkBool32 shaderFloat6464-bit floats (doubles) in shaders + VkBool32 shaderInt6464-bit integers in shaders + VkBool32 shaderInt1616-bit integers in shaders + VkBool32 shaderResourceResidencyshader can use texture operations that return resource residency information (requires sparseNonResident support) + VkBool32 shaderResourceMinLodshader can use texture operations that specify minimum resource LOD + VkBool32 sparseBindingSparse resources support: Resource memory can be managed at opaque page level rather than object level + VkBool32 sparseResidencyBufferSparse resources support: GPU can access partially resident buffers + VkBool32 sparseResidencyImage2DSparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images + VkBool32 sparseResidencyImage3DSparse resources support: GPU can access partially resident 3D images + VkBool32 sparseResidency2SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 2 samples + VkBool32 sparseResidency4SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 4 samples + VkBool32 sparseResidency8SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 8 samples + VkBool32 sparseResidency16SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 16 samples + VkBool32 sparseResidencyAliasedSparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) + VkBool32 variableMultisampleRatemultisample rate must be the same for all pipelines in a subpass + VkBool32 inheritedQueriesQueries may be inherited from primary to secondary command buffers + + + VkBool32 residencyStandard2DBlockShapeSparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard2DMultisampleBlockShapeSparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard3DBlockShapeSparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyAlignedMipSizeSparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail + VkBool32 residencyNonResidentStrictSparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded + + + resource maximum sizes + uint32_t maxImageDimension1Dmax 1D image dimension + uint32_t maxImageDimension2Dmax 2D image dimension + uint32_t maxImageDimension3Dmax 3D image dimension + uint32_t maxImageDimensionCubemax cubemap image dimension + uint32_t maxImageArrayLayersmax layers for image arrays + uint32_t maxTexelBufferElementsmax texel buffer size (fstexels) + uint32_t maxUniformBufferRangemax uniform buffer range (bytes) + uint32_t maxStorageBufferRangemax storage buffer range (bytes) + uint32_t maxPushConstantsSizemax size of the push constants pool (bytes) + memory limits + uint32_t maxMemoryAllocationCountmax number of device memory allocations supported + uint32_t maxSamplerAllocationCountmax number of samplers that can be allocated on a device + VkDeviceSize bufferImageGranularityGranularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage + VkDeviceSize sparseAddressSpaceSizeTotal address space available for sparse allocations (bytes) + descriptor set limits + uint32_t maxBoundDescriptorSetsmax number of descriptors sets that can be bound to a pipeline + uint32_t maxPerStageDescriptorSamplersmax number of samplers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorUniformBuffersmax number of uniform buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageBuffersmax number of storage buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorSampledImagesmax number of sampled images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageImagesmax number of storage images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorInputAttachmentsmax number of input attachments allowed per-stage in a descriptor set + uint32_t maxPerStageResourcesmax number of resources allowed by a single stage + uint32_t maxDescriptorSetSamplersmax number of samplers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersmax number of uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersDynamicmax number of dynamic uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersmax number of storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersDynamicmax number of dynamic storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetSampledImagesmax number of sampled images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageImagesmax number of storage images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetInputAttachmentsmax number of input attachments allowed in all stages in a descriptor set + vertex stage limits + uint32_t maxVertexInputAttributesmax number of vertex input attribute slots + uint32_t maxVertexInputBindingsmax number of vertex input binding slots + uint32_t maxVertexInputAttributeOffsetmax vertex input attribute offset added to vertex buffer offset + uint32_t maxVertexInputBindingStridemax vertex input binding stride + uint32_t maxVertexOutputComponentsmax number of output components written by vertex shader + tessellation control stage limits + uint32_t maxTessellationGenerationLevelmax level supported by tessellation primitive generator + uint32_t maxTessellationPatchSizemax patch size (vertices) + uint32_t maxTessellationControlPerVertexInputComponentsmax number of input components per-vertex in TCS + uint32_t maxTessellationControlPerVertexOutputComponentsmax number of output components per-vertex in TCS + uint32_t maxTessellationControlPerPatchOutputComponentsmax number of output components per-patch in TCS + uint32_t maxTessellationControlTotalOutputComponentsmax total number of per-vertex and per-patch output components in TCS + tessellation evaluation stage limits + uint32_t maxTessellationEvaluationInputComponentsmax number of input components per vertex in TES + uint32_t maxTessellationEvaluationOutputComponentsmax number of output components per vertex in TES + geometry stage limits + uint32_t maxGeometryShaderInvocationsmax invocation count supported in geometry shader + uint32_t maxGeometryInputComponentsmax number of input components read in geometry stage + uint32_t maxGeometryOutputComponentsmax number of output components written in geometry stage + uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage + uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage + fragment stage limits + uint32_t maxFragmentInputComponentsmax number of input components read in fragment stage + uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage + uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending + uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers + compute stage limits + uint32_t maxComputeSharedMemorySizemax total storage size of work group local storage (bytes) + uint32_t maxComputeWorkGroupCount[3]max num of compute work groups that may be dispatched by a single command (x,y,z) + uint32_t maxComputeWorkGroupInvocationsmax total compute invocations in a single local work group + uint32_t maxComputeWorkGroupSize[3]max local size of a compute work group (x,y,z) + uint32_t subPixelPrecisionBitsnumber bits of subpixel precision in screen x and y + uint32_t subTexelPrecisionBitsnumber bits of precision for selecting texel weights + uint32_t mipmapPrecisionBitsnumber bits of precision for selecting mipmap weights + uint32_t maxDrawIndexedIndexValuemax index value for indexed draw calls (for 32-bit indices) + uint32_t maxDrawIndirectCountmax draw count for indirect draw calls + float maxSamplerLodBiasmax absolute sampler LOD bias + float maxSamplerAnisotropymax degree of sampler anisotropy + uint32_t maxViewportsmax number of active viewports + uint32_t maxViewportDimensions[2]max viewport dimensions (x,y) + float viewportBoundsRange[2]viewport bounds range (min,max) + uint32_t viewportSubPixelBitsnumber bits of subpixel precision for viewport + size_t minMemoryMapAlignmentmin required alignment of pointers returned by MapMemory (bytes) + VkDeviceSize minTexelBufferOffsetAlignmentmin required alignment for texel buffer offsets (bytes) + VkDeviceSize minUniformBufferOffsetAlignmentmin required alignment for uniform buffer sizes and offsets (bytes) + VkDeviceSize minStorageBufferOffsetAlignmentmin required alignment for storage buffer offsets (bytes) + int32_t minTexelOffsetmin texel offset for OpTextureSampleOffset + uint32_t maxTexelOffsetmax texel offset for OpTextureSampleOffset + int32_t minTexelGatherOffsetmin texel offset for OpTextureGatherOffset + uint32_t maxTexelGatherOffsetmax texel offset for OpTextureGatherOffset + float minInterpolationOffsetfurthest negative offset for interpolateAtOffset + float maxInterpolationOffsetfurthest positive offset for interpolateAtOffset + uint32_t subPixelInterpolationOffsetBitsnumber of subpixel bits for interpolateAtOffset + uint32_t maxFramebufferWidthmax width for a framebuffer + uint32_t maxFramebufferHeightmax height for a framebuffer + uint32_t maxFramebufferLayersmax layer count for a layered framebuffer + VkSampleCountFlags framebufferColorSampleCountssupported color sample counts for a framebuffer + VkSampleCountFlags framebufferDepthSampleCountssupported depth sample counts for a framebuffer + VkSampleCountFlags framebufferStencilSampleCountssupported stencil sample counts for a framebuffer + VkSampleCountFlags framebufferNoAttachmentsSampleCountssupported sample counts for a framebuffer with no attachments + uint32_t maxColorAttachmentsmax number of color attachments per subpass + VkSampleCountFlags sampledImageColorSampleCountssupported color sample counts for a non-integer sampled image + VkSampleCountFlags sampledImageIntegerSampleCountssupported sample counts for an integer image + VkSampleCountFlags sampledImageDepthSampleCountssupported depth sample counts for a sampled image + VkSampleCountFlags sampledImageStencilSampleCountssupported stencil sample counts for a sampled image + VkSampleCountFlags storageImageSampleCountssupported sample counts for a storage image + uint32_t maxSampleMaskWordsmax number of sample mask words + VkBool32 timestampComputeAndGraphicstimestamps on graphics and compute queues + float timestampPeriodnumber of nanoseconds it takes for timestamp query value to increment by 1 + uint32_t maxClipDistancesmax number of clip distances + uint32_t maxCullDistancesmax number of cull distances + uint32_t maxCombinedClipAndCullDistancesmax combined number of user clipping + uint32_t discreteQueuePrioritiesdistinct queue priorities available + float pointSizeRange[2]range (min,max) of supported point sizes + float lineWidthRange[2]range (min,max) of supported line widths + float pointSizeGranularitygranularity of supported point sizes + float lineWidthGranularitygranularity of supported line widths + VkBool32 strictLinesline rasterization follows preferred rules + VkBool32 standardSampleLocationssupports standard sample locations for all supported sample counts + VkDeviceSize optimalBufferCopyOffsetAlignmentoptimal offset of buffer copies + VkDeviceSize optimalBufferCopyRowPitchAlignmentoptimal pitch of buffer copies + VkDeviceSize nonCoherentAtomSizeminimum size and alignment for non-coherent host-mapped device memory access + + + VkStructureType sType + const void* pNext + VkSemaphoreCreateFlags flagsSemaphore creation flags + + + VkStructureType sType + const void* pNext + VkQueryPoolCreateFlags flags + VkQueryType queryType + uint32_t queryCount + VkQueryPipelineStatisticFlags pipelineStatisticsOptional + + + VkStructureType sType + const void* pNext + VkFramebufferCreateFlags flags + VkRenderPass renderPass + uint32_t attachmentCount + const VkImageView* pAttachments + uint32_t width + uint32_t height + uint32_t layers + + + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + uint32_t x + uint32_t y + uint32_t z + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + const VkPipelineStageFlags* pWaitDstStageMask + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + WSI extensions + + VkDisplayKHR displayHandle of the display object + const char* displayNameName of the display + VkExtent2D physicalDimensionsIn millimeters? + VkExtent2D physicalResolutionMax resolution for CRT? + VkSurfaceTransformFlagsKHR supportedTransformsone or more bits from VkSurfaceTransformFlagsKHR + VkBool32 planeReorderPossibleVK_TRUE if the overlay plane's z-order can be changed on this display. + VkBool32 persistentContentVK_TRUE if this is a "smart" display that supports self-refresh/internal buffering. + + + VkDisplayKHR currentDisplayDisplay the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use. + uint32_t currentStackIndexCurrent z-order of the plane. + + + VkExtent2D visibleRegionVisible scanout region. + uint32_t refreshRateNumber of times per second the display is updated. + + + VkDisplayModeKHR displayModeHandle of this display mode. + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkStructureType sType + const void* pNext + VkDisplayModeCreateFlagsKHR flags + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkDisplayPlaneAlphaFlagsKHR supportedAlphaTypes of alpha blending supported, if any. + VkOffset2D minSrcPositionDoes the plane have any position and extent restrictions? + VkOffset2D maxSrcPosition + VkExtent2D minSrcExtent + VkExtent2D maxSrcExtent + VkOffset2D minDstPosition + VkOffset2D maxDstPosition + VkExtent2D minDstExtent + VkExtent2D maxDstExtent + + + VkStructureType sType + const void* pNext + VkDisplaySurfaceCreateFlagsKHR flags + VkDisplayModeKHR displayModeThe mode to use when displaying this surface + uint32_t planeIndexThe plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount. + uint32_t planeStackIndexThe z-order of the plane. + VkSurfaceTransformFlagBitsKHR transformTransform to apply to the images as part of the scanout operation + float globalAlphaGlobal alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR + VkDisplayPlaneAlphaFlagBitsKHR alphaModeWhat type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha. + VkExtent2D imageExtentsize of the images to use with this surface + + + VkStructureType sType + const void* pNext + VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display. + VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in. + VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. + + + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + + + VkStructureType sType + const void* pNext + VkAndroidSurfaceCreateFlagsKHR flags + struct ANativeWindow* window + + + VkStructureType sType + const void* pNext + VkMirSurfaceCreateFlagsKHR flags + MirConnection* connection + MirSurface* mirSurface + + + VkStructureType sType + const void* pNext + VkViSurfaceCreateFlagsNN flags + void* window + + + VkStructureType sType + const void* pNext + VkWaylandSurfaceCreateFlagsKHR flags + struct wl_display* display + struct wl_surface* surface + + + VkStructureType sType + const void* pNext + VkWin32SurfaceCreateFlagsKHR flags + HINSTANCE hinstance + HWND hwnd + + + VkStructureType sType + const void* pNext + VkXlibSurfaceCreateFlagsKHR flags + Display* dpy + Window window + + + VkStructureType sType + const void* pNext + VkXcbSurfaceCreateFlagsKHR flags + xcb_connection_t* connection + xcb_window_t window + + + VkFormat formatSupported pair of rendering format + VkColorSpaceKHR colorSpaceand color space for the surface + + + VkStructureType sType + const void* pNext + VkSwapchainCreateFlagsKHR flags + VkSurfaceKHR surfaceThe swapchain's target surface + uint32_t minImageCountMinimum number of presentation images the application needs + VkFormat imageFormatFormat of the presentation images + VkColorSpaceKHR imageColorSpaceColorspace of the presentation images + VkExtent2D imageExtentDimensions of the presentation images + uint32_t imageArrayLayersDetermines the number of views for multiview/stereo presentation + VkImageUsageFlags imageUsageBits indicating how the presentation images will be used + VkSharingMode imageSharingModeSharing mode used for the presentation images + uint32_t queueFamilyIndexCountNumber of queue families having access to the images in case of concurrent sharing mode + const uint32_t* pQueueFamilyIndicesArray of queue family indices having access to the images in case of concurrent sharing mode + VkSurfaceTransformFlagBitsKHR preTransformThe transform, relative to the device's natural orientation, applied to the image content prior to presentation + VkCompositeAlphaFlagBitsKHR compositeAlphaThe alpha blending mode used when compositing this surface with other surfaces in the window system + VkPresentModeKHR presentModeWhich presentation mode to use for presents on this swap chain + VkBool32 clippedSpecifies whether presentable images may be affected by window clip regions + VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCountNumber of semaphores to wait for before presenting + const VkSemaphore* pWaitSemaphoresSemaphores to wait for before presenting + uint32_t swapchainCountNumber of swapchains to present in this call + const VkSwapchainKHR* pSwapchainsSwapchains to present an image from + const uint32_t* pImageIndicesIndices of which presentable images to present + VkResult* pResultsOptional (i.e. if non-NULL) VkResult for each swapchain + + + VkStructureType sType + const void* pNext + VkDebugReportFlagsEXT flagsIndicates which events call this callback + PFN_vkDebugReportCallbackEXT pfnCallbackFunction pointer of a callback function + void* pUserDataUser data provided to callback function + + + VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT + const void* pNext + uint32_t disabledValidationCheckCountNumber of validation checks to disable + VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable + + + VkStructureType sType + const void* pNext + VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + const char* pObjectNameName to apply to the object + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + uint64_t tagNameThe name of the tag to set on the object + size_t tagSizeThe length in bytes of the tag data + const void* pTagTag data to attach to the object + + + VkStructureType sType + const void* pNext + const char* pMarkerNameName of the debug marker + float color[4]Optional color for debug marker + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + VkImageFormatProperties imageFormatProperties + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE handle + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeoutMilliseconds + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureType sType + const void* pNext + VkBool32 computeBindingPointSupport + + + VkStructureType sType + const void* pNext + uint32_t maxIndirectCommandsLayoutTokenCount + uint32_t maxObjectEntryCounts + uint32_t minSequenceCountBufferOffsetAlignment + uint32_t minSequenceIndexBufferOffsetAlignment + uint32_t minCommandsTokenBufferOffsetAlignment + + + VkIndirectCommandsTokenTypeNVX tokenType + VkBuffer bufferbuffer containing tableEntries and additional data for indirectCommands + VkDeviceSize offsetoffset from the base address of the buffer + + + VkIndirectCommandsTokenTypeNVX tokenType + uint32_t bindingUnitBinding unit for vertex attribute / descriptor set, offset for pushconstants + uint32_t dynamicCountNumber of variable dynamic values for descriptor set / push constants + uint32_t divisorRate the which the array is advanced per element (must be power of 2, minimum 1) + + + VkStructureType sType + const void* pNext + VkPipelineBindPoint pipelineBindPoint + VkIndirectCommandsLayoutUsageFlagsNVX flags + uint32_t tokenCount + const VkIndirectCommandsLayoutTokenNVX* pTokens + + + VkStructureType sType + const void* pNext + VkObjectTableNVX objectTable + VkIndirectCommandsLayoutNVX indirectCommandsLayout + uint32_t indirectCommandsTokenCount + const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens + uint32_t maxSequencesCount + VkCommandBuffer targetCommandBuffer + VkBuffer sequencesCountBuffer + VkDeviceSize sequencesCountOffset + VkBuffer sequencesIndexBuffer + VkDeviceSize sequencesIndexOffset + + + VkStructureType sType + const void* pNext + VkObjectTableNVX objectTable + VkIndirectCommandsLayoutNVX indirectCommandsLayout + uint32_t maxSequencesCount + + + VkStructureType sType + const void* pNext + uint32_t objectCount + const VkObjectEntryTypeNVX* pObjectEntryTypes + const uint32_t* pObjectEntryCounts + const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags + + uint32_t maxUniformBuffersPerDescriptor + uint32_t maxStorageBuffersPerDescriptor + uint32_t maxStorageImagesPerDescriptor + uint32_t maxSampledImagesPerDescriptor + uint32_t maxPipelineLayouts + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkPipeline pipeline + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkPipelineLayout pipelineLayout + VkDescriptorSet descriptorSet + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkBuffer buffer + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkBuffer buffer + VkIndexType indexType + + + VkObjectEntryTypeNVX type + VkObjectEntryUsageFlagsNVX flags + VkPipelineLayout pipelineLayout + VkShaderStageFlags stageFlags + + + VkStructureType sType + void* pNext + VkPhysicalDeviceFeatures features + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceProperties properties + + + + VkStructureType sType + void* pNext + VkFormatProperties formatProperties + + + + VkStructureType sType + void* pNext + VkImageFormatProperties imageFormatProperties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + + + + VkStructureType sType + void* pNext + VkQueueFamilyProperties queueFamilyProperties + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceMemoryProperties memoryProperties + + + + VkStructureType sType + void* pNext + VkSparseImageFormatProperties properties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + + + + VkStructureType sType + void* pNext + uint32_t maxPushDescriptors + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentRegionKHR* pRegionsThe regions that have changed + + + uint32_t rectangleCountNumber of rectangles in pRectangles + const VkRectLayerKHR* pRectanglesArray of rectangles that have changed in a swapchain's image(s) + + + VkOffset2D offsetupper-left corner of a rectangle that has not changed, in pixels of a presentation images + VkExtent2D extentDimensions of a rectangle that has not changed, in pixels of a presentation images + uint32_t layerLayer of a swapchain's image(s), for stereoscopic-3D images + + + VkStructureType sType + void* pNext + VkBool32 variablePointersStorageBuffer + VkBool32 variablePointers + + + + VkExternalMemoryFeatureFlags externalMemoryFeatures + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlags compatibleHandleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flags + VkBufferUsageFlags usage + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + void* pNext + uint8_t deviceUUID[VK_UUID_SIZE] + uint8_t driverUUID[VK_UUID_SIZE] + uint8_t deviceLUID[VK_LUID_SIZE] + uint32_t deviceNodeMask + VkBool32 deviceLUIDValid + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeouts + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures + + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreValuesCount + const uint64_t* pWaitSemaphoreValues + uint32_t signalSemaphoreValuesCount + const uint64_t* pSignalSemaphoreValues + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes + VkExternalFenceHandleTypeFlags compatibleHandleTypes + VkExternalFenceFeatureFlags externalFenceFeatures + + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + void* pNext + VkBool32 multiviewMultiple views in a renderpass + VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader + VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader + + + + VkStructureType sType + void* pNext + uint32_t maxMultiviewViewCountmax number of views in a subpass + uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass + + + + VkStructureType sType + const void* pNext + uint32_t subpassCount + const uint32_t* pViewMasks + uint32_t dependencyCount + const int32_t* pViewOffsets + uint32_t correlationMaskCount + const uint32_t* pCorrelationMasks + + + + VkStructureType sType + void* pNext + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + VkSurfaceCounterFlagsEXT supportedSurfaceCounters + + + VkStructureType sType + const void* pNext + VkDisplayPowerStateEXT powerState + + + VkStructureType sType + const void* pNext + VkDeviceEventTypeEXT deviceEvent + + + VkStructureType sType + const void* pNext + VkDisplayEventTypeEXT displayEvent + + + VkStructureType sType + const void* pNext + VkSurfaceCounterFlagsEXT surfaceCounters + + + VkStructureType sType + void* pNext + uint32_t physicalDeviceCount + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE] + VkBool32 subsetAllocation + + + + VkStructureType sType + const void* pNext + VkMemoryAllocateFlags flags + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + + + + VkStructureType sType + const void* pNext + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + uint32_t splitInstanceBindRegionCount + const VkRect2D* pSplitInstanceBindRegions + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + uint32_t deviceRenderAreaCount + const VkRect2D* pDeviceRenderAreas + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const uint32_t* pWaitSemaphoreDeviceIndices + uint32_t commandBufferCount + const uint32_t* pCommandBufferDeviceMasks + uint32_t signalSemaphoreCount + const uint32_t* pSignalSemaphoreDeviceIndices + + + + VkStructureType sType + const void* pNext + uint32_t resourceDeviceIndex + uint32_t memoryDeviceIndex + + + + VkStructureType sType + const void* pNext + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE] + VkDeviceGroupPresentModeFlagsKHR modes + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint32_t imageIndex + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t deviceMask + + + VkStructureType sType + const void* pNext + uint32_t swapchainCount + const uint32_t* pDeviceMasks + VkDeviceGroupPresentModeFlagBitsKHR mode + + + VkStructureType sType + const void* pNext + uint32_t physicalDeviceCount + const VkPhysicalDevice* pPhysicalDevices + + + + VkStructureType sType + const void* pNext + VkDeviceGroupPresentModeFlagsKHR modes + + + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write + VkDescriptorType descriptorTypeDescriptor type to write + size_t offsetOffset into pData where the descriptors to update are stored + size_t strideStride between two descriptors in pData when writing more than one descriptor + + + + VkStructureType sType + void* pNext + VkDescriptorUpdateTemplateCreateFlags flags + uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template + VkDescriptorUpdateTemplateType templateType + VkDescriptorSetLayout descriptorSetLayout + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayoutpipelineLayoutIf used for push descriptors, this is the only allowed layout + uint32_t set + + + + float x + float y + + + Display primary in chromaticity coordinates + VkStructureType sType + const void* pNext + From SMPTE 2086 + VkXYColorEXT displayPrimaryRedDisplay primary's Red + VkXYColorEXT displayPrimaryGreenDisplay primary's Green + VkXYColorEXT displayPrimaryBlueDisplay primary's Blue + VkXYColorEXT whitePointDisplay primary's Blue + float maxLuminanceDisplay maximum luminance + float minLuminanceDisplay minimum luminance + From CTA 861.3 + float maxContentLightLevelContent maximum luminance + float maxFrameAverageLightLevel + + + uint64_t refreshDurationNumber of nanoseconds from the start of one refresh cycle to the next + + + uint32_t presentIDApplication-provided identifier, previously given to vkQueuePresentKHR + uint64_t desiredPresentTimeEarliest time an image should have been presented, previously given to vkQueuePresentKHR + uint64_t actualPresentTimeTime the image was actually displayed + uint64_t earliestPresentTimeEarliest time the image could have been displayed + uint64_t presentMarginHow early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentTimeGOOGLE* pTimesThe earliest times to present images + + + uint32_t presentIDApplication-provided identifier + uint64_t desiredPresentTimeEarliest time an image should be presented + + + VkStructureType sType + const void* pNext + VkIOSSurfaceCreateFlagsMVK flags + const void* pView + + + VkStructureType sType + const void* pNext + VkMacOSSurfaceCreateFlagsMVK flags + const void* pView + + + float xcoeff + float ycoeff + + + VkStructureType sType + const void* pNext + VkBool32 viewportWScalingEnable + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + VkViewportCoordinateSwizzleNV x + VkViewportCoordinateSwizzleNV y + VkViewportCoordinateSwizzleNV z + VkViewportCoordinateSwizzleNV w + + + VkStructureType sType + const void* pNext + VkPipelineViewportSwizzleStateCreateFlagsNV flags + uint32_t viewportCount + const VkViewportSwizzleNV* pViewportSwizzles + + + VkStructureType sType + void* pNext + uint32_t maxDiscardRectanglesmax number of active discard rectangles + + + VkStructureType sType + const void* pNext + VkPipelineDiscardRectangleStateCreateFlagsEXT flags + VkDiscardRectangleModeEXT discardRectangleMode + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + VkStructureType sType + void* pNext + VkBool32 perViewPositionAllComponents + + + uint32_t subpass + uint32_t inputAttachmentIndex + VkImageAspectFlags aspectMask + + + + VkStructureType sType + const void* pNext + uint32_t aspectReferenceCount + const VkInputAttachmentAspectReference* pAspectReferences + + + + VkStructureType sType + const void* pNext + VkSurfaceKHR surface + + + VkStructureType sType + void* pNext + VkSurfaceCapabilitiesKHR surfaceCapabilities + + + VkStructureType sType + void* pNext + VkSurfaceFormatKHR surfaceFormat + + + VkStructureType sType + void* pNext + VkDisplayPropertiesKHR displayProperties + + + VkStructureType sType + void* pNext + VkDisplayPlanePropertiesKHR displayPlaneProperties + + + VkStructureType sType + void* pNext + VkDisplayModePropertiesKHR displayModeProperties + + + VkStructureType sType + const void* pNext + VkDisplayModeKHR mode + uint32_t planeIndex + + + VkStructureType sType + void* pNext + VkDisplayPlaneCapabilitiesKHR capabilities + + + VkStructureType sType + void* pNext + VkImageUsageFlags sharedPresentSupportedUsageFlagsSupported image usage flags if swapchain created using a shared present mode + + + VkStructureType sType + void* pNext + VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock + VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block + VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant + VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs + + + + VkStructureType sType + void* pNext + uint32_t subgroupSizeThe size of a subgroup for this queue. + VkShaderStageFlags supportedStagesBitfield of what shader stages support subgroup operations + VkSubgroupFeatureFlags supportedOperationsBitfield of what subgroup operations are supported. + VkBool32 quadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + void* pNext + VkMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkSparseImageMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkPointClippingBehavior pointClippingBehavior + + + + VkStructureType sType + void* pNext + VkBool32 prefersDedicatedAllocation + VkBool32 requiresDedicatedAllocation + + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + + VkStructureType sType + const void* pNext + VkImageUsageFlags usage + + + + VkStructureType sType + const void* pNext + VkTessellationDomainOrigin domainOrigin + + + + VkStructureType sType + const void* pNext + VkSamplerYcbcrConversion conversion + + + + VkStructureType sType + const void* pNext + VkFormat format + VkSamplerYcbcrModelConversion ycbcrModel + VkSamplerYcbcrRange ycbcrRange + VkComponentMapping components + VkChromaLocation xChromaOffset + VkChromaLocation yChromaOffset + VkFilter chromaFilter + VkBool32 forceExplicitReconstruction + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + void* pNext + VkBool32 samplerYcbcrConversionSampler color conversion supported + + + + VkStructureType sType + void* pNext + uint32_t combinedImageSamplerDescriptorCount + + + + VkStructureType sType + void* pNext + VkBool32 supportsTextureGatherLODBiasAMD + + + VkStructureType sType + const void* pNext + VkBool32 protectedSubmitSubmit protected command buffers + + + VkStructureType sType + void* pNext + VkBool32 protectedMemory + + + VkStructureType sType + void* pNext + VkBool32 protectedNoFault + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueIndex + + + VkStructureType sType + const void* pNext + VkPipelineCoverageToColorStateCreateFlagsNV flags + VkBool32 coverageToColorEnable + uint32_t coverageToColorLocation + + + VkStructureType sType + void* pNext + VkBool32 filterMinmaxSingleComponentFormats + VkBool32 filterMinmaxImageComponentMapping + + + float x + float y + + + VkStructureType sType + const void* pNext + VkSampleCountFlagBits sampleLocationsPerPixel + VkExtent2D sampleLocationGridSize + uint32_t sampleLocationsCount + const VkSampleLocationEXT* pSampleLocations + + + uint32_t attachmentIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + uint32_t subpassIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + const void* pNext + uint32_t attachmentInitialSampleLocationsCount + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations + uint32_t postSubpassSampleLocationsCount + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations + + + VkStructureType sType + const void* pNext + VkBool32 sampleLocationsEnable + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + void* pNext + VkSampleCountFlags sampleLocationSampleCounts + VkExtent2D maxSampleLocationGridSize + float sampleLocationCoordinateRange[2] + uint32_t sampleLocationSubPixelBits + VkBool32 variableSampleLocations + + + VkStructureType sType + void* pNext + VkExtent2D maxSampleLocationGridSize + + + VkStructureType sType + const void* pNext + VkSamplerReductionModeEXT reductionMode + + + VkStructureType sType + void* pNext + VkBool32 advancedBlendCoherentOperations + + + VkStructureType sType + void* pNext + uint32_t advancedBlendMaxColorAttachments + VkBool32 advancedBlendIndependentBlend + VkBool32 advancedBlendNonPremultipliedSrcColor + VkBool32 advancedBlendNonPremultipliedDstColor + VkBool32 advancedBlendCorrelatedOverlap + VkBool32 advancedBlendAllOperations + + + VkStructureType sType + const void* pNext + VkBool32 srcPremultiplied + VkBool32 dstPremultiplied + VkBlendOverlapEXT blendOverlap + + + VkStructureType sType + const void* pNext + VkPipelineCoverageModulationStateCreateFlagsNV flags + VkCoverageModulationModeNV coverageModulationMode + VkBool32 coverageModulationTableEnable + uint32_t coverageModulationTableCount + const float* pCoverageModulationTable + + + VkStructureType sType + const void* pNext + uint32_t viewFormatCount + const VkFormat* pViewFormats + + + VkStructureType sType + const void* pNext + VkValidationCacheCreateFlagsEXT flags + size_t initialDataSize + const void* pInitialData + + + VkStructureType sType + const void* pNext + VkValidationCacheEXT validationCache + + + VkStructureType sType + void* pNext + uint32_t maxPerSetDescriptors + VkDeviceSize maxMemoryAllocationSize + + + + VkStructureType sType + void* pNext + VkBool32 supported + + + + VkStructureType sType + void* pNext + VkBool32 shaderDrawParameters + + + VkStructureType sType + const void* pNext + const void* handle + int stride + int format + int usage + + + uint32_t numUsedVgprs + uint32_t numUsedSgprs + uint32_t ldsSizePerLocalWorkGroup + size_t ldsUsageSizeInBytes + size_t scratchMemUsageInBytes + + + VkShaderStageFlags shaderStageMask + VkShaderResourceUsageAMD resourceUsage + uint32_t numPhysicalVgprs + uint32_t numPhysicalSgprs + uint32_t numAvailableVgprs + uint32_t numAvailableSgprs + uint32_t computeWorkGroupSize[3] + + + VkStructureType sType + const void* pNext + VkQueueGlobalPriorityEXT globalPriority + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + const char* pObjectName + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + uint64_t tagName + size_t tagSize + const void* pTag + + + VkStructureType sType + const void* pNext + const char* pLabelName + float color[4] + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCreateFlagsEXT flags + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageType + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback + void* pUserData + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCallbackDataFlagsEXT flags + const char* pMessageIdName + int32_t messageIdNumber + const char* pMessage + uint32_t queueLabelCount + VkDebugUtilsLabelEXT* pQueueLabels + uint32_t cmdBufLabelCount + VkDebugUtilsLabelEXT* pCmdBufLabels + uint32_t objectCount + VkDebugUtilsObjectNameInfoEXT* pObjects + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + void* pHostPointer + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + void* pNext + VkDeviceSize minImportedHostPointerAlignment + + + VkStructureType sType + void* pNextPointer to next structure + float primitiveOverestimationSizeThe size in pixels the primitive is enlarged at each edge during conservative rasterization + float maxExtraPrimitiveOverestimationSizeThe maximum additional overestimation the client can specify in the pipeline state + float extraPrimitiveOverestimationSizeGranularityThe granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize + VkBool32 primitiveUnderestimationtrue if the implementation supports conservative rasterization underestimation mode + VkBool32 conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines + VkBool32 degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized + VkBool32 degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized + VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable + VkBool32 conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask + + + VkStructureType sType + void* pNextPointer to next structure + uint32_t shaderEngineCountnumber of shader engines + uint32_t shaderArraysPerEngineCountnumber of shader arrays + uint32_t computeUnitsPerShaderArraynumber of CUs per shader array + uint32_t simdPerComputeUnitnumber of SIMDs per compute unit + uint32_t wavefrontsPerSimdnumber of wavefront slots in each SIMD + uint32_t wavefrontSizenumber of threads per wavefront + uint32_t sgprsPerSimdnumber of physical SGPRs per SIMD + uint32_t minSgprAllocationminimum number of SGPRs that can be allocated by a wave + uint32_t maxSgprAllocationnumber of available SGPRs + uint32_t sgprAllocationGranularitySGPRs are allocated in groups of this size + uint32_t vgprsPerSimdnumber of physical VGPRs per SIMD + uint32_t minVgprAllocationminimum number of VGPRs that can be allocated by a wave + uint32_t maxVgprAllocationnumber of available VGPRs + uint32_t vgprAllocationGranularityVGPRs are allocated in groups of this size + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags + VkConservativeRasterizationModeEXT conservativeRasterizationMode + float extraPrimitiveOverestimationSize + + + VkStructureType sType + void* pNext + VkBool32 shaderInputAttachmentArrayDynamicIndexing + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing + VkBool32 shaderUniformBufferArrayNonUniformIndexing + VkBool32 shaderSampledImageArrayNonUniformIndexing + VkBool32 shaderStorageBufferArrayNonUniformIndexing + VkBool32 shaderStorageImageArrayNonUniformIndexing + VkBool32 shaderInputAttachmentArrayNonUniformIndexing + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing + VkBool32 descriptorBindingUniformBufferUpdateAfterBind + VkBool32 descriptorBindingSampledImageUpdateAfterBind + VkBool32 descriptorBindingStorageImageUpdateAfterBind + VkBool32 descriptorBindingStorageBufferUpdateAfterBind + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind + VkBool32 descriptorBindingUpdateUnusedWhilePending + VkBool32 descriptorBindingPartiallyBound + VkBool32 descriptorBindingVariableDescriptorCount + VkBool32 runtimeDescriptorArray + + + VkStructureType sType + void* pNext + uint32_t maxUpdateAfterBindDescriptorsInAllPools + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative + VkBool32 shaderSampledImageArrayNonUniformIndexingNative + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative + VkBool32 shaderStorageImageArrayNonUniformIndexingNative + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative + VkBool32 robustBufferAccessUpdateAfterBind + VkBool32 quadDivergentImplicitLod + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments + uint32_t maxPerStageUpdateAfterBindResources + uint32_t maxDescriptorSetUpdateAfterBindSamplers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindSampledImages + uint32_t maxDescriptorSetUpdateAfterBindStorageImages + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments + + + VkStructureType sType + const void* pNext + uint32_t bindingCount + const VkDescriptorBindingFlagsEXT* pBindingFlags + + + VkStructureType sType + const void* pNext + uint32_t descriptorSetCount + const uint32_t* pDescriptorCounts + + + VkStructureType sType + void* pNext + uint32_t maxVariableDescriptorCount + + + uint32_t binding + uint32_t divisor + + + VkStructureType sType + const void* pNext + uint32_t vertexBindingDivisorCount + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors + + + VkStructureType sType + void* pNext + uint32_t maxVertexAttribDivisormax value of vertex attribute divisor + + + VkStructureType sType + const void* pNext + struct AHardwareBuffer* buffer + + + VkStructureType sType + void* pNext + uint64_t androidHardwareBufferUsage + + + VkStructureType sType + void* pNext + VkDeviceSize allocationSize + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + + + VkStructureType sType + void* pNext + VkFormat format + uint64_t externalFormat + VkFormatFeatureFlags formatFeatures + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + void* pNext + uint64_t externalFormat + + + + Vulkan enumerant (token) definitions + + + + + + + + + + + + + + + + + + + + + + + + + + + + Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in + their own numeric namespaces. The "name" attribute is the C enum + type name, and is pulled in from a type tag definition above + (slightly clunky, but retains the type / enum distinction). "type" + attributes of "enum" or "bitmask" indicate that these values should + be generated inside an appropriate definition. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge + enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not + alias! + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Return codes (positive values) + + + + + + + Error codes (negative values) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Flags + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WSI Extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Vendor IDs are now represented as enums instead of the old + <vendorids> tag, allowing them to be included in the + API headers. + + + + + + + + + VkResult vkCreateInstance + const VkInstanceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkInstance* pInstance + + + void vkDestroyInstance + VkInstance instance + const VkAllocationCallbacks* pAllocator + + + VkResult vkEnumeratePhysicalDevices + VkInstance instance + uint32_t* pPhysicalDeviceCount + VkPhysicalDevice* pPhysicalDevices + + + PFN_vkVoidFunction vkGetDeviceProcAddr + VkDevice device + const char* pName + + + PFN_vkVoidFunction vkGetInstanceProcAddr + VkInstance instance + const char* pName + + + void vkGetPhysicalDeviceProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties* pProperties + + + void vkGetPhysicalDeviceQueueFamilyProperties + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties* pQueueFamilyProperties + + + void vkGetPhysicalDeviceMemoryProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties* pMemoryProperties + + + void vkGetPhysicalDeviceFeatures + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures* pFeatures + + + void vkGetPhysicalDeviceFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties* pFormatProperties + + + VkResult vkGetPhysicalDeviceImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkImageFormatProperties* pImageFormatProperties + + + VkResult vkCreateDevice + VkPhysicalDevice physicalDevice + const VkDeviceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDevice* pDevice + + + void vkDestroyDevice + VkDevice device + const VkAllocationCallbacks* pAllocator + + + VkResult vkEnumerateInstanceVersion + uint32_t* pApiVersion + + + VkResult vkEnumerateInstanceLayerProperties + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateInstanceExtensionProperties + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + VkResult vkEnumerateDeviceLayerProperties + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateDeviceExtensionProperties + VkPhysicalDevice physicalDevice + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + void vkGetDeviceQueue + VkDevice device + uint32_t queueFamilyIndex + uint32_t queueIndex + VkQueue* pQueue + + + VkResult vkQueueSubmit + VkQueue queue + uint32_t submitCount + const VkSubmitInfo* pSubmits + VkFence fence + + + VkResult vkQueueWaitIdle + VkQueue queue + + + VkResult vkDeviceWaitIdle + VkDevice device + + all sname:VkQueue objects created from pname:device + + + + VkResult vkAllocateMemory + VkDevice device + const VkMemoryAllocateInfo* pAllocateInfo + const VkAllocationCallbacks* pAllocator + VkDeviceMemory* pMemory + + + void vkFreeMemory + VkDevice device + VkDeviceMemory memory + const VkAllocationCallbacks* pAllocator + + + VkResult vkMapMemory + VkDevice device + VkDeviceMemory memory + VkDeviceSize offset + VkDeviceSize size + VkMemoryMapFlags flags + void** ppData + + + void vkUnmapMemory + VkDevice device + VkDeviceMemory memory + + + VkResult vkFlushMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + VkResult vkInvalidateMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + void vkGetDeviceMemoryCommitment + VkDevice device + VkDeviceMemory memory + VkDeviceSize* pCommittedMemoryInBytes + + + void vkGetBufferMemoryRequirements + VkDevice device + VkBuffer buffer + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindBufferMemory + VkDevice device + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageMemoryRequirements + VkDevice device + VkImage image + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindImageMemory + VkDevice device + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageSparseMemoryRequirements + VkDevice device + VkImage image + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements* pSparseMemoryRequirements + + + void vkGetPhysicalDeviceSparseImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + uint32_t* pPropertyCount + VkSparseImageFormatProperties* pProperties + + + VkResult vkQueueBindSparse + VkQueue queue + uint32_t bindInfoCount + const VkBindSparseInfo* pBindInfo + VkFence fence + + + VkResult vkCreateFence + VkDevice device + const VkFenceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + void vkDestroyFence + VkDevice device + VkFence fence + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + + + VkResult vkGetFenceStatus + VkDevice device + VkFence fence + + + VkResult vkWaitForFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + VkBool32 waitAll + uint64_t timeout + + + VkResult vkCreateSemaphore + VkDevice device + const VkSemaphoreCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSemaphore* pSemaphore + + + void vkDestroySemaphore + VkDevice device + VkSemaphore semaphore + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateEvent + VkDevice device + const VkEventCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkEvent* pEvent + + + void vkDestroyEvent + VkDevice device + VkEvent event + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetEventStatus + VkDevice device + VkEvent event + + + VkResult vkSetEvent + VkDevice device + VkEvent event + + + VkResult vkResetEvent + VkDevice device + VkEvent event + + + VkResult vkCreateQueryPool + VkDevice device + const VkQueryPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkQueryPool* pQueryPool + + + void vkDestroyQueryPool + VkDevice device + VkQueryPool queryPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetQueryPoolResults + VkDevice device + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + size_t dataSize + void* pData + VkDeviceSize stride + VkQueryResultFlags flags + + + VkResult vkCreateBuffer + VkDevice device + const VkBufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBuffer* pBuffer + + + void vkDestroyBuffer + VkDevice device + VkBuffer buffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateBufferView + VkDevice device + const VkBufferViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBufferView* pView + + + void vkDestroyBufferView + VkDevice device + VkBufferView bufferView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateImage + VkDevice device + const VkImageCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImage* pImage + + + void vkDestroyImage + VkDevice device + VkImage image + const VkAllocationCallbacks* pAllocator + + + void vkGetImageSubresourceLayout + VkDevice device + VkImage image + const VkImageSubresource* pSubresource + VkSubresourceLayout* pLayout + + + VkResult vkCreateImageView + VkDevice device + const VkImageViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImageView* pView + + + void vkDestroyImageView + VkDevice device + VkImageView imageView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateShaderModule + VkDevice device + const VkShaderModuleCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkShaderModule* pShaderModule + + + void vkDestroyShaderModule + VkDevice device + VkShaderModule shaderModule + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineCache + VkDevice device + const VkPipelineCacheCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineCache* pPipelineCache + + + void vkDestroyPipelineCache + VkDevice device + VkPipelineCache pipelineCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPipelineCacheData + VkDevice device + VkPipelineCache pipelineCache + size_t* pDataSize + void* pData + + + VkResult vkMergePipelineCaches + VkDevice device + VkPipelineCache dstCache + uint32_t srcCacheCount + const VkPipelineCache* pSrcCaches + + + VkResult vkCreateGraphicsPipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkGraphicsPipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateComputePipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkComputePipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + void vkDestroyPipeline + VkDevice device + VkPipeline pipeline + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineLayout + VkDevice device + const VkPipelineLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineLayout* pPipelineLayout + + + void vkDestroyPipelineLayout + VkDevice device + VkPipelineLayout pipelineLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateSampler + VkDevice device + const VkSamplerCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSampler* pSampler + + + void vkDestroySampler + VkDevice device + VkSampler sampler + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorSetLayout + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorSetLayout* pSetLayout + + + void vkDestroyDescriptorSetLayout + VkDevice device + VkDescriptorSetLayout descriptorSetLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorPool + VkDevice device + const VkDescriptorPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorPool* pDescriptorPool + + + void vkDestroyDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + VkDescriptorPoolResetFlags flags + + any sname:VkDescriptorSet objects allocated from pname:descriptorPool + + + + VkResult vkAllocateDescriptorSets + VkDevice device + const VkDescriptorSetAllocateInfo* pAllocateInfo + VkDescriptorSet* pDescriptorSets + + + VkResult vkFreeDescriptorSets + VkDevice device + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + + + void vkUpdateDescriptorSets + VkDevice device + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + uint32_t descriptorCopyCount + const VkCopyDescriptorSet* pDescriptorCopies + + + VkResult vkCreateFramebuffer + VkDevice device + const VkFramebufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFramebuffer* pFramebuffer + + + void vkDestroyFramebuffer + VkDevice device + VkFramebuffer framebuffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateRenderPass + VkDevice device + const VkRenderPassCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkRenderPass* pRenderPass + + + void vkDestroyRenderPass + VkDevice device + VkRenderPass renderPass + const VkAllocationCallbacks* pAllocator + + + void vkGetRenderAreaGranularity + VkDevice device + VkRenderPass renderPass + VkExtent2D* pGranularity + + + VkResult vkCreateCommandPool + VkDevice device + const VkCommandPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCommandPool* pCommandPool + + + void vkDestroyCommandPool + VkDevice device + VkCommandPool commandPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolResetFlags flags + + + VkResult vkAllocateCommandBuffers + VkDevice device + const VkCommandBufferAllocateInfo* pAllocateInfo + VkCommandBuffer* pCommandBuffers + + + void vkFreeCommandBuffers + VkDevice device + VkCommandPool commandPool + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkBeginCommandBuffer + VkCommandBuffer commandBuffer + const VkCommandBufferBeginInfo* pBeginInfo + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkEndCommandBuffer + VkCommandBuffer commandBuffer + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkResetCommandBuffer + VkCommandBuffer commandBuffer + VkCommandBufferResetFlags flags + + + void vkCmdBindPipeline + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + + + void vkCmdSetViewport + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewport* pViewports + + + void vkCmdSetScissor + VkCommandBuffer commandBuffer + uint32_t firstScissor + uint32_t scissorCount + const VkRect2D* pScissors + + + void vkCmdSetLineWidth + VkCommandBuffer commandBuffer + float lineWidth + + + void vkCmdSetDepthBias + VkCommandBuffer commandBuffer + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + + + void vkCmdSetBlendConstants + VkCommandBuffer commandBuffer + const float blendConstants[4] + + + void vkCmdSetDepthBounds + VkCommandBuffer commandBuffer + float minDepthBounds + float maxDepthBounds + + + void vkCmdSetStencilCompareMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t compareMask + + + void vkCmdSetStencilWriteMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t writeMask + + + void vkCmdSetStencilReference + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t reference + + + void vkCmdBindDescriptorSets + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t firstSet + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + uint32_t dynamicOffsetCount + const uint32_t* pDynamicOffsets + + + void vkCmdBindIndexBuffer + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkIndexType indexType + + + void vkCmdBindVertexBuffers + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + + + void vkCmdDraw + VkCommandBuffer commandBuffer + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + void vkCmdDrawIndexed + VkCommandBuffer commandBuffer + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + void vkCmdDrawIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDispatch + VkCommandBuffer commandBuffer + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + void vkCmdDispatchIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + + + void vkCmdCopyBuffer + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferCopy* pRegions + + + void vkCmdCopyImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageCopy* pRegions + + + void vkCmdBlitImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageBlit* pRegions + VkFilter filter + + + void vkCmdCopyBufferToImage + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdCopyImageToBuffer + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdUpdateBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize dataSize + const void* pData + + + void vkCmdFillBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize size + uint32_t data + + + void vkCmdClearColorImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearColorValue* pColor + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearDepthStencilImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearDepthStencilValue* pDepthStencil + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearAttachments + VkCommandBuffer commandBuffer + uint32_t attachmentCount + const VkClearAttachment* pAttachments + uint32_t rectCount + const VkClearRect* pRects + + + void vkCmdResolveImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageResolve* pRegions + + + void vkCmdSetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdResetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdWaitEvents + VkCommandBuffer commandBuffer + uint32_t eventCount + const VkEvent* pEvents + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdPipelineBarrier + VkCommandBuffer commandBuffer + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkDependencyFlags dependencyFlags + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdBeginQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + VkQueryControlFlags flags + + + void vkCmdEndQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + + + void vkCmdResetQueryPool + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + + + void vkCmdWriteTimestamp + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkQueryPool queryPool + uint32_t query + + + void vkCmdCopyQueryPoolResults + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize stride + VkQueryResultFlags flags + + + void vkCmdPushConstants + VkCommandBuffer commandBuffer + VkPipelineLayout layout + VkShaderStageFlags stageFlags + uint32_t offset + uint32_t size + const void* pValues + + + void vkCmdBeginRenderPass + VkCommandBuffer commandBuffer + const VkRenderPassBeginInfo* pRenderPassBegin + VkSubpassContents contents + + + void vkCmdNextSubpass + VkCommandBuffer commandBuffer + VkSubpassContents contents + + + void vkCmdEndRenderPass + VkCommandBuffer commandBuffer + + + void vkCmdExecuteCommands + VkCommandBuffer commandBuffer + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkCreateAndroidSurfaceKHR + VkInstance instance + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPropertiesKHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlanePropertiesKHR* pProperties + + + VkResult vkGetDisplayPlaneSupportedDisplaysKHR + VkPhysicalDevice physicalDevice + uint32_t planeIndex + uint32_t* pDisplayCount + VkDisplayKHR* pDisplays + + + VkResult vkGetDisplayModePropertiesKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModePropertiesKHR* pProperties + + + VkResult vkCreateDisplayModeKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + const VkDisplayModeCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDisplayModeKHR* pMode + + + VkResult vkGetDisplayPlaneCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkDisplayModeKHR mode + uint32_t planeIndex + VkDisplayPlaneCapabilitiesKHR* pCapabilities + + + VkResult vkCreateDisplayPlaneSurfaceKHR + VkInstance instance + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateSharedSwapchainsKHR + VkDevice device + uint32_t swapchainCount + const VkSwapchainCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchains + + + VkResult vkCreateMirSurfaceKHR + VkInstance instance + const VkMirSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + MirConnection* connection + + + void vkDestroySurfaceKHR + VkInstance instance + VkSurfaceKHR surface + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPhysicalDeviceSurfaceSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + VkSurfaceKHR surface + VkBool32* pSupported + + + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pSurfaceFormatCount + VkSurfaceFormatKHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pPresentModeCount + VkPresentModeKHR* pPresentModes + + + VkResult vkCreateSwapchainKHR + VkDevice device + const VkSwapchainCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchain + + + void vkDestroySwapchainKHR + VkDevice device + VkSwapchainKHR swapchain + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetSwapchainImagesKHR + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pSwapchainImageCount + VkImage* pSwapchainImages + + + VkResult vkAcquireNextImageKHR + VkDevice device + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t* pImageIndex + + + VkResult vkQueuePresentKHR + VkQueue queue + const VkPresentInfoKHR* pPresentInfo + + + VkResult vkCreateViSurfaceNN + VkInstance instance + const VkViSurfaceCreateInfoNN* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateWaylandSurfaceKHR + VkInstance instance + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + struct wl_display* display + + + VkResult vkCreateWin32SurfaceKHR + VkInstance instance + const VkWin32SurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + + + VkResult vkCreateXlibSurfaceKHR + VkInstance instance + const VkXlibSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + Display* dpy + VisualID visualID + + + VkResult vkCreateXcbSurfaceKHR + VkInstance instance + const VkXcbSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + xcb_connection_t* connection + xcb_visualid_t visual_id + + + VkResult vkCreateDebugReportCallbackEXT + VkInstance instance + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugReportCallbackEXT* pCallback + + + void vkDestroyDebugReportCallbackEXT + VkInstance instance + VkDebugReportCallbackEXT callback + const VkAllocationCallbacks* pAllocator + + + void vkDebugReportMessageEXT + VkInstance instance + VkDebugReportFlagsEXT flags + VkDebugReportObjectTypeEXT objectType + uint64_t object + size_t location + int32_t messageCode + const char* pLayerPrefix + const char* pMessage + + + VkResult vkDebugMarkerSetObjectNameEXT + VkDevice device + const VkDebugMarkerObjectNameInfoEXT* pNameInfo + + + VkResult vkDebugMarkerSetObjectTagEXT + VkDevice device + const VkDebugMarkerObjectTagInfoEXT* pTagInfo + + + void vkCmdDebugMarkerBeginEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + void vkCmdDebugMarkerEndEXT + VkCommandBuffer commandBuffer + + + void vkCmdDebugMarkerInsertEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkExternalMemoryHandleTypeFlagsNV externalHandleType + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties + + + VkResult vkGetMemoryWin32HandleNV + VkDevice device + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE* pHandle + + + void vkCmdDrawIndirectCountAMD + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirectCountAMD + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + void vkCmdProcessCommandsNVX + VkCommandBuffer commandBuffer + const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo + + + void vkCmdReserveSpaceForCommandsNVX + VkCommandBuffer commandBuffer + const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo + + + VkResult vkCreateIndirectCommandsLayoutNVX + VkDevice device + const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout + + + void vkDestroyIndirectCommandsLayoutNVX + VkDevice device + VkIndirectCommandsLayoutNVX indirectCommandsLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateObjectTableNVX + VkDevice device + const VkObjectTableCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkObjectTableNVX* pObjectTable + + + void vkDestroyObjectTableNVX + VkDevice device + VkObjectTableNVX objectTable + const VkAllocationCallbacks* pAllocator + + + VkResult vkRegisterObjectsNVX + VkDevice device + VkObjectTableNVX objectTable + uint32_t objectCount + const VkObjectTableEntryNVX* const* ppObjectTableEntries + const uint32_t* pObjectIndices + + + VkResult vkUnregisterObjectsNVX + VkDevice device + VkObjectTableNVX objectTable + uint32_t objectCount + const VkObjectEntryTypeNVX* pObjectEntryTypes + const uint32_t* pObjectIndices + + + void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX + VkPhysicalDevice physicalDevice + VkDeviceGeneratedCommandsFeaturesNVX* pFeatures + VkDeviceGeneratedCommandsLimitsNVX* pLimits + + + void vkGetPhysicalDeviceFeatures2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures2* pFeatures + + + + void vkGetPhysicalDeviceProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties2* pProperties + + + + void vkGetPhysicalDeviceFormatProperties2 + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties2* pFormatProperties + + + + VkResult vkGetPhysicalDeviceImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo + VkImageFormatProperties2* pImageFormatProperties + + + + void vkGetPhysicalDeviceQueueFamilyProperties2 + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties2* pQueueFamilyProperties + + + + void vkGetPhysicalDeviceMemoryProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties2* pMemoryProperties + + + + void vkGetPhysicalDeviceSparseImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo + uint32_t* pPropertyCount + VkSparseImageFormatProperties2* pProperties + + + + void vkCmdPushDescriptorSetKHR + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t set + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + + + void vkTrimCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolTrimFlags flags + + + + void vkGetPhysicalDeviceExternalBufferProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo + VkExternalBufferProperties* pExternalBufferProperties + + + + VkResult vkGetMemoryWin32HandleKHR + VkDevice device + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkGetMemoryWin32HandlePropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties + + + VkResult vkGetMemoryFdKHR + VkDevice device + const VkMemoryGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkGetMemoryFdPropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + int fd + VkMemoryFdPropertiesKHR* pMemoryFdProperties + + + void vkGetPhysicalDeviceExternalSemaphoreProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo + VkExternalSemaphoreProperties* pExternalSemaphoreProperties + + + + VkResult vkGetSemaphoreWin32HandleKHR + VkDevice device + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportSemaphoreWin32HandleKHR + VkDevice device + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo + + + VkResult vkGetSemaphoreFdKHR + VkDevice device + const VkSemaphoreGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportSemaphoreFdKHR + VkDevice device + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo + + + void vkGetPhysicalDeviceExternalFenceProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo + VkExternalFenceProperties* pExternalFenceProperties + + + + VkResult vkGetFenceWin32HandleKHR + VkDevice device + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportFenceWin32HandleKHR + VkDevice device + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo + + + VkResult vkGetFenceFdKHR + VkDevice device + const VkFenceGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportFenceFdKHR + VkDevice device + const VkImportFenceFdInfoKHR* pImportFenceFdInfo + + + VkResult vkReleaseDisplayEXT + VkPhysicalDevice physicalDevice + VkDisplayKHR display + + + VkResult vkAcquireXlibDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + VkDisplayKHR display + + + VkResult vkGetRandROutputDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + RROutput rrOutput + VkDisplayKHR* pDisplay + + + VkResult vkDisplayPowerControlEXT + VkDevice device + VkDisplayKHR display + const VkDisplayPowerInfoEXT* pDisplayPowerInfo + + + VkResult vkRegisterDeviceEventEXT + VkDevice device + const VkDeviceEventInfoEXT* pDeviceEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkRegisterDisplayEventEXT + VkDevice device + VkDisplayKHR display + const VkDisplayEventInfoEXT* pDisplayEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkGetSwapchainCounterEXT + VkDevice device + VkSwapchainKHR swapchain + VkSurfaceCounterFlagBitsEXT counter + uint64_t* pCounterValue + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilities2EXT* pSurfaceCapabilities + + + VkResult vkEnumeratePhysicalDeviceGroups + VkInstance instance + uint32_t* pPhysicalDeviceGroupCount + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties + + + + void vkGetDeviceGroupPeerMemoryFeatures + VkDevice device + uint32_t heapIndex + uint32_t localDeviceIndex + uint32_t remoteDeviceIndex + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures + + + + VkResult vkBindBufferMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindBufferMemoryInfo* pBindInfos + + + + VkResult vkBindImageMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindImageMemoryInfo* pBindInfos + + + + void vkCmdSetDeviceMask + VkCommandBuffer commandBuffer + uint32_t deviceMask + + + + VkResult vkGetDeviceGroupPresentCapabilitiesKHR + VkDevice device + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities + + + VkResult vkGetDeviceGroupSurfacePresentModesKHR + VkDevice device + VkSurfaceKHR surface + VkDeviceGroupPresentModeFlagsKHR* pModes + + + VkResult vkAcquireNextImage2KHR + VkDevice device + const VkAcquireNextImageInfoKHR* pAcquireInfo + uint32_t* pImageIndex + + + void vkCmdDispatchBase + VkCommandBuffer commandBuffer + uint32_t baseGroupX + uint32_t baseGroupY + uint32_t baseGroupZ + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + + VkResult vkGetPhysicalDevicePresentRectanglesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pRectCount + VkRect2D* pRects + + + VkResult vkCreateDescriptorUpdateTemplate + VkDevice device + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate + + + + void vkDestroyDescriptorUpdateTemplate + VkDevice device + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const VkAllocationCallbacks* pAllocator + + + + void vkUpdateDescriptorSetWithTemplate + VkDevice device + VkDescriptorSet descriptorSet + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const void* pData + + + + void vkCmdPushDescriptorSetWithTemplateKHR + VkCommandBuffer commandBuffer + VkDescriptorUpdateTemplate descriptorUpdateTemplate + VkPipelineLayout layout + uint32_t set + const void* pData + + + void vkSetHdrMetadataEXT + VkDevice device + uint32_t swapchainCount + const VkSwapchainKHR* pSwapchains + const VkHdrMetadataEXT* pMetadata + + + VkResult vkGetSwapchainStatusKHR + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkGetRefreshCycleDurationGOOGLE + VkDevice device + VkSwapchainKHR swapchain + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties + + + VkResult vkGetPastPresentationTimingGOOGLE + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pPresentationTimingCount + VkPastPresentationTimingGOOGLE* pPresentationTimings + + + VkResult vkCreateIOSSurfaceMVK + VkInstance instance + const VkIOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateMacOSSurfaceMVK + VkInstance instance + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + void vkCmdSetViewportWScalingNV + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + void vkCmdSetDiscardRectangleEXT + VkCommandBuffer commandBuffer + uint32_t firstDiscardRectangle + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + void vkCmdSetSampleLocationsEXT + VkCommandBuffer commandBuffer + const VkSampleLocationsInfoEXT* pSampleLocationsInfo + + + void vkGetPhysicalDeviceMultisamplePropertiesEXT + VkPhysicalDevice physicalDevice + VkSampleCountFlagBits samples + VkMultisamplePropertiesEXT* pMultisampleProperties + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + VkSurfaceCapabilities2KHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + uint32_t* pSurfaceFormatCount + VkSurfaceFormat2KHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceDisplayProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayProperties2KHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlaneProperties2KHR* pProperties + + + VkResult vkGetDisplayModeProperties2KHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModeProperties2KHR* pProperties + + + VkResult vkGetDisplayPlaneCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo + VkDisplayPlaneCapabilities2KHR* pCapabilities + + + void vkGetBufferMemoryRequirements2 + VkDevice device + const VkBufferMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageMemoryRequirements2 + VkDevice device + const VkImageMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageSparseMemoryRequirements2 + VkDevice device + const VkImageSparseMemoryRequirementsInfo2* pInfo + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements + + + + VkResult vkCreateSamplerYcbcrConversion + VkDevice device + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSamplerYcbcrConversion* pYcbcrConversion + + + + void vkDestroySamplerYcbcrConversion + VkDevice device + VkSamplerYcbcrConversion ycbcrConversion + const VkAllocationCallbacks* pAllocator + + + + void vkGetDeviceQueue2 + VkDevice device + const VkDeviceQueueInfo2* pQueueInfo + VkQueue* pQueue + + + VkResult vkCreateValidationCacheEXT + VkDevice device + const VkValidationCacheCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkValidationCacheEXT* pValidationCache + + + void vkDestroyValidationCacheEXT + VkDevice device + VkValidationCacheEXT validationCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetValidationCacheDataEXT + VkDevice device + VkValidationCacheEXT validationCache + size_t* pDataSize + void* pData + + + VkResult vkMergeValidationCachesEXT + VkDevice device + VkValidationCacheEXT dstCache + uint32_t srcCacheCount + const VkValidationCacheEXT* pSrcCaches + + + void vkGetDescriptorSetLayoutSupport + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + VkDescriptorSetLayoutSupport* pSupport + + + + VkResult vkGetSwapchainGrallocUsageANDROID + VkDevice device + VkFormat format + VkImageUsageFlags imageUsage + int* grallocUsage + + + VkResult vkAcquireImageANDROID + VkDevice device + VkImage image + int nativeFenceFd + VkSemaphore semaphore + VkFence fence + + + VkResult vkQueueSignalReleaseImageANDROID + VkQueue queue + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + VkImage image + int* pNativeFenceFd + + + VkResult vkGetShaderInfoAMD + VkDevice device + VkPipeline pipeline + VkShaderStageFlagBits shaderStage + VkShaderInfoTypeAMD infoType + size_t* pInfoSize + void* pInfo + + + VkResult vkSetDebugUtilsObjectNameEXT + VkDevice device + const VkDebugUtilsObjectNameInfoEXT* pNameInfo + + + VkResult vkSetDebugUtilsObjectTagEXT + VkDevice device + const VkDebugUtilsObjectTagInfoEXT* pTagInfo + + + void vkQueueBeginDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkQueueEndDebugUtilsLabelEXT + VkQueue queue + + + void vkQueueInsertDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdBeginDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdEndDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + + + void vkCmdInsertDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + VkResult vkCreateDebugUtilsMessengerEXT + VkInstance instance + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugUtilsMessengerEXT* pMessenger + + + void vkDestroyDebugUtilsMessengerEXT + VkInstance instance + VkDebugUtilsMessengerEXT messenger + const VkAllocationCallbacks* pAllocator + + + void vkSubmitDebugUtilsMessageEXT + VkInstance instance + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageTypes + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData + + + VkResult vkGetMemoryHostPointerPropertiesEXT + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + const void* pHostPointer + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties + + + void vkCmdWriteBufferMarkerAMD + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkBuffer dstBuffer + VkDeviceSize dstOffset + uint32_t marker + + + VkResult vkGetAndroidHardwareBufferPropertiesANDROID + VkDevice device + const struct AHardwareBuffer* buffer + VkAndroidHardwareBufferPropertiesANDROID* pProperties + + + VkResult vkGetMemoryAndroidHardwareBufferANDROID + VkDevice device + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo + struct AHardwareBuffer** pBuffer + + + void vkCmdDrawIndirectCountKHR + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirectCountKHR + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum + offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in VK_KHR_device_group below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in other extensions, below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + enum offset=0 was mistakenly used for the 1.1 core enum + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES + (value=1000094000). Fortunately, no conflict resulted. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From d267044765088656d3a75ea096b30be0e232932a Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 29 Jul 2018 22:48:40 +0200 Subject: [PATCH 027/122] Remove folder that should be a submodule --- generator/Vulkan-Headers/.cmake-format.py | 34 - generator/Vulkan-Headers/.gitignore | 5 - generator/Vulkan-Headers/BUILD.md | 270 - generator/Vulkan-Headers/CMakeLists.txt | 37 - generator/Vulkan-Headers/LICENSE.txt | 170 - generator/Vulkan-Headers/README.md | 3 - .../Vulkan-Headers/cmake/Copyright_cmake.txt | 126 - .../cmake/cmake_uninstall.cmake.in | 21 - .../Vulkan-Headers/include/vulkan/vk_icd.h | 170 - .../Vulkan-Headers/include/vulkan/vk_layer.h | 195 - .../include/vulkan/vk_platform.h | 92 - .../include/vulkan/vk_sdk_platform.h | 69 - .../Vulkan-Headers/include/vulkan/vulkan.h | 79 - .../Vulkan-Headers/include/vulkan/vulkan.hpp | 43865 ---------------- .../include/vulkan/vulkan_android.h | 126 - .../include/vulkan/vulkan_core.h | 7586 --- .../include/vulkan/vulkan_ios.h | 58 - .../include/vulkan/vulkan_macos.h | 58 - .../include/vulkan/vulkan_mir.h | 65 - .../Vulkan-Headers/include/vulkan/vulkan_vi.h | 58 - .../include/vulkan/vulkan_wayland.h | 65 - .../include/vulkan/vulkan_win32.h | 276 - .../include/vulkan/vulkan_xcb.h | 66 - .../include/vulkan/vulkan_xlib.h | 66 - .../include/vulkan/vulkan_xlib_xrandr.h | 54 - .../Vulkan-Headers/registry/cgenerator.py | 417 - .../Vulkan-Headers/registry/generator.py | 595 - generator/Vulkan-Headers/registry/genvk.py | 531 - generator/Vulkan-Headers/registry/reg.py | 1066 - .../Vulkan-Headers/registry/validusage.json | 19076 ------- generator/Vulkan-Headers/registry/vk.xml | 8842 ---- 31 files changed, 84141 deletions(-) delete mode 100644 generator/Vulkan-Headers/.cmake-format.py delete mode 100644 generator/Vulkan-Headers/.gitignore delete mode 100644 generator/Vulkan-Headers/BUILD.md delete mode 100644 generator/Vulkan-Headers/CMakeLists.txt delete mode 100644 generator/Vulkan-Headers/LICENSE.txt delete mode 100644 generator/Vulkan-Headers/README.md delete mode 100644 generator/Vulkan-Headers/cmake/Copyright_cmake.txt delete mode 100644 generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in delete mode 100644 generator/Vulkan-Headers/include/vulkan/vk_icd.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vk_layer.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vk_platform.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan.hpp delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_android.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_core.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_ios.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_macos.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_mir.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_vi.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_win32.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h delete mode 100644 generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h delete mode 100644 generator/Vulkan-Headers/registry/cgenerator.py delete mode 100644 generator/Vulkan-Headers/registry/generator.py delete mode 100644 generator/Vulkan-Headers/registry/genvk.py delete mode 100644 generator/Vulkan-Headers/registry/reg.py delete mode 100644 generator/Vulkan-Headers/registry/validusage.json delete mode 100644 generator/Vulkan-Headers/registry/vk.xml diff --git a/generator/Vulkan-Headers/.cmake-format.py b/generator/Vulkan-Headers/.cmake-format.py deleted file mode 100644 index 9c173ac..0000000 --- a/generator/Vulkan-Headers/.cmake-format.py +++ /dev/null @@ -1,34 +0,0 @@ -# Configuration for cmake-format (v0.3.6, circa Apr 2018) -# https://github.com/cheshirekow/cmake_format - -# How wide to allow formatted cmake files -line_width = 132 - -# How many spaces to tab for indent -tab_size = 4 - -# If arglists are longer than this, break them always -max_subargs_per_line = 3 - -# If true, separate flow control names from their parentheses with a space -separate_ctrl_name_with_space = False - -# If true, separate function names from parentheses with a space -separate_fn_name_with_space = False - -# If a statement is wrapped to more than one line, than dangle the closing -# parenthesis on it's own line -dangle_parens = False - -# What character to use for bulleted lists -bullet_char = u'*' - -# What character to use as punctuation after numerals in an enumerated list -enum_char = u'.' - -# What style line endings to use in the output. -line_ending = u'unix' - -# Format command names consistently as 'lower' or 'upper' case -command_case = u'lower' - diff --git a/generator/Vulkan-Headers/.gitignore b/generator/Vulkan-Headers/.gitignore deleted file mode 100644 index 23e1481..0000000 --- a/generator/Vulkan-Headers/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -# Python cache -__pycache__ -*.pyc -build -.vscode/ diff --git a/generator/Vulkan-Headers/BUILD.md b/generator/Vulkan-Headers/BUILD.md deleted file mode 100644 index 0f0114e..0000000 --- a/generator/Vulkan-Headers/BUILD.md +++ /dev/null @@ -1,270 +0,0 @@ -# Build Instructions - -Instructions for building this repository on Windows, Linux, and MacOS. - -## Index - -1. [Contributing](#contributing-to-the-repository) -1. [Repository Content](#repository-content) -1. [Repository Set-up](#repository-set-up) -1. [Windows Build](#building-on-windows) -1. [Linux Build](#building-on-linux) -1. [MacOS Build](#building-on-macos) - -## Contributing to the Repository - -The contents of this repository are sourced primarily from the Khronos Vulkan -API specification [repository](https://github.com/KhronosGroup/Vulkan-Docs). -Please visit that repository for information on contributing. - -## Repository Content - -This repository contains the Vulkan header files and the Vulkan API definition -(registry) with its related files. This repository does not create libraries -or executables. - -However, this repository contains CMake build configuration files to "install" -the files from this repository to a specific install directory. For example, -you can install the files to a system directory such as `/usr/local` on Linux. - -If you are building other Vulkan-related repositories such as -[Vulkan-Loader](https://github.com/KhronosGroup/Vulkan-Loader), -you need to build the install target of this repository and provide the -resulting install directory to those repositories. - -### Installed Files - -The `install` target installs the following files under the directory -indicated by *install_dir*: - -- *install_dir*`/include/vulkan` : The header files found in the - `include/vulkan` directory of this repository -- *install_dir*`/share/vulkan/registry` : The registry files found in the - `registry` directory of this repository - -The `uninstall` target can be used to remove the above files from the install -directory. - -## Repository Set-Up - -### Download the Repository - -To create your local git repository: - - git clone https://github.com/KhronosGroup/Vulkan-Headers.git - -### Repository Dependencies - -This repository does not depend on any other repositories. - -### Build and Install Directories - -A common convention is to place the build directory in the top directory of -the repository with a name of `build` and place the install directory as a -child of the build directory with the name `install`. The remainder of these -instructions follow this convention, although you can use any name for these -directories and place them in any location. - -## Building On Windows - -### Windows Development Environment Requirements - -- Windows - - Any Personal Computer version supported by Microsoft -- Microsoft [Visual Studio](https://www.visualstudio.com/) - - Versions - - [2013 (update 4)](https://www.visualstudio.com/vs/older-downloads/) - - [2015](https://www.visualstudio.com/vs/older-downloads/) - - [2017](https://www.visualstudio.com/vs/downloads/) - - The Community Edition of each of the above versions is sufficient, as - well as any more capable edition. -- [CMake](http://www.cmake.org/download/) (Version 2.8.11 or better) - - Use the installer option to add CMake to the system PATH -- Git Client Support - - [Git for Windows](http://git-scm.com/download/win) is a popular solution - for Windows - - Some IDEs (e.g., [Visual Studio](https://www.visualstudio.com/), - [GitHub Desktop](https://desktop.github.com/)) have integrated - Git client support - -### Windows Build - Microsoft Visual Studio - -The general approach is to run CMake to generate the Visual Studio project -files. Then either run CMake with the `--build` option to build from the -command line or use the Visual Studio IDE to open the generated solution and -work with the solution interactively. - -#### Windows Quick Start - - cd Vulkan-Headers - mkdir build - cd build - cmake .. - cmake --build . --target install - -See below for the details. - -#### Use `CMake` to Create the Visual Studio Project Files - -Change your current directory to the top of the cloned repository directory, -create a build directory and generate the Visual Studio project files: - - cd Vulkan-Headers - mkdir build - cd build - cmake .. - -> Note: The `..` parameter tells `cmake` the location of the top of the -> repository. If you place your build directory someplace else, you'll need to -> specify the location of the repository top differently. - -The CMake configuration files set the default install directory location to -`$CMAKE_BINARY_DIR\install`, which is a child of your build directory. In this -example, the install directory becomes the `Vulkan-Headers\build\install` -directory. - -The project installs the header files to - - Vulkan-Headers\build\install\include\vulkan - -and installs the registry files to - - Vulkan-Headers\build\install\share\vulkan\registry - -You can change the install directory with the `CMAKE_INSTALL_PREFIX` CMake -variable. - -For example: - - cd Vulkan-Headers - mkdir build - cd build - cmake -DCMAKE_INSTALL_PREFIX=/c/Users/dev/install .. # MINGW64 shell - -As it starts generating the project files, `cmake` responds with something -like: - - -- Building for: Visual Studio 14 2015 - -which is a 32-bit generator. - -Since this repository does not compile anything, there is no need to specify a -specific generator such as "Visual Studio 14 2015 Win64", so the default -generator should suffice. - -The above steps create a Windows solution file named `Vulkan-Headers.sln` in -the build directory. - -At this point, you can build the solution from the command line or open the -generated solution with Visual Studio. - -#### Build the Solution From the Command Line - -While still in the build directory: - - cmake --build . --target install - -to build the install target. - -Build the `uninstall` target to remove the files from the install directory. - - cmake --build . --target uninstall - -#### Build the Solution With Visual Studio - -Launch Visual Studio and open the "Vulkan-Headers.sln" solution file in the -build directory. Build the `INSTALL` target from the Visual Studio solution -explorer. - -Build the `uninstall` target to remove the files from the install directory. - -> Note: Since there are only the `INSTALL` and `uninstall` projects in the -> solution, building the solution from the command line may be more efficient -> than starting Visual Studio for these simple operations. - -## Building On Linux - -### Linux Development Environment Requirements - -There are no specific Linux distribution or compiler version requirements for -building this repository. The required tools are - -- cmake (Version 2.8.11 or better) -- git - -### Linux Build - -The general approach is to run CMake to generate make files. Then either run -CMake with the `--build` option or `make` to build from the command line. - -#### Linux Quick Start - - cd Vulkan-Headers - mkdir build - cd build - cmake -DCMAKE_INSTALL_PREFIX=install .. - make install - -See below for the details. - -#### Use CMake to Create the Make Files - -Change your current directory to the top of the cloned repository directory, -create a build directory and generate the make files: - - cd Vulkan-Headers - mkdir build - cd build - cmake -DCMAKE_INSTALL_PREFIX=install .. - -> Note: The `..` parameter tells `cmake` the location of the top of the -> repository. If you place your `build` directory someplace else, you'll need -> to specify the location of the repository top differently. - -Set the `CMAKE_INSTALL_PREFIX` variable to the directory to serve as the -destination directory for the `install` target. - -The above `cmake` command sets the install directory to -`$CMAKE_BINARY_DIR/install`, which is a child of your `build` directory. In -this example, the install directory becomes the `Vulkan-Headers/build/install` -directory. - -The make file install target installs the header files to - - Vulkan-Headers/build/install/include/vulkan - -and installs the registry files to - - Vulkan-Headers/build/install/share/vulkan/registry - -> Note: For Linux, the default value for `CMAKE_INSTALL_PREFIX` is -> `/usr/local`, which would be used if you do not specify -> `CMAKE_INSTALL_PREFIX`. In this case, you may need to use `sudo` to install -> to system directories later when you run `make install`. - -Note that after generating the make files, running `make`: - - make - -does nothing, since there are no libraries or executables to build. - -To install the header files: - - make install - -or - - cmake --build . --target install - -To uninstall the files from the install directories, you can execute: - - make uninstall - -or - - cmake --build . --target uninstall - -## Building on MacOS - -The instructions for building this repository on MacOS are the same as those -for Linux. diff --git a/generator/Vulkan-Headers/CMakeLists.txt b/generator/Vulkan-Headers/CMakeLists.txt deleted file mode 100644 index fb95d64..0000000 --- a/generator/Vulkan-Headers/CMakeLists.txt +++ /dev/null @@ -1,37 +0,0 @@ -# ~~~ -# Copyright (c) 2018 Valve Corporation -# Copyright (c) 2018 LunarG, Inc. -# -# 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. -# ~~~ - -cmake_minimum_required(VERSION 2.8.11) - -project(Vulkan-Headers NONE) - -include(GNUInstallDirs) -# Set a better default install location for Windows only if the user did not provide one. -if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32) - set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "default install path" FORCE) -endif() - -install(DIRECTORY "${CMAKE_SOURCE_DIR}/include/vulkan" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) -install(DIRECTORY "${CMAKE_SOURCE_DIR}/registry" DESTINATION ${CMAKE_INSTALL_DATADIR}/vulkan) - -# uninstall target -if(NOT TARGET uninstall) - configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" - IMMEDIATE - @ONLY) - add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) -endif() diff --git a/generator/Vulkan-Headers/LICENSE.txt b/generator/Vulkan-Headers/LICENSE.txt deleted file mode 100644 index 3c65815..0000000 --- a/generator/Vulkan-Headers/LICENSE.txt +++ /dev/null @@ -1,170 +0,0 @@ -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 - -APPENDIX: HOW TO APPLY THE APACHE LICENSE TO YOUR WORK -To apply the Apache License to your work, attach the following boilerplate notice, with -the fields enclosed by brackets "[]" replaced with your own identifying information. -(Don't include the brackets!) The text should be enclosed in the appropriate comment -syntax for the file format. We also recommend that a file or class name and description -of purpose be included on the same "printed page" as the copyright notice for easier -identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. - diff --git a/generator/Vulkan-Headers/README.md b/generator/Vulkan-Headers/README.md deleted file mode 100644 index e9661fe..0000000 --- a/generator/Vulkan-Headers/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# Vulkan-Headers - -Vulkan Header files and API registry diff --git a/generator/Vulkan-Headers/cmake/Copyright_cmake.txt b/generator/Vulkan-Headers/cmake/Copyright_cmake.txt deleted file mode 100644 index 743c634..0000000 --- a/generator/Vulkan-Headers/cmake/Copyright_cmake.txt +++ /dev/null @@ -1,126 +0,0 @@ -CMake - Cross Platform Makefile Generator -Copyright 2000-2018 Kitware, Inc. and Contributors -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions -are met: - -* Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - -* Neither the name of Kitware, Inc. nor the names of Contributors - may be used to endorse or promote products derived from this - software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ------------------------------------------------------------------------------- - -The following individuals and institutions are among the Contributors: - -* Aaron C. Meadows -* Adriaan de Groot -* Aleksey Avdeev -* Alexander Neundorf -* Alexander Smorkalov -* Alexey Sokolov -* Alex Turbov -* Andreas Pakulat -* Andreas Schneider -* André Rigland Brodtkorb -* Axel Huebl, Helmholtz-Zentrum Dresden - Rossendorf -* Benjamin Eikel -* Bjoern Ricks -* Brad Hards -* Christopher Harvey -* Christoph Grüninger -* Clement Creusot -* Daniel Blezek -* Daniel Pfeifer -* Enrico Scholz -* Eran Ifrah -* Esben Mose Hansen, Ange Optimization ApS -* Geoffrey Viola -* Google Inc -* Gregor Jasny -* Helio Chissini de Castro -* Ilya Lavrenov -* Insight Software Consortium -* Jan Woetzel -* Kelly Thompson -* Konstantin Podsvirov -* Mario Bensi -* Mathieu Malaterre -* Matthaeus G. Chajdas -* Matthias Kretz -* Matthias Maennich -* Michael Stürmer -* Miguel A. Figueroa-Villanueva -* Mike Jackson -* Mike McQuaid -* Nicolas Bock -* Nicolas Despres -* Nikita Krupen'ko -* NVIDIA Corporation -* OpenGamma Ltd. -* Patrick Stotko -* Per Øyvind Karlsen -* Peter Collingbourne -* Petr Gotthard -* Philip Lowman -* Philippe Proulx -* Raffi Enficiaud, Max Planck Society -* Raumfeld -* Roger Leigh -* Rolf Eike Beer -* Roman Donchenko -* Roman Kharitonov -* Ruslan Baratov -* Sebastian Holtermann -* Stephen Kelly -* Sylvain Joubert -* Thomas Sondergaard -* Tobias Hunger -* Todd Gamblin -* Tristan Carel -* University of Dundee -* Vadim Zhukov -* Will Dicharry - -See version control history for details of individual contributions. - -The above copyright and license notice applies to distributions of -CMake in source and binary form. Third-party software packages supplied -with CMake under compatible licenses provide their own copyright notices -documented in corresponding subdirectories or source files. - ------------------------------------------------------------------------------- - -CMake was initially developed by Kitware with the following sponsorship: - - * National Library of Medicine at the National Institutes of Health - as part of the Insight Segmentation and Registration Toolkit (ITK). - - * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel - Visualization Initiative. - - * National Alliance for Medical Image Computing (NAMIC) is funded by the - National Institutes of Health through the NIH Roadmap for Medical Research, - Grant U54 EB005149. - - * Kitware, Inc. diff --git a/generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in b/generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in deleted file mode 100644 index 2037e36..0000000 --- a/generator/Vulkan-Headers/cmake/cmake_uninstall.cmake.in +++ /dev/null @@ -1,21 +0,0 @@ -if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") - message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") -endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") - -file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) -string(REGEX REPLACE "\n" ";" files "${files}") -foreach(file ${files}) - message(STATUS "Uninstalling $ENV{DESTDIR}${file}") - if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") - exec_program( - "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" - OUTPUT_VARIABLE rm_out - RETURN_VALUE rm_retval - ) - if(NOT "${rm_retval}" STREQUAL 0) - message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") - endif(NOT "${rm_retval}" STREQUAL 0) - else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") - message(STATUS "File $ENV{DESTDIR}${file} does not exist.") - endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") -endforeach(file) diff --git a/generator/Vulkan-Headers/include/vulkan/vk_icd.h b/generator/Vulkan-Headers/include/vulkan/vk_icd.h deleted file mode 100644 index b935fa1..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vk_icd.h +++ /dev/null @@ -1,170 +0,0 @@ -// -// File: vk_icd.h -// -/* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * 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. - * - */ - -#ifndef VKICD_H -#define VKICD_H - -#include "vulkan.h" -#include - -// Loader-ICD version negotiation API. Versions add the following features: -// Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr -// or vk_icdNegotiateLoaderICDInterfaceVersion. -// Version 1 - Add support for vk_icdGetInstanceProcAddr. -// Version 2 - Add Loader/ICD Interface version negotiation -// via vk_icdNegotiateLoaderICDInterfaceVersion. -// Version 3 - Add ICD creation/destruction of KHR_surface objects. -// Version 4 - Add unknown physical device extension qyering via -// vk_icdGetPhysicalDeviceProcAddr. -// Version 5 - Tells ICDs that the loader is now paying attention to the -// application version of Vulkan passed into the ApplicationInfo -// structure during vkCreateInstance. This will tell the ICD -// that if the loader is older, it should automatically fail a -// call for any API version > 1.0. Otherwise, the loader will -// manually determine if it can support the expected version. -#define CURRENT_LOADER_ICD_INTERFACE_VERSION 5 -#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 -#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 -typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); - -// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this -// file directly, it won't be found. -#ifndef PFN_GetPhysicalDeviceProcAddr -typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName); -#endif - -/* - * The ICD must reserve space for a pointer for the loader's dispatch - * table, at the start of . - * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. - */ - -#define ICD_LOADER_MAGIC 0x01CDC0DE - -typedef union { - uintptr_t loaderMagic; - void *loaderData; -} VK_LOADER_DATA; - -static inline void set_loader_magic_value(void *pNewObject) { - VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; - loader_info->loaderMagic = ICD_LOADER_MAGIC; -} - -static inline bool valid_loader_magic_value(void *pNewObject) { - const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; - return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; -} - -/* - * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that - * contains the platform-specific connection and surface information. - */ -typedef enum { - VK_ICD_WSI_PLATFORM_MIR, - VK_ICD_WSI_PLATFORM_WAYLAND, - VK_ICD_WSI_PLATFORM_WIN32, - VK_ICD_WSI_PLATFORM_XCB, - VK_ICD_WSI_PLATFORM_XLIB, - VK_ICD_WSI_PLATFORM_ANDROID, - VK_ICD_WSI_PLATFORM_MACOS, - VK_ICD_WSI_PLATFORM_IOS, - VK_ICD_WSI_PLATFORM_DISPLAY -} VkIcdWsiPlatform; - -typedef struct { - VkIcdWsiPlatform platform; -} VkIcdSurfaceBase; - -#ifdef VK_USE_PLATFORM_MIR_KHR -typedef struct { - VkIcdSurfaceBase base; - MirConnection *connection; - MirSurface *mirSurface; -} VkIcdSurfaceMir; -#endif // VK_USE_PLATFORM_MIR_KHR - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR -typedef struct { - VkIcdSurfaceBase base; - struct wl_display *display; - struct wl_surface *surface; -} VkIcdSurfaceWayland; -#endif // VK_USE_PLATFORM_WAYLAND_KHR - -#ifdef VK_USE_PLATFORM_WIN32_KHR -typedef struct { - VkIcdSurfaceBase base; - HINSTANCE hinstance; - HWND hwnd; -} VkIcdSurfaceWin32; -#endif // VK_USE_PLATFORM_WIN32_KHR - -#ifdef VK_USE_PLATFORM_XCB_KHR -typedef struct { - VkIcdSurfaceBase base; - xcb_connection_t *connection; - xcb_window_t window; -} VkIcdSurfaceXcb; -#endif // VK_USE_PLATFORM_XCB_KHR - -#ifdef VK_USE_PLATFORM_XLIB_KHR -typedef struct { - VkIcdSurfaceBase base; - Display *dpy; - Window window; -} VkIcdSurfaceXlib; -#endif // VK_USE_PLATFORM_XLIB_KHR - -#ifdef VK_USE_PLATFORM_ANDROID_KHR -typedef struct { - VkIcdSurfaceBase base; - struct ANativeWindow *window; -} VkIcdSurfaceAndroid; -#endif // VK_USE_PLATFORM_ANDROID_KHR - -#ifdef VK_USE_PLATFORM_MACOS_MVK -typedef struct { - VkIcdSurfaceBase base; - const void *pView; -} VkIcdSurfaceMacOS; -#endif // VK_USE_PLATFORM_MACOS_MVK - -#ifdef VK_USE_PLATFORM_IOS_MVK -typedef struct { - VkIcdSurfaceBase base; - const void *pView; -} VkIcdSurfaceIOS; -#endif // VK_USE_PLATFORM_IOS_MVK - -typedef struct { - VkIcdSurfaceBase base; - VkDisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - VkSurfaceTransformFlagBitsKHR transform; - float globalAlpha; - VkDisplayPlaneAlphaFlagBitsKHR alphaMode; - VkExtent2D imageExtent; -} VkIcdSurfaceDisplay; - -#endif // VKICD_H diff --git a/generator/Vulkan-Headers/include/vulkan/vk_layer.h b/generator/Vulkan-Headers/include/vulkan/vk_layer.h deleted file mode 100644 index 823c88a..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vk_layer.h +++ /dev/null @@ -1,195 +0,0 @@ -// -// File: vk_layer.h -// -/* - * Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. - * - * 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. - * - */ - -/* Need to define dispatch table - * Core struct can then have ptr to dispatch table at the top - * Along with object ptrs for current and next OBJ - */ -#pragma once - -#include "vulkan.h" -#if defined(__GNUC__) && __GNUC__ >= 4 -#define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -#define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#else -#define VK_LAYER_EXPORT -#endif - -#define MAX_NUM_UNKNOWN_EXTS 250 - - // Loader-Layer version negotiation API. Versions add the following features: - // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr - // or vk_icdNegotiateLoaderLayerInterfaceVersion. - // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and - // vk_icdNegotiateLoaderLayerInterfaceVersion. -#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 -#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 - -#define VK_CURRENT_CHAIN_VERSION 1 - -// Typedef for use in the interfaces below -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); - -// Version negotiation values -typedef enum VkNegotiateLayerStructType { - LAYER_NEGOTIATE_UNINTIALIZED = 0, - LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, -} VkNegotiateLayerStructType; - -// Version negotiation structures -typedef struct VkNegotiateLayerInterface { - VkNegotiateLayerStructType sType; - void *pNext; - uint32_t loaderLayerInterfaceVersion; - PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; - PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; -} VkNegotiateLayerInterface; - -// Version negotiation functions -typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); - -// Function prototype for unknown physical device extension command -typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); - -// ------------------------------------------------------------------------------------------------ -// CreateInstance and CreateDevice support structures - -/* Sub type of structure for instance and device loader ext of CreateInfo. - * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO - * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - * then VkLayerFunction indicates struct type pointed to by pNext - */ -typedef enum VkLayerFunction_ { - VK_LAYER_LINK_INFO = 0, - VK_LOADER_DATA_CALLBACK = 1 -} VkLayerFunction; - -typedef struct VkLayerInstanceLink_ { - struct VkLayerInstanceLink_ *pNext; - PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; - PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; -} VkLayerInstanceLink; - -/* - * When creating the device chain the loader needs to pass - * down information about it's device structure needed at - * the end of the chain. Passing the data via the - * VkLayerDeviceInfo avoids issues with finding the - * exact instance being used. - */ -typedef struct VkLayerDeviceInfo_ { - void *device_info; - PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; -} VkLayerDeviceInfo; - -typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, - void *object); -typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, - void *object); - -typedef struct { - VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO - const void *pNext; - VkLayerFunction function; - union { - VkLayerInstanceLink *pLayerInfo; - PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; - } u; -} VkLayerInstanceCreateInfo; - -typedef struct VkLayerDeviceLink_ { - struct VkLayerDeviceLink_ *pNext; - PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; -} VkLayerDeviceLink; - -typedef struct { - VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - const void *pNext; - VkLayerFunction function; - union { - VkLayerDeviceLink *pLayerInfo; - PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; - } u; -} VkLayerDeviceCreateInfo; - -#ifdef __cplusplus -extern "C" { -#endif - -VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); - -typedef enum VkChainType { - VK_CHAIN_TYPE_UNKNOWN = 0, - VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, - VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, - VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, -} VkChainType; - -typedef struct VkChainHeader { - VkChainType type; - uint32_t version; - uint32_t size; -} VkChainHeader; - -typedef struct VkEnumerateInstanceExtensionPropertiesChain { - VkChainHeader header; - VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, - VkExtensionProperties *); - const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; - -#if defined(__cplusplus) - inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { - return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); - } -#endif -} VkEnumerateInstanceExtensionPropertiesChain; - -typedef struct VkEnumerateInstanceLayerPropertiesChain { - VkChainHeader header; - VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); - const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; - -#if defined(__cplusplus) - inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { - return pfnNextLayer(pNextLink, pPropertyCount, pProperties); - } -#endif -} VkEnumerateInstanceLayerPropertiesChain; - -typedef struct VkEnumerateInstanceVersionChain { - VkChainHeader header; - VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); - const struct VkEnumerateInstanceVersionChain *pNextLink; - -#if defined(__cplusplus) - inline VkResult CallDown(uint32_t *pApiVersion) const { - return pfnNextLayer(pNextLink, pApiVersion); - } -#endif -} VkEnumerateInstanceVersionChain; - -#ifdef __cplusplus -} -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vk_platform.h b/generator/Vulkan-Headers/include/vulkan/vk_platform.h deleted file mode 100644 index 7289299..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vk_platform.h +++ /dev/null @@ -1,92 +0,0 @@ -// -// File: vk_platform.h -// -/* -** Copyright (c) 2014-2017 The Khronos Group Inc. -** -** 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. -*/ - - -#ifndef VK_PLATFORM_H_ -#define VK_PLATFORM_H_ - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -/* -*************************************************************************************************** -* Platform-specific directives and type declarations -*************************************************************************************************** -*/ - -/* Platform-specific calling convention macros. - * - * Platforms should define these so that Vulkan clients call Vulkan commands - * with the same calling conventions that the Vulkan implementation expects. - * - * VKAPI_ATTR - Placed before the return type in function declarations. - * Useful for C++11 and GCC/Clang-style function attribute syntax. - * VKAPI_CALL - Placed after the return type in function declarations. - * Useful for MSVC-style calling convention syntax. - * VKAPI_PTR - Placed between the '(' and '*' in function pointer types. - * - * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); - * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); - */ -#if defined(_WIN32) - // On Windows, Vulkan commands use the stdcall convention - #define VKAPI_ATTR - #define VKAPI_CALL __stdcall - #define VKAPI_PTR VKAPI_CALL -#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 - #error "Vulkan isn't supported for the 'armeabi' NDK ABI" -#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) - // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" - // calling convention, i.e. float parameters are passed in registers. This - // is true even if the rest of the application passes floats on the stack, - // as it does by default when compiling for the armeabi-v7a NDK ABI. - #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) - #define VKAPI_CALL - #define VKAPI_PTR VKAPI_ATTR -#else - // On other platforms, use the default calling convention - #define VKAPI_ATTR - #define VKAPI_CALL - #define VKAPI_PTR -#endif - -#include - -#if !defined(VK_NO_STDINT_H) - #if defined(_MSC_VER) && (_MSC_VER < 1600) - typedef signed __int8 int8_t; - typedef unsigned __int8 uint8_t; - typedef signed __int16 int16_t; - typedef unsigned __int16 uint16_t; - typedef signed __int32 int32_t; - typedef unsigned __int32 uint32_t; - typedef signed __int64 int64_t; - typedef unsigned __int64 uint64_t; - #else - #include - #endif -#endif // !defined(VK_NO_STDINT_H) - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h b/generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h deleted file mode 100644 index 96d8676..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vk_sdk_platform.h +++ /dev/null @@ -1,69 +0,0 @@ -// -// File: vk_sdk_platform.h -// -/* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. - * - * 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. - */ - -#ifndef VK_SDK_PLATFORM_H -#define VK_SDK_PLATFORM_H - -#if defined(_WIN32) -#define NOMINMAX -#ifndef __cplusplus -#undef inline -#define inline __inline -#endif // __cplusplus - -#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/) -// C99: -// Microsoft didn't implement C99 in Visual Studio; but started adding it with -// VS2013. However, VS2013 still didn't have snprintf(). The following is a -// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the -// "CMakeLists.txt" file). -// NOTE: This is fixed in Visual Studio 2015. -#define snprintf _snprintf -#endif - -#define strdup _strdup - -#endif // _WIN32 - -// Check for noexcept support using clang, with fallback to Windows or GCC version numbers -#ifndef NOEXCEPT -#if defined(__clang__) -#if __has_feature(cxx_noexcept) -#define HAS_NOEXCEPT -#endif -#else -#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 -#define HAS_NOEXCEPT -#else -#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS -#define HAS_NOEXCEPT -#endif -#endif -#endif - -#ifdef HAS_NOEXCEPT -#define NOEXCEPT noexcept -#else -#define NOEXCEPT -#endif -#endif - -#endif // VK_SDK_PLATFORM_H diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan.h b/generator/Vulkan-Headers/include/vulkan/vulkan.h deleted file mode 100644 index d05c849..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan.h +++ /dev/null @@ -1,79 +0,0 @@ -#ifndef VULKAN_H_ -#define VULKAN_H_ 1 - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -#include "vk_platform.h" -#include "vulkan_core.h" - -#ifdef VK_USE_PLATFORM_ANDROID_KHR -#include "vulkan_android.h" -#endif - - -#ifdef VK_USE_PLATFORM_IOS_MVK -#include "vulkan_ios.h" -#endif - - -#ifdef VK_USE_PLATFORM_MACOS_MVK -#include "vulkan_macos.h" -#endif - - -#ifdef VK_USE_PLATFORM_MIR_KHR -#include -#include "vulkan_mir.h" -#endif - - -#ifdef VK_USE_PLATFORM_VI_NN -#include "vulkan_vi.h" -#endif - - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR -#include -#include "vulkan_wayland.h" -#endif - - -#ifdef VK_USE_PLATFORM_WIN32_KHR -#include -#include "vulkan_win32.h" -#endif - - -#ifdef VK_USE_PLATFORM_XCB_KHR -#include -#include "vulkan_xcb.h" -#endif - - -#ifdef VK_USE_PLATFORM_XLIB_KHR -#include -#include "vulkan_xlib.h" -#endif - - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -#include -#include -#include "vulkan_xlib_xrandr.h" -#endif - -#endif // VULKAN_H_ diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan.hpp b/generator/Vulkan-Headers/include/vulkan/vulkan.hpp deleted file mode 100644 index df24587..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan.hpp +++ /dev/null @@ -1,43865 +0,0 @@ -// Copyright (c) 2015-2018 The Khronos Group Inc. -// -// 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. -// -// ---- Exceptions to the Apache 2.0 License: ---- -// -// As an exception, if you use this Software to generate code and portions of -// this Software are embedded into the generated code as a result, you may -// redistribute such product without providing attribution as would otherwise -// be required by Sections 4(a), 4(b) and 4(d) of the License. -// -// In addition, if you combine or link code generated by this Software with -// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1 -// ("`Combined Software`") and if a court of competent jurisdiction determines -// that the patent provision (Section 3), the indemnity provision (Section 9) -// or other Section of the License conflicts with the conditions of the -// applicable GPL or LGPL license, you may retroactively and prospectively -// choose to deem waived or otherwise exclude such Section(s) of the License, -// but only in their entirety and only with respect to the Combined Software. -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_HPP -#define VULKAN_HPP - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE -# include -# include -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#if !defined(VULKAN_HPP_ASSERT) -# include -# define VULKAN_HPP_ASSERT assert -#endif -static_assert( VK_HEADER_VERSION == 79 , "Wrong VK_HEADER_VERSION!" ); - -// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. -// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION -#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) -# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION ) -# define VULKAN_HPP_TYPESAFE_CONVERSION -# endif -#endif - -#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS) -# if defined(__clang__) -# if __has_feature(cxx_unrestricted_unions) -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# elif defined(__GNUC__) -# define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) -# if 40600 <= GCC_VERSION -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# elif defined(_MSC_VER) -# if 1900 <= _MSC_VER -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# endif -#endif - -#if !defined(VULKAN_HPP_INLINE) -# if defined(__clang___) -# if __has_attribute(always_inline) -# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__ -# else -# define VULKAN_HPP_INLINE inline -# endif -# elif defined(__GNUC__) -# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__ -# elif defined(_MSC_VER) -# define VULKAN_HPP_INLINE __forceinline -# else -# define VULKAN_HPP_INLINE inline -# endif -#endif - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) -# define VULKAN_HPP_TYPESAFE_EXPLICIT -#else -# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit -#endif - -#if defined(_MSC_VER) && (_MSC_VER <= 1800) -# define VULKAN_HPP_CONSTEXPR -#else -# define VULKAN_HPP_CONSTEXPR constexpr -#endif - - -#if !defined(VULKAN_HPP_NAMESPACE) -#define VULKAN_HPP_NAMESPACE vk -#endif - -#define VULKAN_HPP_STRINGIFY2(text) #text -#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text) -#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE) - -namespace VULKAN_HPP_NAMESPACE -{ - - template struct FlagTraits - { - enum { allFlags = 0 }; - }; - - template - class Flags - { - public: - VULKAN_HPP_CONSTEXPR Flags() - : m_mask(0) - { - } - - Flags(BitType bit) - : m_mask(static_cast(bit)) - { - } - - Flags(Flags const& rhs) - : m_mask(rhs.m_mask) - { - } - - explicit Flags(MaskType flags) - : m_mask(flags) - { - } - - Flags & operator=(Flags const& rhs) - { - m_mask = rhs.m_mask; - return *this; - } - - Flags & operator|=(Flags const& rhs) - { - m_mask |= rhs.m_mask; - return *this; - } - - Flags & operator&=(Flags const& rhs) - { - m_mask &= rhs.m_mask; - return *this; - } - - Flags & operator^=(Flags const& rhs) - { - m_mask ^= rhs.m_mask; - return *this; - } - - Flags operator|(Flags const& rhs) const - { - Flags result(*this); - result |= rhs; - return result; - } - - Flags operator&(Flags const& rhs) const - { - Flags result(*this); - result &= rhs; - return result; - } - - Flags operator^(Flags const& rhs) const - { - Flags result(*this); - result ^= rhs; - return result; - } - - bool operator!() const - { - return !m_mask; - } - - Flags operator~() const - { - Flags result(*this); - result.m_mask ^= FlagTraits::allFlags; - return result; - } - - bool operator==(Flags const& rhs) const - { - return m_mask == rhs.m_mask; - } - - bool operator!=(Flags const& rhs) const - { - return m_mask != rhs.m_mask; - } - - explicit operator bool() const - { - return !!m_mask; - } - - explicit operator MaskType() const - { - return m_mask; - } - - private: - MaskType m_mask; - }; - - template - Flags operator|(BitType bit, Flags const& flags) - { - return flags | bit; - } - - template - Flags operator&(BitType bit, Flags const& flags) - { - return flags & bit; - } - - template - Flags operator^(BitType bit, Flags const& flags) - { - return flags ^ bit; - } - - - template - class Optional - { - public: - Optional(RefType & reference) { m_ptr = &reference; } - Optional(RefType * ptr) { m_ptr = ptr; } - Optional(std::nullptr_t) { m_ptr = nullptr; } - - operator RefType*() const { return m_ptr; } - RefType const* operator->() const { return m_ptr; } - explicit operator bool() const { return !!m_ptr; } - - private: - RefType *m_ptr; - }; - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - class ArrayProxy - { - public: - VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) - : m_count(0) - , m_ptr(nullptr) - {} - - ArrayProxy(T & ptr) - : m_count(1) - , m_ptr(&ptr) - {} - - ArrayProxy(uint32_t count, T * ptr) - : m_count(count) - , m_ptr(ptr) - {} - - template - ArrayProxy(std::array::type, N> & data) - : m_count(N) - , m_ptr(data.data()) - {} - - template - ArrayProxy(std::array::type, N> const& data) - : m_count(N) - , m_ptr(data.data()) - {} - - template ::type>> - ArrayProxy(std::vector::type, Allocator> & data) - : m_count(static_cast(data.size())) - , m_ptr(data.data()) - {} - - template ::type>> - ArrayProxy(std::vector::type, Allocator> const& data) - : m_count(static_cast(data.size())) - , m_ptr(data.data()) - {} - - ArrayProxy(std::initializer_list const& data) - : m_count(static_cast(data.end() - data.begin())) - , m_ptr(data.begin()) - {} - - const T * begin() const - { - return m_ptr; - } - - const T * end() const - { - return m_ptr + m_count; - } - - const T & front() const - { - VULKAN_HPP_ASSERT(m_count && m_ptr); - return *m_ptr; - } - - const T & back() const - { - VULKAN_HPP_ASSERT(m_count && m_ptr); - return *(m_ptr + m_count - 1); - } - - bool empty() const - { - return (m_count == 0); - } - - uint32_t size() const - { - return m_count; - } - - T * data() const - { - return m_ptr; - } - - private: - uint32_t m_count; - T * m_ptr; - }; -#endif - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - - template class UniqueHandleTraits; - - template - class UniqueHandle : public UniqueHandleTraits::deleter - { - private: - using Deleter = typename UniqueHandleTraits::deleter; - public: - explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() ) - : Deleter( deleter) - , m_value( value ) - {} - - UniqueHandle( UniqueHandle const& ) = delete; - - UniqueHandle( UniqueHandle && other ) - : Deleter( std::move( static_cast( other ) ) ) - , m_value( other.release() ) - {} - - ~UniqueHandle() - { - if ( m_value ) this->destroy( m_value ); - } - - UniqueHandle & operator=( UniqueHandle const& ) = delete; - - UniqueHandle & operator=( UniqueHandle && other ) - { - reset( other.release() ); - *static_cast(this) = std::move( static_cast(other) ); - return *this; - } - - explicit operator bool() const - { - return m_value.operator bool(); - } - - Type const* operator->() const - { - return &m_value; - } - - Type * operator->() - { - return &m_value; - } - - Type const& operator*() const - { - return m_value; - } - - Type & operator*() - { - return m_value; - } - - const Type & get() const - { - return m_value; - } - - Type & get() - { - return m_value; - } - - void reset( Type const& value = Type() ) - { - if ( m_value != value ) - { - if ( m_value ) this->destroy( m_value ); - m_value = value; - } - } - - Type release() - { - Type value = m_value; - m_value = nullptr; - return value; - } - - void swap( UniqueHandle & rhs ) - { - std::swap(m_value, rhs.m_value); - std::swap(static_cast(*this), static_cast(rhs)); - } - - private: - Type m_value; - }; - - template - VULKAN_HPP_INLINE void swap( UniqueHandle & lhs, UniqueHandle & rhs ) - { - lhs.swap( rhs ); - } -#endif - - - template struct isStructureChainValid { enum { value = false }; }; - - template - class StructureChainElement - { - public: - explicit operator Element&() { return value; } - explicit operator const Element&() const { return value; } - private: - Element value; - }; - - template - class StructureChain : private StructureChainElement... - { - public: - StructureChain() - { - link(); - } - - StructureChain(StructureChain const &rhs) - { - linkAndCopy(rhs); - } - - StructureChain(StructureElements const &... elems) - { - linkAndCopyElements(elems...); - } - - StructureChain& operator=(StructureChain const &rhs) - { - linkAndCopy(rhs); - return *this; - } - - template ClassType& get() { return static_cast(*this);} - - private: - template - void link() - { - } - - template - void link() - { - static_assert(isStructureChainValid::value, "The structure chain is not valid!"); - X& x = static_cast(*this); - Y& y = static_cast(*this); - x.pNext = &y; - link(); - } - - template - void linkAndCopy(StructureChain const &rhs) - { - static_cast(*this) = static_cast(rhs); - } - - template - void linkAndCopy(StructureChain const &rhs) - { - static_assert(isStructureChainValid::value, "The structure chain is not valid!"); - X& x = static_cast(*this); - Y& y = static_cast(*this); - x = static_cast(rhs); - x.pNext = &y; - linkAndCopy(rhs); - } - - template - void linkAndCopyElements(X const &xelem) - { - static_cast(*this) = xelem; - } - - template - void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem) - { - static_assert(isStructureChainValid::value, "The structure chain is not valid!"); - X& x = static_cast(*this); - Y& y = static_cast(*this); - x = xelem; - x.pNext = &y; - linkAndCopyElements(yelem, zelem...); - } - }; - - enum class Result - { - eSuccess = VK_SUCCESS, - eNotReady = VK_NOT_READY, - eTimeout = VK_TIMEOUT, - eEventSet = VK_EVENT_SET, - eEventReset = VK_EVENT_RESET, - eIncomplete = VK_INCOMPLETE, - eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY, - eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY, - eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED, - eErrorDeviceLost = VK_ERROR_DEVICE_LOST, - eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED, - eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT, - eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT, - eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT, - eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER, - eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS, - eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED, - eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL, - eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY, - eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY, - eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE, - eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, - eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR, - eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, - eSuboptimalKHR = VK_SUBOPTIMAL_KHR, - eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR, - eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, - eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, - eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, - eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT, - eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT - }; - - VULKAN_HPP_INLINE std::string to_string(Result value) - { - switch (value) - { - case Result::eSuccess: return "Success"; - case Result::eNotReady: return "NotReady"; - case Result::eTimeout: return "Timeout"; - case Result::eEventSet: return "EventSet"; - case Result::eEventReset: return "EventReset"; - case Result::eIncomplete: return "Incomplete"; - case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory"; - case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory"; - case Result::eErrorInitializationFailed: return "ErrorInitializationFailed"; - case Result::eErrorDeviceLost: return "ErrorDeviceLost"; - case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed"; - case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent"; - case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent"; - case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent"; - case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver"; - case Result::eErrorTooManyObjects: return "ErrorTooManyObjects"; - case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported"; - case Result::eErrorFragmentedPool: return "ErrorFragmentedPool"; - case Result::eErrorOutOfPoolMemory: return "ErrorOutOfPoolMemory"; - case Result::eErrorInvalidExternalHandle: return "ErrorInvalidExternalHandle"; - case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR"; - case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR"; - case Result::eSuboptimalKHR: return "SuboptimalKHR"; - case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR"; - case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR"; - case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT"; - case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV"; - case Result::eErrorFragmentationEXT: return "ErrorFragmentationEXT"; - case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT"; - default: return "invalid"; - } - } - -#ifndef VULKAN_HPP_NO_EXCEPTIONS -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# define noexcept _NOEXCEPT -#endif - - class ErrorCategoryImpl : public std::error_category - { - public: - virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; } - virtual std::string message(int ev) const override { return to_string(static_cast(ev)); } - }; - -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# undef noexcept -#endif - - VULKAN_HPP_INLINE const std::error_category& errorCategory() - { - static ErrorCategoryImpl instance; - return instance; - } - - VULKAN_HPP_INLINE std::error_code make_error_code(Result e) - { - return std::error_code(static_cast(e), errorCategory()); - } - - VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) - { - return std::error_condition(static_cast(e), errorCategory()); - } - -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# define noexcept _NOEXCEPT -#endif - - class Error - { - public: - virtual ~Error() = default; - - virtual const char* what() const noexcept = 0; - }; - - class LogicError : public Error, public std::logic_error - { - public: - explicit LogicError( const std::string& what ) - : Error(), std::logic_error(what) {} - explicit LogicError( char const * what ) - : Error(), std::logic_error(what) {} - virtual ~LogicError() = default; - - virtual const char* what() const noexcept { return std::logic_error::what(); } - }; - - class SystemError : public Error, public std::system_error - { - public: - SystemError( std::error_code ec ) - : Error(), std::system_error(ec) {} - SystemError( std::error_code ec, std::string const& what ) - : Error(), std::system_error(ec, what) {} - SystemError( std::error_code ec, char const * what ) - : Error(), std::system_error(ec, what) {} - SystemError( int ev, std::error_category const& ecat ) - : Error(), std::system_error(ev, ecat) {} - SystemError( int ev, std::error_category const& ecat, std::string const& what) - : Error(), std::system_error(ev, ecat, what) {} - SystemError( int ev, std::error_category const& ecat, char const * what) - : Error(), std::system_error(ev, ecat, what) {} - virtual ~SystemError() = default; - - virtual const char* what() const noexcept { return std::system_error::what(); } - }; - -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# undef noexcept -#endif - - class OutOfHostMemoryError : public SystemError - { - public: - OutOfHostMemoryError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} - OutOfHostMemoryError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} - }; - class OutOfDeviceMemoryError : public SystemError - { - public: - OutOfDeviceMemoryError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} - OutOfDeviceMemoryError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} - }; - class InitializationFailedError : public SystemError - { - public: - InitializationFailedError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} - InitializationFailedError( char const * message ) - : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} - }; - class DeviceLostError : public SystemError - { - public: - DeviceLostError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} - DeviceLostError( char const * message ) - : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} - }; - class MemoryMapFailedError : public SystemError - { - public: - MemoryMapFailedError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} - MemoryMapFailedError( char const * message ) - : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} - }; - class LayerNotPresentError : public SystemError - { - public: - LayerNotPresentError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} - LayerNotPresentError( char const * message ) - : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} - }; - class ExtensionNotPresentError : public SystemError - { - public: - ExtensionNotPresentError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} - ExtensionNotPresentError( char const * message ) - : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} - }; - class FeatureNotPresentError : public SystemError - { - public: - FeatureNotPresentError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} - FeatureNotPresentError( char const * message ) - : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} - }; - class IncompatibleDriverError : public SystemError - { - public: - IncompatibleDriverError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} - IncompatibleDriverError( char const * message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} - }; - class TooManyObjectsError : public SystemError - { - public: - TooManyObjectsError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} - TooManyObjectsError( char const * message ) - : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} - }; - class FormatNotSupportedError : public SystemError - { - public: - FormatNotSupportedError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} - FormatNotSupportedError( char const * message ) - : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} - }; - class FragmentedPoolError : public SystemError - { - public: - FragmentedPoolError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} - FragmentedPoolError( char const * message ) - : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} - }; - class OutOfPoolMemoryError : public SystemError - { - public: - OutOfPoolMemoryError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} - OutOfPoolMemoryError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} - }; - class InvalidExternalHandleError : public SystemError - { - public: - InvalidExternalHandleError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} - InvalidExternalHandleError( char const * message ) - : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} - }; - class SurfaceLostKHRError : public SystemError - { - public: - SurfaceLostKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} - SurfaceLostKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} - }; - class NativeWindowInUseKHRError : public SystemError - { - public: - NativeWindowInUseKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} - NativeWindowInUseKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} - }; - class OutOfDateKHRError : public SystemError - { - public: - OutOfDateKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} - OutOfDateKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} - }; - class IncompatibleDisplayKHRError : public SystemError - { - public: - IncompatibleDisplayKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} - IncompatibleDisplayKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} - }; - class ValidationFailedEXTError : public SystemError - { - public: - ValidationFailedEXTError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} - ValidationFailedEXTError( char const * message ) - : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} - }; - class InvalidShaderNVError : public SystemError - { - public: - InvalidShaderNVError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} - InvalidShaderNVError( char const * message ) - : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} - }; - class FragmentationEXTError : public SystemError - { - public: - FragmentationEXTError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {} - FragmentationEXTError( char const * message ) - : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {} - }; - class NotPermittedEXTError : public SystemError - { - public: - NotPermittedEXTError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} - NotPermittedEXTError( char const * message ) - : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} - }; - - VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) - { - switch ( result ) - { - case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError ( message ); - case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError ( message ); - case Result::eErrorInitializationFailed: throw InitializationFailedError ( message ); - case Result::eErrorDeviceLost: throw DeviceLostError ( message ); - case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError ( message ); - case Result::eErrorLayerNotPresent: throw LayerNotPresentError ( message ); - case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError ( message ); - case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError ( message ); - case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError ( message ); - case Result::eErrorTooManyObjects: throw TooManyObjectsError ( message ); - case Result::eErrorFormatNotSupported: throw FormatNotSupportedError ( message ); - case Result::eErrorFragmentedPool: throw FragmentedPoolError ( message ); - case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError ( message ); - case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError ( message ); - case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError ( message ); - case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError ( message ); - case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError ( message ); - case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message ); - case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message ); - case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message ); - case Result::eErrorFragmentationEXT: throw FragmentationEXTError ( message ); - case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message ); - default: throw SystemError( make_error_code( result ) ); - } - } -#endif -} // namespace VULKAN_HPP_NAMESPACE - -namespace std -{ - template <> - struct is_error_code_enum : public true_type - {}; -} - -namespace VULKAN_HPP_NAMESPACE -{ - - template - struct ResultValue - { - ResultValue( Result r, T & v ) - : result( r ) - , value( v ) - {} - - ResultValue( Result r, T && v ) - : result( r ) - , value( std::move( v ) ) - {} - - Result result; - T value; - - operator std::tuple() { return std::tuple(result, value); } - }; - - template - struct ResultValueType - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - typedef ResultValue type; -#else - typedef T type; -#endif - }; - - template <> - struct ResultValueType - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - typedef Result type; -#else - typedef void type; -#endif - }; - - VULKAN_HPP_INLINE ResultValueType::type createResultValue( Result result, char const * message ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( result == Result::eSuccess ); - return result; -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } -#endif - } - - template - VULKAN_HPP_INLINE typename ResultValueType::type createResultValue( Result result, T & data, char const * message ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( result == Result::eSuccess ); - return ResultValue( result, data ); -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } - return std::move( data ); -#endif - } - - VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list successCodes ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -#else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - throwResultException( result, message ); - } -#endif - return result; - } - - template - VULKAN_HPP_INLINE ResultValue createResultValue( Result result, T & data, char const * message, std::initializer_list successCodes ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -#else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - throwResultException( result, message ); - } -#endif - return ResultValue( result, data ); - } - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE typename ResultValueType>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits::deleter const& deleter ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( result == Result::eSuccess ); - return ResultValue>( result, UniqueHandle(data, deleter) ); -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } - return UniqueHandle(data, deleter); -#endif - } -#endif - - - struct AllocationCallbacks; - - template - class ObjectDestroy - { - public: - ObjectDestroy(OwnerType owner = OwnerType(), Optional allocator = nullptr) - : m_owner(owner) - , m_allocator(allocator) - {} - - OwnerType getOwner() const { return m_owner; } - Optional getAllocator() const { return m_allocator; } - - protected: - template - void destroy(T t) - { - m_owner.destroy(t, m_allocator); - } - - private: - OwnerType m_owner; - Optional m_allocator; - }; - - class NoParent; - - template <> - class ObjectDestroy - { - public: - ObjectDestroy( Optional allocator = nullptr ) - : m_allocator( allocator ) - {} - - Optional getAllocator() const { return m_allocator; } - - protected: - template - void destroy(T t) - { - t.destroy( m_allocator ); - } - - private: - Optional m_allocator; - }; - - template - class ObjectFree - { - public: - ObjectFree(OwnerType owner = OwnerType(), Optional allocator = nullptr) - : m_owner(owner) - , m_allocator(allocator) - {} - - OwnerType getOwner() const { return m_owner; } - Optional getAllocator() const { return m_allocator; } - - protected: - template - void destroy(T t) - { - m_owner.free(t, m_allocator); - } - - private: - OwnerType m_owner; - Optional m_allocator; - }; - - template - class PoolFree - { - public: - PoolFree(OwnerType owner = OwnerType(), PoolType pool = PoolType()) - : m_owner(owner) - , m_pool(pool) - {} - - OwnerType getOwner() const { return m_owner; } - PoolType getPool() const { return m_pool; } - - protected: - template - void destroy(T t) - { - m_owner.free(m_pool, t); - } - - private: - OwnerType m_owner; - PoolType m_pool; - }; - -class DispatchLoaderStatic -{ -public: - VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex ) const - { - return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex); - } - VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex ) const - { - return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex); - } -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const - { - return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display); - } -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const - { - return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers); - } - VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets ) const - { - return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets); - } - VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory ) const - { - return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory); - } - VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo ) const - { - return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo); - } - VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const - { - return ::vkBindBufferMemory( device, buffer, memory, memoryOffset); - } - VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const - { - return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos); - } - VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const - { - return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos); - } - VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const - { - return ::vkBindImageMemory( device, image, memory, memoryOffset); - } - VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const - { - return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos); - } - VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const - { - return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos); - } - void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const - { - return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo); - } - void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const - { - return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags); - } - void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents ) const - { - return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents); - } - void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const - { - return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); - } - void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const - { - return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType); - } - void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const - { - return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline); - } - void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets ) const - { - return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); - } - void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter ) const - { - return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); - } - void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects ) const - { - return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects); - } - void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const - { - return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); - } - void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const - { - return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); - } - void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions ) const - { - return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); - } - void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const - { - return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); - } - void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions ) const - { - return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); - } - void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const - { - return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); - } - void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags ) const - { - return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); - } - void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const - { - return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo); - } - void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const - { - return ::vkCmdDebugMarkerEndEXT( commandBuffer); - } - void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const - { - return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo); - } - void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const - { - return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ); - } - void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const - { - return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); - } - void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const - { - return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); - } - void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const - { - return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset); - } - void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const - { - return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); - } - void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const - { - return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); - } - void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const - { - return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride); - } - void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const - { - return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const - { - return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const - { - return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride); - } - void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const - { - return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const - { - return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const - { - return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer); - } - void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const - { - return ::vkCmdEndQuery( commandBuffer, queryPool, query); - } - void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const - { - return ::vkCmdEndRenderPass( commandBuffer); - } - void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const - { - return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers); - } - void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const - { - return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data); - } - void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const - { - return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo); - } - void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const - { - return ::vkCmdNextSubpass( commandBuffer, contents); - } - void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const - { - return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - } - void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const - { - return ::vkCmdProcessCommandsNVX( commandBuffer, pProcessCommandsInfo); - } - void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const - { - return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues); - } - void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites ) const - { - return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); - } - void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData ) const - { - return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData); - } - void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const - { - return ::vkCmdReserveSpaceForCommandsNVX( commandBuffer, pReserveSpaceInfo); - } - void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const - { - return ::vkCmdResetEvent( commandBuffer, event, stageMask); - } - void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const - { - return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount); - } - void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions ) const - { - return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); - } - void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const - { - return ::vkCmdSetBlendConstants( commandBuffer, blendConstants); - } - void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const - { - return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); - } - void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const - { - return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds); - } - void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const - { - return ::vkCmdSetDeviceMask( commandBuffer, deviceMask); - } - void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const - { - return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask); - } - void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles ) const - { - return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); - } - void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const - { - return ::vkCmdSetEvent( commandBuffer, event, stageMask); - } - void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const - { - return ::vkCmdSetLineWidth( commandBuffer, lineWidth); - } - void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo ) const - { - return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo); - } - void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors ) const - { - return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors); - } - void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const - { - return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask); - } - void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const - { - return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference); - } - void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const - { - return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask); - } - void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports ) const - { - return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports); - } - void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings ) const - { - return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings); - } - void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData ) const - { - return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData); - } - void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const - { - return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - } - void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const - { - return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); - } - void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) const - { - return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query); - } -#ifdef VK_USE_PLATFORM_ANDROID_KHR - VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer ) const - { - return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer); - } - VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView ) const - { - return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView); - } - VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool ) const - { - return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool); - } - VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const - { - return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback ) const - { - return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback); - } - VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger ) const - { - return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger); - } - VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool ) const - { - return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool); - } - VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout ) const - { - return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout); - } - VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const - { - return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - } - VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const - { - return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - } - VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice ) const - { - return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice); - } - VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode ) const - { - return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode); - } - VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } - VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent ) const - { - return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent); - } - VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const - { - return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence); - } - VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer ) const - { - return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer); - } - VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const - { - return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } -#ifdef VK_USE_PLATFORM_IOS_MVK - VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage ) const - { - return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage); - } - VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView ) const - { - return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView); - } - VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const - { - return ::vkCreateIndirectCommandsLayoutNVX( device, pCreateInfo, pAllocator, pIndirectCommandsLayout); - } - VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance ) const - { - return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance); - } -#ifdef VK_USE_PLATFORM_MACOS_MVK - VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - VkResult vkCreateMirSurfaceKHR( VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateMirSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable ) const - { - return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable); - } - VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache ) const - { - return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache); - } - VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout ) const - { - return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout); - } - VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool ) const - { - return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool); - } - VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const - { - return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass); - } - VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler ) const - { - return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler); - } - VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const - { - return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion); - } - VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const - { - return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion); - } - VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore ) const - { - return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore); - } - VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule ) const - { - return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule); - } - VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains ) const - { - return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); - } - VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain ) const - { - return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain); - } - VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache ) const - { - return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache); - } -#ifdef VK_USE_PLATFORM_VI_NN - VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_VI_NN*/ -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_XCB_KHR - VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#ifdef VK_USE_PLATFORM_XLIB_KHR - VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const - { - return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface); - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo ) const - { - return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo); - } - VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo ) const - { - return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo); - } - void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const - { - return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); - } - void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyBuffer( device, buffer, pAllocator); - } - void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyBufferView( device, bufferView, pAllocator); - } - void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyCommandPool( device, commandPool, pAllocator); - } - void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator); - } - void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator); - } - void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator); - } - void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator); - } - void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator); - } - void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator); - } - void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyDevice( device, pAllocator); - } - void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyEvent( device, event, pAllocator); - } - void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyFence( device, fence, pAllocator); - } - void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyFramebuffer( device, framebuffer, pAllocator); - } - void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyImage( device, image, pAllocator); - } - void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyImageView( device, imageView, pAllocator); - } - void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyIndirectCommandsLayoutNVX( device, indirectCommandsLayout, pAllocator); - } - void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyInstance( instance, pAllocator); - } - void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyObjectTableNVX( device, objectTable, pAllocator); - } - void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyPipeline( device, pipeline, pAllocator); - } - void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator); - } - void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator); - } - void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyQueryPool( device, queryPool, pAllocator); - } - void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyRenderPass( device, renderPass, pAllocator); - } - void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroySampler( device, sampler, pAllocator); - } - void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator); - } - void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator); - } - void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroySemaphore( device, semaphore, pAllocator); - } - void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyShaderModule( device, shaderModule, pAllocator); - } - void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroySurfaceKHR( instance, surface, pAllocator); - } - void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroySwapchainKHR( device, swapchain, pAllocator); - } - void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator); - } - VkResult vkDeviceWaitIdle( VkDevice device ) const - { - return ::vkDeviceWaitIdle( device); - } - VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo ) const - { - return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo); - } - VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const - { - return ::vkEndCommandBuffer( commandBuffer); - } - VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const - { - return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties); - } - VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const - { - return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties); - } - VkResult vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const - { - return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties); - } - VkResult vkEnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const - { - return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties); - } - VkResult vkEnumerateInstanceVersion( uint32_t* pApiVersion ) const - { - return ::vkEnumerateInstanceVersion( pApiVersion); - } - VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const - { - return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - } - VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const - { - return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - } - VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices ) const - { - return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices); - } - VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const - { - return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges); - } - void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const - { - return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers); - } - VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets ) const - { - return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets); - } - void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator ) const - { - return ::vkFreeMemory( device, memory, pAllocator); - } -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const - { - return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties); - } -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements ) const - { - return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements); - } - void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const - { - return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements); - } - void vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const - { - return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements); - } - void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const - { - return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport); - } - void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const - { - return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport); - } - void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const - { - return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); - } - void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const - { - return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); - } - VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities ) const - { - return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities); - } - VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes ) const - { - return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes); - } - void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes ) const - { - return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes); - } - PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char* pName ) const - { - return ::vkGetDeviceProcAddr( device, pName); - } - void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue ) const - { - return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue); - } - void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue ) const - { - return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue); - } - VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties ) const - { - return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties); - } - VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties ) const - { - return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties); - } - VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities ) const - { - return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities); - } - VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities ) const - { - return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities); - } - VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays ) const - { - return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays); - } - VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const - { - return ::vkGetEventStatus( device, event); - } - VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const - { - return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd); - } - VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const - { - return ::vkGetFenceStatus( device, fence); - } -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const - { - return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements ) const - { - return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements); - } - void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const - { - return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements); - } - void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const - { - return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements); - } - void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements ) const - { - return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const - { - return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const - { - return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout ) const - { - return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout); - } - PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName ) const - { - return ::vkGetInstanceProcAddr( instance, pName); - } -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer ) const - { - return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer); - } -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const - { - return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd); - } - VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties ) const - { - return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties); - } - VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const - { - return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties); - } -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const - { - return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_NV - VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const - { - return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle); - } -#endif /*VK_USE_PLATFORM_WIN32_NV*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const - { - return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings ) const - { - return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings); - } - VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties ) const - { - return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties); - } - VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties ) const - { - return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties); - } - VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties ) const - { - return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties); - } - VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties ) const - { - return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties); - } - void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const - { - return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties); - } - void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const - { - return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties); - } - void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const - { - return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties); - } - void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const - { - return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties); - } - VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const - { - return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); - } - void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const - { - return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - } - void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const - { - return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - } - void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures ) const - { - return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures); - } - void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const - { - return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures); - } - void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const - { - return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures); - } - void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties ) const - { - return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties); - } - void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const - { - return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties); - } - void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const - { - return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties); - } - void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits ) const - { - return ::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( physicalDevice, pFeatures, pLimits); - } - VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties ) const - { - return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); - } - VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const - { - return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties); - } - VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const - { - return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties); - } - void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties ) const - { - return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties); - } - void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const - { - return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties); - } - void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const - { - return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties); - } -#ifdef VK_USE_PLATFORM_MIR_KHR - VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection ) const - { - return ::vkGetPhysicalDeviceMirPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection); - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties ) const - { - return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties); - } - VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects ) const - { - return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects); - } - void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties ) const - { - return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties); - } - void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const - { - return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties); - } - void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const - { - return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties); - } - void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties ) const - { - return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } - void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const - { - return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } - void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const - { - return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } - void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties ) const - { - return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); - } - void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const - { - return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties); - } - void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const - { - return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties); - } - VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities ) const - { - return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities); - } - VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities ) const - { - return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities); - } - VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities ) const - { - return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities); - } - VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats ) const - { - return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); - } - VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats ) const - { - return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); - } - VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const - { - return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes); - } - VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported ) const - { - return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported); - } -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display ) const - { - return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display); - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const - { - return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_XCB_KHR - VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const - { - return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id); - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#ifdef VK_USE_PLATFORM_XLIB_KHR - VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const - { - return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID); - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData ) const - { - return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData); - } - VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const - { - return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); - } -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ) const - { - return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay); - } -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const - { - return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties); - } - void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity ) const - { - return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity); - } - VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const - { - return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd); - } -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const - { - return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const - { - return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo); - } - VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const - { - return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue); - } - VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages ) const - { - return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages); - } - VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const - { - return ::vkGetSwapchainStatusKHR( device, swapchain); - } - VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const - { - return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData); - } - VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo ) const - { - return ::vkImportFenceFdKHR( device, pImportFenceFdInfo); - } -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const - { - return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const - { - return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo); - } -#ifdef VK_USE_PLATFORM_WIN32_KHR - VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const - { - return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const - { - return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges); - } - VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData ) const - { - return ::vkMapMemory( device, memory, offset, size, flags, ppData); - } - VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches ) const - { - return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches); - } - VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches ) const - { - return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches); - } - void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const - { - return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo); - } - VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence ) const - { - return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence); - } - void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const - { - return ::vkQueueEndDebugUtilsLabelEXT( queue); - } - void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const - { - return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo); - } - VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo ) const - { - return ::vkQueuePresentKHR( queue, pPresentInfo); - } - VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence ) const - { - return ::vkQueueSubmit( queue, submitCount, pSubmits, fence); - } - VkResult vkQueueWaitIdle( VkQueue queue ) const - { - return ::vkQueueWaitIdle( queue); - } - VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const - { - return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence); - } - VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const - { - return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence); - } - VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const - { - return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); - } - VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const - { - return ::vkReleaseDisplayEXT( physicalDevice, display); - } - VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const - { - return ::vkResetCommandBuffer( commandBuffer, flags); - } - VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const - { - return ::vkResetCommandPool( device, commandPool, flags); - } - VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const - { - return ::vkResetDescriptorPool( device, descriptorPool, flags); - } - VkResult vkResetEvent( VkDevice device, VkEvent event ) const - { - return ::vkResetEvent( device, event); - } - VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences ) const - { - return ::vkResetFences( device, fenceCount, pFences); - } - VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo ) const - { - return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo); - } - VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo ) const - { - return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo); - } - VkResult vkSetEvent( VkDevice device, VkEvent event ) const - { - return ::vkSetEvent( device, event); - } - void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata ) const - { - return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata); - } - void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData ) const - { - return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData); - } - void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const - { - return ::vkTrimCommandPool( device, commandPool, flags); - } - void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const - { - return ::vkTrimCommandPoolKHR( device, commandPool, flags); - } - void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const - { - return ::vkUnmapMemory( device, memory); - } - VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const - { - return ::vkUnregisterObjectsNVX( device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); - } - void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const - { - return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData); - } - void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const - { - return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData); - } - void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies ) const - { - return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); - } - VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout ) const - { - return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout); - } -}; - using SampleMask = uint32_t; - - using Bool32 = uint32_t; - - using DeviceSize = uint64_t; - - enum class FramebufferCreateFlagBits - { - }; - - using FramebufferCreateFlags = Flags; - - enum class QueryPoolCreateFlagBits - { - }; - - using QueryPoolCreateFlags = Flags; - - enum class RenderPassCreateFlagBits - { - }; - - using RenderPassCreateFlags = Flags; - - enum class SamplerCreateFlagBits - { - }; - - using SamplerCreateFlags = Flags; - - enum class PipelineLayoutCreateFlagBits - { - }; - - using PipelineLayoutCreateFlags = Flags; - - enum class PipelineCacheCreateFlagBits - { - }; - - using PipelineCacheCreateFlags = Flags; - - enum class PipelineDepthStencilStateCreateFlagBits - { - }; - - using PipelineDepthStencilStateCreateFlags = Flags; - - enum class PipelineDynamicStateCreateFlagBits - { - }; - - using PipelineDynamicStateCreateFlags = Flags; - - enum class PipelineColorBlendStateCreateFlagBits - { - }; - - using PipelineColorBlendStateCreateFlags = Flags; - - enum class PipelineMultisampleStateCreateFlagBits - { - }; - - using PipelineMultisampleStateCreateFlags = Flags; - - enum class PipelineRasterizationStateCreateFlagBits - { - }; - - using PipelineRasterizationStateCreateFlags = Flags; - - enum class PipelineViewportStateCreateFlagBits - { - }; - - using PipelineViewportStateCreateFlags = Flags; - - enum class PipelineTessellationStateCreateFlagBits - { - }; - - using PipelineTessellationStateCreateFlags = Flags; - - enum class PipelineInputAssemblyStateCreateFlagBits - { - }; - - using PipelineInputAssemblyStateCreateFlags = Flags; - - enum class PipelineVertexInputStateCreateFlagBits - { - }; - - using PipelineVertexInputStateCreateFlags = Flags; - - enum class PipelineShaderStageCreateFlagBits - { - }; - - using PipelineShaderStageCreateFlags = Flags; - - enum class BufferViewCreateFlagBits - { - }; - - using BufferViewCreateFlags = Flags; - - enum class InstanceCreateFlagBits - { - }; - - using InstanceCreateFlags = Flags; - - enum class DeviceCreateFlagBits - { - }; - - using DeviceCreateFlags = Flags; - - enum class ImageViewCreateFlagBits - { - }; - - using ImageViewCreateFlags = Flags; - - enum class SemaphoreCreateFlagBits - { - }; - - using SemaphoreCreateFlags = Flags; - - enum class ShaderModuleCreateFlagBits - { - }; - - using ShaderModuleCreateFlags = Flags; - - enum class EventCreateFlagBits - { - }; - - using EventCreateFlags = Flags; - - enum class MemoryMapFlagBits - { - }; - - using MemoryMapFlags = Flags; - - enum class DescriptorPoolResetFlagBits - { - }; - - using DescriptorPoolResetFlags = Flags; - - enum class DescriptorUpdateTemplateCreateFlagBits - { - }; - - using DescriptorUpdateTemplateCreateFlags = Flags; - - using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; - - enum class DisplayModeCreateFlagBitsKHR - { - }; - - using DisplayModeCreateFlagsKHR = Flags; - - enum class DisplaySurfaceCreateFlagBitsKHR - { - }; - - using DisplaySurfaceCreateFlagsKHR = Flags; - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - enum class AndroidSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - using AndroidSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - enum class MirSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - using MirSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_VI_NN - enum class ViSurfaceCreateFlagBitsNN - { - }; -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_VI_NN - using ViSurfaceCreateFlagsNN = Flags; -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - enum class WaylandSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - using WaylandSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - enum class Win32SurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - using Win32SurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - enum class XlibSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - using XlibSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - enum class XcbSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - using XcbSurfaceCreateFlagsKHR = Flags; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - enum class IOSSurfaceCreateFlagBitsMVK - { - }; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - using IOSSurfaceCreateFlagsMVK = Flags; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - enum class MacOSSurfaceCreateFlagBitsMVK - { - }; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - using MacOSSurfaceCreateFlagsMVK = Flags; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - enum class CommandPoolTrimFlagBits - { - }; - - using CommandPoolTrimFlags = Flags; - - using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; - - enum class PipelineViewportSwizzleStateCreateFlagBitsNV - { - }; - - using PipelineViewportSwizzleStateCreateFlagsNV = Flags; - - enum class PipelineDiscardRectangleStateCreateFlagBitsEXT - { - }; - - using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; - - enum class PipelineCoverageToColorStateCreateFlagBitsNV - { - }; - - using PipelineCoverageToColorStateCreateFlagsNV = Flags; - - enum class PipelineCoverageModulationStateCreateFlagBitsNV - { - }; - - using PipelineCoverageModulationStateCreateFlagsNV = Flags; - - enum class ValidationCacheCreateFlagBitsEXT - { - }; - - using ValidationCacheCreateFlagsEXT = Flags; - - enum class DebugUtilsMessengerCreateFlagBitsEXT - { - }; - - using DebugUtilsMessengerCreateFlagsEXT = Flags; - - enum class DebugUtilsMessengerCallbackDataFlagBitsEXT - { - }; - - using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; - - enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT - { - }; - - using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; - - class DeviceMemory - { - public: - VULKAN_HPP_CONSTEXPR DeviceMemory() - : m_deviceMemory(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) - : m_deviceMemory(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) - : m_deviceMemory( deviceMemory ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DeviceMemory & operator=(VkDeviceMemory deviceMemory) - { - m_deviceMemory = deviceMemory; - return *this; - } -#endif - - DeviceMemory & operator=( std::nullptr_t ) - { - m_deviceMemory = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DeviceMemory const & rhs ) const - { - return m_deviceMemory == rhs.m_deviceMemory; - } - - bool operator!=(DeviceMemory const & rhs ) const - { - return m_deviceMemory != rhs.m_deviceMemory; - } - - bool operator<(DeviceMemory const & rhs ) const - { - return m_deviceMemory < rhs.m_deviceMemory; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const - { - return m_deviceMemory; - } - - explicit operator bool() const - { - return m_deviceMemory != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_deviceMemory == VK_NULL_HANDLE; - } - - private: - VkDeviceMemory m_deviceMemory; - }; - - static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); - - class CommandPool - { - public: - VULKAN_HPP_CONSTEXPR CommandPool() - : m_commandPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) - : m_commandPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) - : m_commandPool( commandPool ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandPool & operator=(VkCommandPool commandPool) - { - m_commandPool = commandPool; - return *this; - } -#endif - - CommandPool & operator=( std::nullptr_t ) - { - m_commandPool = VK_NULL_HANDLE; - return *this; - } - - bool operator==( CommandPool const & rhs ) const - { - return m_commandPool == rhs.m_commandPool; - } - - bool operator!=(CommandPool const & rhs ) const - { - return m_commandPool != rhs.m_commandPool; - } - - bool operator<(CommandPool const & rhs ) const - { - return m_commandPool < rhs.m_commandPool; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const - { - return m_commandPool; - } - - explicit operator bool() const - { - return m_commandPool != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_commandPool == VK_NULL_HANDLE; - } - - private: - VkCommandPool m_commandPool; - }; - - static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); - - class Buffer - { - public: - VULKAN_HPP_CONSTEXPR Buffer() - : m_buffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) - : m_buffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) - : m_buffer( buffer ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Buffer & operator=(VkBuffer buffer) - { - m_buffer = buffer; - return *this; - } -#endif - - Buffer & operator=( std::nullptr_t ) - { - m_buffer = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Buffer const & rhs ) const - { - return m_buffer == rhs.m_buffer; - } - - bool operator!=(Buffer const & rhs ) const - { - return m_buffer != rhs.m_buffer; - } - - bool operator<(Buffer const & rhs ) const - { - return m_buffer < rhs.m_buffer; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const - { - return m_buffer; - } - - explicit operator bool() const - { - return m_buffer != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_buffer == VK_NULL_HANDLE; - } - - private: - VkBuffer m_buffer; - }; - - static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); - - class BufferView - { - public: - VULKAN_HPP_CONSTEXPR BufferView() - : m_bufferView(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) - : m_bufferView(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) - : m_bufferView( bufferView ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - BufferView & operator=(VkBufferView bufferView) - { - m_bufferView = bufferView; - return *this; - } -#endif - - BufferView & operator=( std::nullptr_t ) - { - m_bufferView = VK_NULL_HANDLE; - return *this; - } - - bool operator==( BufferView const & rhs ) const - { - return m_bufferView == rhs.m_bufferView; - } - - bool operator!=(BufferView const & rhs ) const - { - return m_bufferView != rhs.m_bufferView; - } - - bool operator<(BufferView const & rhs ) const - { - return m_bufferView < rhs.m_bufferView; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const - { - return m_bufferView; - } - - explicit operator bool() const - { - return m_bufferView != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_bufferView == VK_NULL_HANDLE; - } - - private: - VkBufferView m_bufferView; - }; - - static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); - - class Image - { - public: - VULKAN_HPP_CONSTEXPR Image() - : m_image(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) - : m_image(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) - : m_image( image ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Image & operator=(VkImage image) - { - m_image = image; - return *this; - } -#endif - - Image & operator=( std::nullptr_t ) - { - m_image = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Image const & rhs ) const - { - return m_image == rhs.m_image; - } - - bool operator!=(Image const & rhs ) const - { - return m_image != rhs.m_image; - } - - bool operator<(Image const & rhs ) const - { - return m_image < rhs.m_image; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const - { - return m_image; - } - - explicit operator bool() const - { - return m_image != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_image == VK_NULL_HANDLE; - } - - private: - VkImage m_image; - }; - - static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); - - class ImageView - { - public: - VULKAN_HPP_CONSTEXPR ImageView() - : m_imageView(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) - : m_imageView(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) - : m_imageView( imageView ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ImageView & operator=(VkImageView imageView) - { - m_imageView = imageView; - return *this; - } -#endif - - ImageView & operator=( std::nullptr_t ) - { - m_imageView = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ImageView const & rhs ) const - { - return m_imageView == rhs.m_imageView; - } - - bool operator!=(ImageView const & rhs ) const - { - return m_imageView != rhs.m_imageView; - } - - bool operator<(ImageView const & rhs ) const - { - return m_imageView < rhs.m_imageView; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const - { - return m_imageView; - } - - explicit operator bool() const - { - return m_imageView != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_imageView == VK_NULL_HANDLE; - } - - private: - VkImageView m_imageView; - }; - - static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); - - class ShaderModule - { - public: - VULKAN_HPP_CONSTEXPR ShaderModule() - : m_shaderModule(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) - : m_shaderModule(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) - : m_shaderModule( shaderModule ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ShaderModule & operator=(VkShaderModule shaderModule) - { - m_shaderModule = shaderModule; - return *this; - } -#endif - - ShaderModule & operator=( std::nullptr_t ) - { - m_shaderModule = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ShaderModule const & rhs ) const - { - return m_shaderModule == rhs.m_shaderModule; - } - - bool operator!=(ShaderModule const & rhs ) const - { - return m_shaderModule != rhs.m_shaderModule; - } - - bool operator<(ShaderModule const & rhs ) const - { - return m_shaderModule < rhs.m_shaderModule; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const - { - return m_shaderModule; - } - - explicit operator bool() const - { - return m_shaderModule != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_shaderModule == VK_NULL_HANDLE; - } - - private: - VkShaderModule m_shaderModule; - }; - - static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); - - class Pipeline - { - public: - VULKAN_HPP_CONSTEXPR Pipeline() - : m_pipeline(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) - : m_pipeline(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) - : m_pipeline( pipeline ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Pipeline & operator=(VkPipeline pipeline) - { - m_pipeline = pipeline; - return *this; - } -#endif - - Pipeline & operator=( std::nullptr_t ) - { - m_pipeline = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Pipeline const & rhs ) const - { - return m_pipeline == rhs.m_pipeline; - } - - bool operator!=(Pipeline const & rhs ) const - { - return m_pipeline != rhs.m_pipeline; - } - - bool operator<(Pipeline const & rhs ) const - { - return m_pipeline < rhs.m_pipeline; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const - { - return m_pipeline; - } - - explicit operator bool() const - { - return m_pipeline != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_pipeline == VK_NULL_HANDLE; - } - - private: - VkPipeline m_pipeline; - }; - - static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); - - class PipelineLayout - { - public: - VULKAN_HPP_CONSTEXPR PipelineLayout() - : m_pipelineLayout(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) - : m_pipelineLayout(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) - : m_pipelineLayout( pipelineLayout ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineLayout & operator=(VkPipelineLayout pipelineLayout) - { - m_pipelineLayout = pipelineLayout; - return *this; - } -#endif - - PipelineLayout & operator=( std::nullptr_t ) - { - m_pipelineLayout = VK_NULL_HANDLE; - return *this; - } - - bool operator==( PipelineLayout const & rhs ) const - { - return m_pipelineLayout == rhs.m_pipelineLayout; - } - - bool operator!=(PipelineLayout const & rhs ) const - { - return m_pipelineLayout != rhs.m_pipelineLayout; - } - - bool operator<(PipelineLayout const & rhs ) const - { - return m_pipelineLayout < rhs.m_pipelineLayout; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const - { - return m_pipelineLayout; - } - - explicit operator bool() const - { - return m_pipelineLayout != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_pipelineLayout == VK_NULL_HANDLE; - } - - private: - VkPipelineLayout m_pipelineLayout; - }; - - static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); - - class Sampler - { - public: - VULKAN_HPP_CONSTEXPR Sampler() - : m_sampler(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) - : m_sampler(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) - : m_sampler( sampler ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Sampler & operator=(VkSampler sampler) - { - m_sampler = sampler; - return *this; - } -#endif - - Sampler & operator=( std::nullptr_t ) - { - m_sampler = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Sampler const & rhs ) const - { - return m_sampler == rhs.m_sampler; - } - - bool operator!=(Sampler const & rhs ) const - { - return m_sampler != rhs.m_sampler; - } - - bool operator<(Sampler const & rhs ) const - { - return m_sampler < rhs.m_sampler; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const - { - return m_sampler; - } - - explicit operator bool() const - { - return m_sampler != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_sampler == VK_NULL_HANDLE; - } - - private: - VkSampler m_sampler; - }; - - static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); - - class DescriptorSet - { - public: - VULKAN_HPP_CONSTEXPR DescriptorSet() - : m_descriptorSet(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) - : m_descriptorSet(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) - : m_descriptorSet( descriptorSet ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSet & operator=(VkDescriptorSet descriptorSet) - { - m_descriptorSet = descriptorSet; - return *this; - } -#endif - - DescriptorSet & operator=( std::nullptr_t ) - { - m_descriptorSet = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorSet const & rhs ) const - { - return m_descriptorSet == rhs.m_descriptorSet; - } - - bool operator!=(DescriptorSet const & rhs ) const - { - return m_descriptorSet != rhs.m_descriptorSet; - } - - bool operator<(DescriptorSet const & rhs ) const - { - return m_descriptorSet < rhs.m_descriptorSet; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const - { - return m_descriptorSet; - } - - explicit operator bool() const - { - return m_descriptorSet != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorSet == VK_NULL_HANDLE; - } - - private: - VkDescriptorSet m_descriptorSet; - }; - - static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); - - class DescriptorSetLayout - { - public: - VULKAN_HPP_CONSTEXPR DescriptorSetLayout() - : m_descriptorSetLayout(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) - : m_descriptorSetLayout(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) - : m_descriptorSetLayout( descriptorSetLayout ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) - { - m_descriptorSetLayout = descriptorSetLayout; - return *this; - } -#endif - - DescriptorSetLayout & operator=( std::nullptr_t ) - { - m_descriptorSetLayout = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorSetLayout const & rhs ) const - { - return m_descriptorSetLayout == rhs.m_descriptorSetLayout; - } - - bool operator!=(DescriptorSetLayout const & rhs ) const - { - return m_descriptorSetLayout != rhs.m_descriptorSetLayout; - } - - bool operator<(DescriptorSetLayout const & rhs ) const - { - return m_descriptorSetLayout < rhs.m_descriptorSetLayout; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const - { - return m_descriptorSetLayout; - } - - explicit operator bool() const - { - return m_descriptorSetLayout != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorSetLayout == VK_NULL_HANDLE; - } - - private: - VkDescriptorSetLayout m_descriptorSetLayout; - }; - - static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); - - class DescriptorPool - { - public: - VULKAN_HPP_CONSTEXPR DescriptorPool() - : m_descriptorPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) - : m_descriptorPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) - : m_descriptorPool( descriptorPool ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorPool & operator=(VkDescriptorPool descriptorPool) - { - m_descriptorPool = descriptorPool; - return *this; - } -#endif - - DescriptorPool & operator=( std::nullptr_t ) - { - m_descriptorPool = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorPool const & rhs ) const - { - return m_descriptorPool == rhs.m_descriptorPool; - } - - bool operator!=(DescriptorPool const & rhs ) const - { - return m_descriptorPool != rhs.m_descriptorPool; - } - - bool operator<(DescriptorPool const & rhs ) const - { - return m_descriptorPool < rhs.m_descriptorPool; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const - { - return m_descriptorPool; - } - - explicit operator bool() const - { - return m_descriptorPool != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorPool == VK_NULL_HANDLE; - } - - private: - VkDescriptorPool m_descriptorPool; - }; - - static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); - - class Fence - { - public: - VULKAN_HPP_CONSTEXPR Fence() - : m_fence(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) - : m_fence(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) - : m_fence( fence ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Fence & operator=(VkFence fence) - { - m_fence = fence; - return *this; - } -#endif - - Fence & operator=( std::nullptr_t ) - { - m_fence = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Fence const & rhs ) const - { - return m_fence == rhs.m_fence; - } - - bool operator!=(Fence const & rhs ) const - { - return m_fence != rhs.m_fence; - } - - bool operator<(Fence const & rhs ) const - { - return m_fence < rhs.m_fence; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const - { - return m_fence; - } - - explicit operator bool() const - { - return m_fence != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_fence == VK_NULL_HANDLE; - } - - private: - VkFence m_fence; - }; - - static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); - - class Semaphore - { - public: - VULKAN_HPP_CONSTEXPR Semaphore() - : m_semaphore(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) - : m_semaphore(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) - : m_semaphore( semaphore ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Semaphore & operator=(VkSemaphore semaphore) - { - m_semaphore = semaphore; - return *this; - } -#endif - - Semaphore & operator=( std::nullptr_t ) - { - m_semaphore = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Semaphore const & rhs ) const - { - return m_semaphore == rhs.m_semaphore; - } - - bool operator!=(Semaphore const & rhs ) const - { - return m_semaphore != rhs.m_semaphore; - } - - bool operator<(Semaphore const & rhs ) const - { - return m_semaphore < rhs.m_semaphore; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const - { - return m_semaphore; - } - - explicit operator bool() const - { - return m_semaphore != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_semaphore == VK_NULL_HANDLE; - } - - private: - VkSemaphore m_semaphore; - }; - - static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); - - class Event - { - public: - VULKAN_HPP_CONSTEXPR Event() - : m_event(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) - : m_event(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) - : m_event( event ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Event & operator=(VkEvent event) - { - m_event = event; - return *this; - } -#endif - - Event & operator=( std::nullptr_t ) - { - m_event = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Event const & rhs ) const - { - return m_event == rhs.m_event; - } - - bool operator!=(Event const & rhs ) const - { - return m_event != rhs.m_event; - } - - bool operator<(Event const & rhs ) const - { - return m_event < rhs.m_event; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const - { - return m_event; - } - - explicit operator bool() const - { - return m_event != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_event == VK_NULL_HANDLE; - } - - private: - VkEvent m_event; - }; - - static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); - - class QueryPool - { - public: - VULKAN_HPP_CONSTEXPR QueryPool() - : m_queryPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) - : m_queryPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) - : m_queryPool( queryPool ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - QueryPool & operator=(VkQueryPool queryPool) - { - m_queryPool = queryPool; - return *this; - } -#endif - - QueryPool & operator=( std::nullptr_t ) - { - m_queryPool = VK_NULL_HANDLE; - return *this; - } - - bool operator==( QueryPool const & rhs ) const - { - return m_queryPool == rhs.m_queryPool; - } - - bool operator!=(QueryPool const & rhs ) const - { - return m_queryPool != rhs.m_queryPool; - } - - bool operator<(QueryPool const & rhs ) const - { - return m_queryPool < rhs.m_queryPool; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const - { - return m_queryPool; - } - - explicit operator bool() const - { - return m_queryPool != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_queryPool == VK_NULL_HANDLE; - } - - private: - VkQueryPool m_queryPool; - }; - - static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); - - class Framebuffer - { - public: - VULKAN_HPP_CONSTEXPR Framebuffer() - : m_framebuffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) - : m_framebuffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) - : m_framebuffer( framebuffer ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Framebuffer & operator=(VkFramebuffer framebuffer) - { - m_framebuffer = framebuffer; - return *this; - } -#endif - - Framebuffer & operator=( std::nullptr_t ) - { - m_framebuffer = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Framebuffer const & rhs ) const - { - return m_framebuffer == rhs.m_framebuffer; - } - - bool operator!=(Framebuffer const & rhs ) const - { - return m_framebuffer != rhs.m_framebuffer; - } - - bool operator<(Framebuffer const & rhs ) const - { - return m_framebuffer < rhs.m_framebuffer; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const - { - return m_framebuffer; - } - - explicit operator bool() const - { - return m_framebuffer != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_framebuffer == VK_NULL_HANDLE; - } - - private: - VkFramebuffer m_framebuffer; - }; - - static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); - - class RenderPass - { - public: - VULKAN_HPP_CONSTEXPR RenderPass() - : m_renderPass(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) - : m_renderPass(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) - : m_renderPass( renderPass ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - RenderPass & operator=(VkRenderPass renderPass) - { - m_renderPass = renderPass; - return *this; - } -#endif - - RenderPass & operator=( std::nullptr_t ) - { - m_renderPass = VK_NULL_HANDLE; - return *this; - } - - bool operator==( RenderPass const & rhs ) const - { - return m_renderPass == rhs.m_renderPass; - } - - bool operator!=(RenderPass const & rhs ) const - { - return m_renderPass != rhs.m_renderPass; - } - - bool operator<(RenderPass const & rhs ) const - { - return m_renderPass < rhs.m_renderPass; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const - { - return m_renderPass; - } - - explicit operator bool() const - { - return m_renderPass != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_renderPass == VK_NULL_HANDLE; - } - - private: - VkRenderPass m_renderPass; - }; - - static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); - - class PipelineCache - { - public: - VULKAN_HPP_CONSTEXPR PipelineCache() - : m_pipelineCache(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) - : m_pipelineCache(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) - : m_pipelineCache( pipelineCache ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineCache & operator=(VkPipelineCache pipelineCache) - { - m_pipelineCache = pipelineCache; - return *this; - } -#endif - - PipelineCache & operator=( std::nullptr_t ) - { - m_pipelineCache = VK_NULL_HANDLE; - return *this; - } - - bool operator==( PipelineCache const & rhs ) const - { - return m_pipelineCache == rhs.m_pipelineCache; - } - - bool operator!=(PipelineCache const & rhs ) const - { - return m_pipelineCache != rhs.m_pipelineCache; - } - - bool operator<(PipelineCache const & rhs ) const - { - return m_pipelineCache < rhs.m_pipelineCache; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const - { - return m_pipelineCache; - } - - explicit operator bool() const - { - return m_pipelineCache != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_pipelineCache == VK_NULL_HANDLE; - } - - private: - VkPipelineCache m_pipelineCache; - }; - - static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); - - class ObjectTableNVX - { - public: - VULKAN_HPP_CONSTEXPR ObjectTableNVX() - : m_objectTableNVX(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR ObjectTableNVX( std::nullptr_t ) - : m_objectTableNVX(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX ) - : m_objectTableNVX( objectTableNVX ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX) - { - m_objectTableNVX = objectTableNVX; - return *this; - } -#endif - - ObjectTableNVX & operator=( std::nullptr_t ) - { - m_objectTableNVX = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ObjectTableNVX const & rhs ) const - { - return m_objectTableNVX == rhs.m_objectTableNVX; - } - - bool operator!=(ObjectTableNVX const & rhs ) const - { - return m_objectTableNVX != rhs.m_objectTableNVX; - } - - bool operator<(ObjectTableNVX const & rhs ) const - { - return m_objectTableNVX < rhs.m_objectTableNVX; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const - { - return m_objectTableNVX; - } - - explicit operator bool() const - { - return m_objectTableNVX != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_objectTableNVX == VK_NULL_HANDLE; - } - - private: - VkObjectTableNVX m_objectTableNVX; - }; - - static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" ); - - class IndirectCommandsLayoutNVX - { - public: - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX() - : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX( std::nullptr_t ) - : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX ) - : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) - { - m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX; - return *this; - } -#endif - - IndirectCommandsLayoutNVX & operator=( std::nullptr_t ) - { - m_indirectCommandsLayoutNVX = VK_NULL_HANDLE; - return *this; - } - - bool operator==( IndirectCommandsLayoutNVX const & rhs ) const - { - return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX; - } - - bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const - { - return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX; - } - - bool operator<(IndirectCommandsLayoutNVX const & rhs ) const - { - return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const - { - return m_indirectCommandsLayoutNVX; - } - - explicit operator bool() const - { - return m_indirectCommandsLayoutNVX != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_indirectCommandsLayoutNVX == VK_NULL_HANDLE; - } - - private: - VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX; - }; - - static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" ); - - class DescriptorUpdateTemplate - { - public: - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() - : m_descriptorUpdateTemplate(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) - : m_descriptorUpdateTemplate(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) - : m_descriptorUpdateTemplate( descriptorUpdateTemplate ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate) - { - m_descriptorUpdateTemplate = descriptorUpdateTemplate; - return *this; - } -#endif - - DescriptorUpdateTemplate & operator=( std::nullptr_t ) - { - m_descriptorUpdateTemplate = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorUpdateTemplate const & rhs ) const - { - return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate; - } - - bool operator!=(DescriptorUpdateTemplate const & rhs ) const - { - return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate; - } - - bool operator<(DescriptorUpdateTemplate const & rhs ) const - { - return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const - { - return m_descriptorUpdateTemplate; - } - - explicit operator bool() const - { - return m_descriptorUpdateTemplate != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorUpdateTemplate == VK_NULL_HANDLE; - } - - private: - VkDescriptorUpdateTemplate m_descriptorUpdateTemplate; - }; - - static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); - - using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; - - class SamplerYcbcrConversion - { - public: - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() - : m_samplerYcbcrConversion(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) - : m_samplerYcbcrConversion(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) - : m_samplerYcbcrConversion( samplerYcbcrConversion ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion) - { - m_samplerYcbcrConversion = samplerYcbcrConversion; - return *this; - } -#endif - - SamplerYcbcrConversion & operator=( std::nullptr_t ) - { - m_samplerYcbcrConversion = VK_NULL_HANDLE; - return *this; - } - - bool operator==( SamplerYcbcrConversion const & rhs ) const - { - return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion; - } - - bool operator!=(SamplerYcbcrConversion const & rhs ) const - { - return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion; - } - - bool operator<(SamplerYcbcrConversion const & rhs ) const - { - return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const - { - return m_samplerYcbcrConversion; - } - - explicit operator bool() const - { - return m_samplerYcbcrConversion != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_samplerYcbcrConversion == VK_NULL_HANDLE; - } - - private: - VkSamplerYcbcrConversion m_samplerYcbcrConversion; - }; - - static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); - - using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; - - class ValidationCacheEXT - { - public: - VULKAN_HPP_CONSTEXPR ValidationCacheEXT() - : m_validationCacheEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) - : m_validationCacheEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) - : m_validationCacheEXT( validationCacheEXT ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT) - { - m_validationCacheEXT = validationCacheEXT; - return *this; - } -#endif - - ValidationCacheEXT & operator=( std::nullptr_t ) - { - m_validationCacheEXT = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ValidationCacheEXT const & rhs ) const - { - return m_validationCacheEXT == rhs.m_validationCacheEXT; - } - - bool operator!=(ValidationCacheEXT const & rhs ) const - { - return m_validationCacheEXT != rhs.m_validationCacheEXT; - } - - bool operator<(ValidationCacheEXT const & rhs ) const - { - return m_validationCacheEXT < rhs.m_validationCacheEXT; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const - { - return m_validationCacheEXT; - } - - explicit operator bool() const - { - return m_validationCacheEXT != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_validationCacheEXT == VK_NULL_HANDLE; - } - - private: - VkValidationCacheEXT m_validationCacheEXT; - }; - - static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); - - class DisplayKHR - { - public: - VULKAN_HPP_CONSTEXPR DisplayKHR() - : m_displayKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) - : m_displayKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) - : m_displayKHR( displayKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayKHR & operator=(VkDisplayKHR displayKHR) - { - m_displayKHR = displayKHR; - return *this; - } -#endif - - DisplayKHR & operator=( std::nullptr_t ) - { - m_displayKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DisplayKHR const & rhs ) const - { - return m_displayKHR == rhs.m_displayKHR; - } - - bool operator!=(DisplayKHR const & rhs ) const - { - return m_displayKHR != rhs.m_displayKHR; - } - - bool operator<(DisplayKHR const & rhs ) const - { - return m_displayKHR < rhs.m_displayKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const - { - return m_displayKHR; - } - - explicit operator bool() const - { - return m_displayKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_displayKHR == VK_NULL_HANDLE; - } - - private: - VkDisplayKHR m_displayKHR; - }; - - static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); - - class DisplayModeKHR - { - public: - VULKAN_HPP_CONSTEXPR DisplayModeKHR() - : m_displayModeKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) - : m_displayModeKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) - : m_displayModeKHR( displayModeKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) - { - m_displayModeKHR = displayModeKHR; - return *this; - } -#endif - - DisplayModeKHR & operator=( std::nullptr_t ) - { - m_displayModeKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DisplayModeKHR const & rhs ) const - { - return m_displayModeKHR == rhs.m_displayModeKHR; - } - - bool operator!=(DisplayModeKHR const & rhs ) const - { - return m_displayModeKHR != rhs.m_displayModeKHR; - } - - bool operator<(DisplayModeKHR const & rhs ) const - { - return m_displayModeKHR < rhs.m_displayModeKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const - { - return m_displayModeKHR; - } - - explicit operator bool() const - { - return m_displayModeKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_displayModeKHR == VK_NULL_HANDLE; - } - - private: - VkDisplayModeKHR m_displayModeKHR; - }; - - static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); - - class SurfaceKHR - { - public: - VULKAN_HPP_CONSTEXPR SurfaceKHR() - : m_surfaceKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) - : m_surfaceKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) - : m_surfaceKHR( surfaceKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) - { - m_surfaceKHR = surfaceKHR; - return *this; - } -#endif - - SurfaceKHR & operator=( std::nullptr_t ) - { - m_surfaceKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( SurfaceKHR const & rhs ) const - { - return m_surfaceKHR == rhs.m_surfaceKHR; - } - - bool operator!=(SurfaceKHR const & rhs ) const - { - return m_surfaceKHR != rhs.m_surfaceKHR; - } - - bool operator<(SurfaceKHR const & rhs ) const - { - return m_surfaceKHR < rhs.m_surfaceKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const - { - return m_surfaceKHR; - } - - explicit operator bool() const - { - return m_surfaceKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_surfaceKHR == VK_NULL_HANDLE; - } - - private: - VkSurfaceKHR m_surfaceKHR; - }; - - static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); - - class SwapchainKHR - { - public: - VULKAN_HPP_CONSTEXPR SwapchainKHR() - : m_swapchainKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) - : m_swapchainKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) - : m_swapchainKHR( swapchainKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) - { - m_swapchainKHR = swapchainKHR; - return *this; - } -#endif - - SwapchainKHR & operator=( std::nullptr_t ) - { - m_swapchainKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( SwapchainKHR const & rhs ) const - { - return m_swapchainKHR == rhs.m_swapchainKHR; - } - - bool operator!=(SwapchainKHR const & rhs ) const - { - return m_swapchainKHR != rhs.m_swapchainKHR; - } - - bool operator<(SwapchainKHR const & rhs ) const - { - return m_swapchainKHR < rhs.m_swapchainKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const - { - return m_swapchainKHR; - } - - explicit operator bool() const - { - return m_swapchainKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_swapchainKHR == VK_NULL_HANDLE; - } - - private: - VkSwapchainKHR m_swapchainKHR; - }; - - static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); - - class DebugReportCallbackEXT - { - public: - VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() - : m_debugReportCallbackEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) - : m_debugReportCallbackEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) - : m_debugReportCallbackEXT( debugReportCallbackEXT ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) - { - m_debugReportCallbackEXT = debugReportCallbackEXT; - return *this; - } -#endif - - DebugReportCallbackEXT & operator=( std::nullptr_t ) - { - m_debugReportCallbackEXT = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DebugReportCallbackEXT const & rhs ) const - { - return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT; - } - - bool operator!=(DebugReportCallbackEXT const & rhs ) const - { - return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT; - } - - bool operator<(DebugReportCallbackEXT const & rhs ) const - { - return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const - { - return m_debugReportCallbackEXT; - } - - explicit operator bool() const - { - return m_debugReportCallbackEXT != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_debugReportCallbackEXT == VK_NULL_HANDLE; - } - - private: - VkDebugReportCallbackEXT m_debugReportCallbackEXT; - }; - - static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); - - class DebugUtilsMessengerEXT - { - public: - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() - : m_debugUtilsMessengerEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) - : m_debugUtilsMessengerEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) - : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) - { - m_debugUtilsMessengerEXT = debugUtilsMessengerEXT; - return *this; - } -#endif - - DebugUtilsMessengerEXT & operator=( std::nullptr_t ) - { - m_debugUtilsMessengerEXT = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DebugUtilsMessengerEXT const & rhs ) const - { - return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT; - } - - bool operator!=(DebugUtilsMessengerEXT const & rhs ) const - { - return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT; - } - - bool operator<(DebugUtilsMessengerEXT const & rhs ) const - { - return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const - { - return m_debugUtilsMessengerEXT; - } - - explicit operator bool() const - { - return m_debugUtilsMessengerEXT != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_debugUtilsMessengerEXT == VK_NULL_HANDLE; - } - - private: - VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT; - }; - - static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" ); - - struct Offset2D - { - Offset2D( int32_t x_ = 0, - int32_t y_ = 0 ) - : x( x_ ) - , y( y_ ) - { - } - - Offset2D( VkOffset2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset2D ) ); - } - - Offset2D& operator=( VkOffset2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset2D ) ); - return *this; - } - Offset2D& setX( int32_t x_ ) - { - x = x_; - return *this; - } - - Offset2D& setY( int32_t y_ ) - { - y = y_; - return *this; - } - - operator const VkOffset2D&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Offset2D const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ); - } - - bool operator!=( Offset2D const& rhs ) const - { - return !operator==( rhs ); - } - - int32_t x; - int32_t y; - }; - static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" ); - - struct Offset3D - { - Offset3D( int32_t x_ = 0, - int32_t y_ = 0, - int32_t z_ = 0 ) - : x( x_ ) - , y( y_ ) - , z( z_ ) - { - } - - explicit Offset3D( Offset2D const& offset2D, - int32_t z_ = 0 ) - : x( offset2D.x ) - , y( offset2D.y ) - , z( z_ ) - {} - - Offset3D( VkOffset3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset3D ) ); - } - - Offset3D& operator=( VkOffset3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset3D ) ); - return *this; - } - Offset3D& setX( int32_t x_ ) - { - x = x_; - return *this; - } - - Offset3D& setY( int32_t y_ ) - { - y = y_; - return *this; - } - - Offset3D& setZ( int32_t z_ ) - { - z = z_; - return *this; - } - - operator const VkOffset3D&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Offset3D const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( z == rhs.z ); - } - - bool operator!=( Offset3D const& rhs ) const - { - return !operator==( rhs ); - } - - int32_t x; - int32_t y; - int32_t z; - }; - static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" ); - - struct Extent2D - { - Extent2D( uint32_t width_ = 0, - uint32_t height_ = 0 ) - : width( width_ ) - , height( height_ ) - { - } - - Extent2D( VkExtent2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent2D ) ); - } - - Extent2D& operator=( VkExtent2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent2D ) ); - return *this; - } - Extent2D& setWidth( uint32_t width_ ) - { - width = width_; - return *this; - } - - Extent2D& setHeight( uint32_t height_ ) - { - height = height_; - return *this; - } - - operator const VkExtent2D&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Extent2D const& rhs ) const - { - return ( width == rhs.width ) - && ( height == rhs.height ); - } - - bool operator!=( Extent2D const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t width; - uint32_t height; - }; - static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" ); - - struct Extent3D - { - Extent3D( uint32_t width_ = 0, - uint32_t height_ = 0, - uint32_t depth_ = 0 ) - : width( width_ ) - , height( height_ ) - , depth( depth_ ) - { - } - - explicit Extent3D( Extent2D const& extent2D, - uint32_t depth_ = 0 ) - : width( extent2D.width ) - , height( extent2D.height ) - , depth( depth_ ) - {} - - Extent3D( VkExtent3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent3D ) ); - } - - Extent3D& operator=( VkExtent3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent3D ) ); - return *this; - } - Extent3D& setWidth( uint32_t width_ ) - { - width = width_; - return *this; - } - - Extent3D& setHeight( uint32_t height_ ) - { - height = height_; - return *this; - } - - Extent3D& setDepth( uint32_t depth_ ) - { - depth = depth_; - return *this; - } - - operator const VkExtent3D&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Extent3D const& rhs ) const - { - return ( width == rhs.width ) - && ( height == rhs.height ) - && ( depth == rhs.depth ); - } - - bool operator!=( Extent3D const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t width; - uint32_t height; - uint32_t depth; - }; - static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" ); - - struct Viewport - { - Viewport( float x_ = 0, - float y_ = 0, - float width_ = 0, - float height_ = 0, - float minDepth_ = 0, - float maxDepth_ = 0 ) - : x( x_ ) - , y( y_ ) - , width( width_ ) - , height( height_ ) - , minDepth( minDepth_ ) - , maxDepth( maxDepth_ ) - { - } - - Viewport( VkViewport const & rhs ) - { - memcpy( this, &rhs, sizeof( Viewport ) ); - } - - Viewport& operator=( VkViewport const & rhs ) - { - memcpy( this, &rhs, sizeof( Viewport ) ); - return *this; - } - Viewport& setX( float x_ ) - { - x = x_; - return *this; - } - - Viewport& setY( float y_ ) - { - y = y_; - return *this; - } - - Viewport& setWidth( float width_ ) - { - width = width_; - return *this; - } - - Viewport& setHeight( float height_ ) - { - height = height_; - return *this; - } - - Viewport& setMinDepth( float minDepth_ ) - { - minDepth = minDepth_; - return *this; - } - - Viewport& setMaxDepth( float maxDepth_ ) - { - maxDepth = maxDepth_; - return *this; - } - - operator const VkViewport&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Viewport const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( width == rhs.width ) - && ( height == rhs.height ) - && ( minDepth == rhs.minDepth ) - && ( maxDepth == rhs.maxDepth ); - } - - bool operator!=( Viewport const& rhs ) const - { - return !operator==( rhs ); - } - - float x; - float y; - float width; - float height; - float minDepth; - float maxDepth; - }; - static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); - - struct Rect2D - { - Rect2D( Offset2D offset_ = Offset2D(), - Extent2D extent_ = Extent2D() ) - : offset( offset_ ) - , extent( extent_ ) - { - } - - Rect2D( VkRect2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Rect2D ) ); - } - - Rect2D& operator=( VkRect2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Rect2D ) ); - return *this; - } - Rect2D& setOffset( Offset2D offset_ ) - { - offset = offset_; - return *this; - } - - Rect2D& setExtent( Extent2D extent_ ) - { - extent = extent_; - return *this; - } - - operator const VkRect2D&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Rect2D const& rhs ) const - { - return ( offset == rhs.offset ) - && ( extent == rhs.extent ); - } - - bool operator!=( Rect2D const& rhs ) const - { - return !operator==( rhs ); - } - - Offset2D offset; - Extent2D extent; - }; - static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); - - struct ClearRect - { - ClearRect( Rect2D rect_ = Rect2D(), - uint32_t baseArrayLayer_ = 0, - uint32_t layerCount_ = 0 ) - : rect( rect_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } - - ClearRect( VkClearRect const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearRect ) ); - } - - ClearRect& operator=( VkClearRect const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearRect ) ); - return *this; - } - ClearRect& setRect( Rect2D rect_ ) - { - rect = rect_; - return *this; - } - - ClearRect& setBaseArrayLayer( uint32_t baseArrayLayer_ ) - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - ClearRect& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } - - operator const VkClearRect&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ClearRect const& rhs ) const - { - return ( rect == rhs.rect ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } - - bool operator!=( ClearRect const& rhs ) const - { - return !operator==( rhs ); - } - - Rect2D rect; - uint32_t baseArrayLayer; - uint32_t layerCount; - }; - static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" ); - - struct ExtensionProperties - { - operator const VkExtensionProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExtensionProperties const& rhs ) const - { - return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 ) - && ( specVersion == rhs.specVersion ); - } - - bool operator!=( ExtensionProperties const& rhs ) const - { - return !operator==( rhs ); - } - - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - }; - static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" ); - - struct LayerProperties - { - operator const VkLayerProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( LayerProperties const& rhs ) const - { - return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 ) - && ( specVersion == rhs.specVersion ) - && ( implementationVersion == rhs.implementationVersion ) - && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ); - } - - bool operator!=( LayerProperties const& rhs ) const - { - return !operator==( rhs ); - } - - char layerName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - uint32_t implementationVersion; - char description[VK_MAX_DESCRIPTION_SIZE]; - }; - static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" ); - - struct AllocationCallbacks - { - AllocationCallbacks( void* pUserData_ = nullptr, - PFN_vkAllocationFunction pfnAllocation_ = nullptr, - PFN_vkReallocationFunction pfnReallocation_ = nullptr, - PFN_vkFreeFunction pfnFree_ = nullptr, - PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr, - PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr ) - : pUserData( pUserData_ ) - , pfnAllocation( pfnAllocation_ ) - , pfnReallocation( pfnReallocation_ ) - , pfnFree( pfnFree_ ) - , pfnInternalAllocation( pfnInternalAllocation_ ) - , pfnInternalFree( pfnInternalFree_ ) - { - } - - AllocationCallbacks( VkAllocationCallbacks const & rhs ) - { - memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); - } - - AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) - { - memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); - return *this; - } - AllocationCallbacks& setPUserData( void* pUserData_ ) - { - pUserData = pUserData_; - return *this; - } - - AllocationCallbacks& setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) - { - pfnAllocation = pfnAllocation_; - return *this; - } - - AllocationCallbacks& setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) - { - pfnReallocation = pfnReallocation_; - return *this; - } - - AllocationCallbacks& setPfnFree( PFN_vkFreeFunction pfnFree_ ) - { - pfnFree = pfnFree_; - return *this; - } - - AllocationCallbacks& setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) - { - pfnInternalAllocation = pfnInternalAllocation_; - return *this; - } - - AllocationCallbacks& setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) - { - pfnInternalFree = pfnInternalFree_; - return *this; - } - - operator const VkAllocationCallbacks&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AllocationCallbacks const& rhs ) const - { - return ( pUserData == rhs.pUserData ) - && ( pfnAllocation == rhs.pfnAllocation ) - && ( pfnReallocation == rhs.pfnReallocation ) - && ( pfnFree == rhs.pfnFree ) - && ( pfnInternalAllocation == rhs.pfnInternalAllocation ) - && ( pfnInternalFree == rhs.pfnInternalFree ); - } - - bool operator!=( AllocationCallbacks const& rhs ) const - { - return !operator==( rhs ); - } - - void* pUserData; - PFN_vkAllocationFunction pfnAllocation; - PFN_vkReallocationFunction pfnReallocation; - PFN_vkFreeFunction pfnFree; - PFN_vkInternalAllocationNotification pfnInternalAllocation; - PFN_vkInternalFreeNotification pfnInternalFree; - }; - static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" ); - - struct MemoryRequirements - { - operator const VkMemoryRequirements&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryRequirements const& rhs ) const - { - return ( size == rhs.size ) - && ( alignment == rhs.alignment ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryRequirements const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize size; - DeviceSize alignment; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); - - struct DescriptorBufferInfo - { - DescriptorBufferInfo( Buffer buffer_ = Buffer(), - DeviceSize offset_ = 0, - DeviceSize range_ = 0 ) - : buffer( buffer_ ) - , offset( offset_ ) - , range( range_ ) - { - } - - DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); - } - - DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); - return *this; - } - DescriptorBufferInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - DescriptorBufferInfo& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - DescriptorBufferInfo& setRange( DeviceSize range_ ) - { - range = range_; - return *this; - } - - operator const VkDescriptorBufferInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorBufferInfo const& rhs ) const - { - return ( buffer == rhs.buffer ) - && ( offset == rhs.offset ) - && ( range == rhs.range ); - } - - bool operator!=( DescriptorBufferInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Buffer buffer; - DeviceSize offset; - DeviceSize range; - }; - static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" ); - - struct SubresourceLayout - { - operator const VkSubresourceLayout&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SubresourceLayout const& rhs ) const - { - return ( offset == rhs.offset ) - && ( size == rhs.size ) - && ( rowPitch == rhs.rowPitch ) - && ( arrayPitch == rhs.arrayPitch ) - && ( depthPitch == rhs.depthPitch ); - } - - bool operator!=( SubresourceLayout const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize offset; - DeviceSize size; - DeviceSize rowPitch; - DeviceSize arrayPitch; - DeviceSize depthPitch; - }; - static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); - - struct BufferCopy - { - BufferCopy( DeviceSize srcOffset_ = 0, - DeviceSize dstOffset_ = 0, - DeviceSize size_ = 0 ) - : srcOffset( srcOffset_ ) - , dstOffset( dstOffset_ ) - , size( size_ ) - { - } - - BufferCopy( VkBufferCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCopy ) ); - } - - BufferCopy& operator=( VkBufferCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCopy ) ); - return *this; - } - BufferCopy& setSrcOffset( DeviceSize srcOffset_ ) - { - srcOffset = srcOffset_; - return *this; - } - - BufferCopy& setDstOffset( DeviceSize dstOffset_ ) - { - dstOffset = dstOffset_; - return *this; - } - - BufferCopy& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - operator const VkBufferCopy&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BufferCopy const& rhs ) const - { - return ( srcOffset == rhs.srcOffset ) - && ( dstOffset == rhs.dstOffset ) - && ( size == rhs.size ); - } - - bool operator!=( BufferCopy const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize srcOffset; - DeviceSize dstOffset; - DeviceSize size; - }; - static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); - - struct SpecializationMapEntry - { - SpecializationMapEntry( uint32_t constantID_ = 0, - uint32_t offset_ = 0, - size_t size_ = 0 ) - : constantID( constantID_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); - } - - SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); - return *this; - } - SpecializationMapEntry& setConstantID( uint32_t constantID_ ) - { - constantID = constantID_; - return *this; - } - - SpecializationMapEntry& setOffset( uint32_t offset_ ) - { - offset = offset_; - return *this; - } - - SpecializationMapEntry& setSize( size_t size_ ) - { - size = size_; - return *this; - } - - operator const VkSpecializationMapEntry&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SpecializationMapEntry const& rhs ) const - { - return ( constantID == rhs.constantID ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( SpecializationMapEntry const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t constantID; - uint32_t offset; - size_t size; - }; - static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" ); - - struct SpecializationInfo - { - SpecializationInfo( uint32_t mapEntryCount_ = 0, - const SpecializationMapEntry* pMapEntries_ = nullptr, - size_t dataSize_ = 0, - const void* pData_ = nullptr ) - : mapEntryCount( mapEntryCount_ ) - , pMapEntries( pMapEntries_ ) - , dataSize( dataSize_ ) - , pData( pData_ ) - { - } - - SpecializationInfo( VkSpecializationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationInfo ) ); - } - - SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationInfo ) ); - return *this; - } - SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ ) - { - mapEntryCount = mapEntryCount_; - return *this; - } - - SpecializationInfo& setPMapEntries( const SpecializationMapEntry* pMapEntries_ ) - { - pMapEntries = pMapEntries_; - return *this; - } - - SpecializationInfo& setDataSize( size_t dataSize_ ) - { - dataSize = dataSize_; - return *this; - } - - SpecializationInfo& setPData( const void* pData_ ) - { - pData = pData_; - return *this; - } - - operator const VkSpecializationInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SpecializationInfo const& rhs ) const - { - return ( mapEntryCount == rhs.mapEntryCount ) - && ( pMapEntries == rhs.pMapEntries ) - && ( dataSize == rhs.dataSize ) - && ( pData == rhs.pData ); - } - - bool operator!=( SpecializationInfo const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t mapEntryCount; - const SpecializationMapEntry* pMapEntries; - size_t dataSize; - const void* pData; - }; - static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); - - union ClearColorValue - { - ClearColorValue( const std::array& float32_ = { {0} } ) - { - memcpy( &float32, float32_.data(), 4 * sizeof( float ) ); - } - - ClearColorValue( const std::array& int32_ ) - { - memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) ); - } - - ClearColorValue( const std::array& uint32_ ) - { - memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) ); - } - - ClearColorValue& setFloat32( std::array float32_ ) - { - memcpy( &float32, float32_.data(), 4 * sizeof( float ) ); - return *this; - } - - ClearColorValue& setInt32( std::array int32_ ) - { - memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) ); - return *this; - } - - ClearColorValue& setUint32( std::array uint32_ ) - { - memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) ); - return *this; - } - - operator VkClearColorValue const& () const - { - return *reinterpret_cast(this); - } - - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; - }; - - struct ClearDepthStencilValue - { - ClearDepthStencilValue( float depth_ = 0, - uint32_t stencil_ = 0 ) - : depth( depth_ ) - , stencil( stencil_ ) - { - } - - ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); - } - - ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); - return *this; - } - ClearDepthStencilValue& setDepth( float depth_ ) - { - depth = depth_; - return *this; - } - - ClearDepthStencilValue& setStencil( uint32_t stencil_ ) - { - stencil = stencil_; - return *this; - } - - operator const VkClearDepthStencilValue&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ClearDepthStencilValue const& rhs ) const - { - return ( depth == rhs.depth ) - && ( stencil == rhs.stencil ); - } - - bool operator!=( ClearDepthStencilValue const& rhs ) const - { - return !operator==( rhs ); - } - - float depth; - uint32_t stencil; - }; - static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" ); - - union ClearValue - { - ClearValue( ClearColorValue color_ = ClearColorValue() ) - { - color = color_; - } - - ClearValue( ClearDepthStencilValue depthStencil_ ) - { - depthStencil = depthStencil_; - } - - ClearValue& setColor( ClearColorValue color_ ) - { - color = color_; - return *this; - } - - ClearValue& setDepthStencil( ClearDepthStencilValue depthStencil_ ) - { - depthStencil = depthStencil_; - return *this; - } - - operator VkClearValue const& () const - { - return *reinterpret_cast(this); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - ClearColorValue color; - ClearDepthStencilValue depthStencil; -#else - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -#endif // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - }; - - struct PhysicalDeviceFeatures - { - PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0, - Bool32 fullDrawIndexUint32_ = 0, - Bool32 imageCubeArray_ = 0, - Bool32 independentBlend_ = 0, - Bool32 geometryShader_ = 0, - Bool32 tessellationShader_ = 0, - Bool32 sampleRateShading_ = 0, - Bool32 dualSrcBlend_ = 0, - Bool32 logicOp_ = 0, - Bool32 multiDrawIndirect_ = 0, - Bool32 drawIndirectFirstInstance_ = 0, - Bool32 depthClamp_ = 0, - Bool32 depthBiasClamp_ = 0, - Bool32 fillModeNonSolid_ = 0, - Bool32 depthBounds_ = 0, - Bool32 wideLines_ = 0, - Bool32 largePoints_ = 0, - Bool32 alphaToOne_ = 0, - Bool32 multiViewport_ = 0, - Bool32 samplerAnisotropy_ = 0, - Bool32 textureCompressionETC2_ = 0, - Bool32 textureCompressionASTC_LDR_ = 0, - Bool32 textureCompressionBC_ = 0, - Bool32 occlusionQueryPrecise_ = 0, - Bool32 pipelineStatisticsQuery_ = 0, - Bool32 vertexPipelineStoresAndAtomics_ = 0, - Bool32 fragmentStoresAndAtomics_ = 0, - Bool32 shaderTessellationAndGeometryPointSize_ = 0, - Bool32 shaderImageGatherExtended_ = 0, - Bool32 shaderStorageImageExtendedFormats_ = 0, - Bool32 shaderStorageImageMultisample_ = 0, - Bool32 shaderStorageImageReadWithoutFormat_ = 0, - Bool32 shaderStorageImageWriteWithoutFormat_ = 0, - Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0, - Bool32 shaderSampledImageArrayDynamicIndexing_ = 0, - Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0, - Bool32 shaderStorageImageArrayDynamicIndexing_ = 0, - Bool32 shaderClipDistance_ = 0, - Bool32 shaderCullDistance_ = 0, - Bool32 shaderFloat64_ = 0, - Bool32 shaderInt64_ = 0, - Bool32 shaderInt16_ = 0, - Bool32 shaderResourceResidency_ = 0, - Bool32 shaderResourceMinLod_ = 0, - Bool32 sparseBinding_ = 0, - Bool32 sparseResidencyBuffer_ = 0, - Bool32 sparseResidencyImage2D_ = 0, - Bool32 sparseResidencyImage3D_ = 0, - Bool32 sparseResidency2Samples_ = 0, - Bool32 sparseResidency4Samples_ = 0, - Bool32 sparseResidency8Samples_ = 0, - Bool32 sparseResidency16Samples_ = 0, - Bool32 sparseResidencyAliased_ = 0, - Bool32 variableMultisampleRate_ = 0, - Bool32 inheritedQueries_ = 0 ) - : robustBufferAccess( robustBufferAccess_ ) - , fullDrawIndexUint32( fullDrawIndexUint32_ ) - , imageCubeArray( imageCubeArray_ ) - , independentBlend( independentBlend_ ) - , geometryShader( geometryShader_ ) - , tessellationShader( tessellationShader_ ) - , sampleRateShading( sampleRateShading_ ) - , dualSrcBlend( dualSrcBlend_ ) - , logicOp( logicOp_ ) - , multiDrawIndirect( multiDrawIndirect_ ) - , drawIndirectFirstInstance( drawIndirectFirstInstance_ ) - , depthClamp( depthClamp_ ) - , depthBiasClamp( depthBiasClamp_ ) - , fillModeNonSolid( fillModeNonSolid_ ) - , depthBounds( depthBounds_ ) - , wideLines( wideLines_ ) - , largePoints( largePoints_ ) - , alphaToOne( alphaToOne_ ) - , multiViewport( multiViewport_ ) - , samplerAnisotropy( samplerAnisotropy_ ) - , textureCompressionETC2( textureCompressionETC2_ ) - , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ ) - , textureCompressionBC( textureCompressionBC_ ) - , occlusionQueryPrecise( occlusionQueryPrecise_ ) - , pipelineStatisticsQuery( pipelineStatisticsQuery_ ) - , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ ) - , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ ) - , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ ) - , shaderImageGatherExtended( shaderImageGatherExtended_ ) - , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ ) - , shaderStorageImageMultisample( shaderStorageImageMultisample_ ) - , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ ) - , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ ) - , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ ) - , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ ) - , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ ) - , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ ) - , shaderClipDistance( shaderClipDistance_ ) - , shaderCullDistance( shaderCullDistance_ ) - , shaderFloat64( shaderFloat64_ ) - , shaderInt64( shaderInt64_ ) - , shaderInt16( shaderInt16_ ) - , shaderResourceResidency( shaderResourceResidency_ ) - , shaderResourceMinLod( shaderResourceMinLod_ ) - , sparseBinding( sparseBinding_ ) - , sparseResidencyBuffer( sparseResidencyBuffer_ ) - , sparseResidencyImage2D( sparseResidencyImage2D_ ) - , sparseResidencyImage3D( sparseResidencyImage3D_ ) - , sparseResidency2Samples( sparseResidency2Samples_ ) - , sparseResidency4Samples( sparseResidency4Samples_ ) - , sparseResidency8Samples( sparseResidency8Samples_ ) - , sparseResidency16Samples( sparseResidency16Samples_ ) - , sparseResidencyAliased( sparseResidencyAliased_ ) - , variableMultisampleRate( variableMultisampleRate_ ) - , inheritedQueries( inheritedQueries_ ) - { - } - - PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); - } - - PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); - return *this; - } - PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ ) - { - robustBufferAccess = robustBufferAccess_; - return *this; - } - - PhysicalDeviceFeatures& setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) - { - fullDrawIndexUint32 = fullDrawIndexUint32_; - return *this; - } - - PhysicalDeviceFeatures& setImageCubeArray( Bool32 imageCubeArray_ ) - { - imageCubeArray = imageCubeArray_; - return *this; - } - - PhysicalDeviceFeatures& setIndependentBlend( Bool32 independentBlend_ ) - { - independentBlend = independentBlend_; - return *this; - } - - PhysicalDeviceFeatures& setGeometryShader( Bool32 geometryShader_ ) - { - geometryShader = geometryShader_; - return *this; - } - - PhysicalDeviceFeatures& setTessellationShader( Bool32 tessellationShader_ ) - { - tessellationShader = tessellationShader_; - return *this; - } - - PhysicalDeviceFeatures& setSampleRateShading( Bool32 sampleRateShading_ ) - { - sampleRateShading = sampleRateShading_; - return *this; - } - - PhysicalDeviceFeatures& setDualSrcBlend( Bool32 dualSrcBlend_ ) - { - dualSrcBlend = dualSrcBlend_; - return *this; - } - - PhysicalDeviceFeatures& setLogicOp( Bool32 logicOp_ ) - { - logicOp = logicOp_; - return *this; - } - - PhysicalDeviceFeatures& setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) - { - multiDrawIndirect = multiDrawIndirect_; - return *this; - } - - PhysicalDeviceFeatures& setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) - { - drawIndirectFirstInstance = drawIndirectFirstInstance_; - return *this; - } - - PhysicalDeviceFeatures& setDepthClamp( Bool32 depthClamp_ ) - { - depthClamp = depthClamp_; - return *this; - } - - PhysicalDeviceFeatures& setDepthBiasClamp( Bool32 depthBiasClamp_ ) - { - depthBiasClamp = depthBiasClamp_; - return *this; - } - - PhysicalDeviceFeatures& setFillModeNonSolid( Bool32 fillModeNonSolid_ ) - { - fillModeNonSolid = fillModeNonSolid_; - return *this; - } - - PhysicalDeviceFeatures& setDepthBounds( Bool32 depthBounds_ ) - { - depthBounds = depthBounds_; - return *this; - } - - PhysicalDeviceFeatures& setWideLines( Bool32 wideLines_ ) - { - wideLines = wideLines_; - return *this; - } - - PhysicalDeviceFeatures& setLargePoints( Bool32 largePoints_ ) - { - largePoints = largePoints_; - return *this; - } - - PhysicalDeviceFeatures& setAlphaToOne( Bool32 alphaToOne_ ) - { - alphaToOne = alphaToOne_; - return *this; - } - - PhysicalDeviceFeatures& setMultiViewport( Bool32 multiViewport_ ) - { - multiViewport = multiViewport_; - return *this; - } - - PhysicalDeviceFeatures& setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) - { - samplerAnisotropy = samplerAnisotropy_; - return *this; - } - - PhysicalDeviceFeatures& setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) - { - textureCompressionETC2 = textureCompressionETC2_; - return *this; - } - - PhysicalDeviceFeatures& setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) - { - textureCompressionASTC_LDR = textureCompressionASTC_LDR_; - return *this; - } - - PhysicalDeviceFeatures& setTextureCompressionBC( Bool32 textureCompressionBC_ ) - { - textureCompressionBC = textureCompressionBC_; - return *this; - } - - PhysicalDeviceFeatures& setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) - { - occlusionQueryPrecise = occlusionQueryPrecise_; - return *this; - } - - PhysicalDeviceFeatures& setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) - { - pipelineStatisticsQuery = pipelineStatisticsQuery_; - return *this; - } - - PhysicalDeviceFeatures& setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) - { - vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_; - return *this; - } - - PhysicalDeviceFeatures& setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) - { - fragmentStoresAndAtomics = fragmentStoresAndAtomics_; - return *this; - } - - PhysicalDeviceFeatures& setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) - { - shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_; - return *this; - } - - PhysicalDeviceFeatures& setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) - { - shaderImageGatherExtended = shaderImageGatherExtended_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) - { - shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ ) - { - shaderStorageImageMultisample = shaderStorageImageMultisample_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ ) - { - shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ ) - { - shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_; - return *this; - } - - PhysicalDeviceFeatures& setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ ) - { - shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ ) - { - shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ ) - { - shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ ) - { - shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderClipDistance( Bool32 shaderClipDistance_ ) - { - shaderClipDistance = shaderClipDistance_; - return *this; - } - - PhysicalDeviceFeatures& setShaderCullDistance( Bool32 shaderCullDistance_ ) - { - shaderCullDistance = shaderCullDistance_; - return *this; - } - - PhysicalDeviceFeatures& setShaderFloat64( Bool32 shaderFloat64_ ) - { - shaderFloat64 = shaderFloat64_; - return *this; - } - - PhysicalDeviceFeatures& setShaderInt64( Bool32 shaderInt64_ ) - { - shaderInt64 = shaderInt64_; - return *this; - } - - PhysicalDeviceFeatures& setShaderInt16( Bool32 shaderInt16_ ) - { - shaderInt16 = shaderInt16_; - return *this; - } - - PhysicalDeviceFeatures& setShaderResourceResidency( Bool32 shaderResourceResidency_ ) - { - shaderResourceResidency = shaderResourceResidency_; - return *this; - } - - PhysicalDeviceFeatures& setShaderResourceMinLod( Bool32 shaderResourceMinLod_ ) - { - shaderResourceMinLod = shaderResourceMinLod_; - return *this; - } - - PhysicalDeviceFeatures& setSparseBinding( Bool32 sparseBinding_ ) - { - sparseBinding = sparseBinding_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ ) - { - sparseResidencyBuffer = sparseResidencyBuffer_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ ) - { - sparseResidencyImage2D = sparseResidencyImage2D_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ ) - { - sparseResidencyImage3D = sparseResidencyImage3D_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency2Samples( Bool32 sparseResidency2Samples_ ) - { - sparseResidency2Samples = sparseResidency2Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency4Samples( Bool32 sparseResidency4Samples_ ) - { - sparseResidency4Samples = sparseResidency4Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency8Samples( Bool32 sparseResidency8Samples_ ) - { - sparseResidency8Samples = sparseResidency8Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency16Samples( Bool32 sparseResidency16Samples_ ) - { - sparseResidency16Samples = sparseResidency16Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyAliased( Bool32 sparseResidencyAliased_ ) - { - sparseResidencyAliased = sparseResidencyAliased_; - return *this; - } - - PhysicalDeviceFeatures& setVariableMultisampleRate( Bool32 variableMultisampleRate_ ) - { - variableMultisampleRate = variableMultisampleRate_; - return *this; - } - - PhysicalDeviceFeatures& setInheritedQueries( Bool32 inheritedQueries_ ) - { - inheritedQueries = inheritedQueries_; - return *this; - } - - operator const VkPhysicalDeviceFeatures&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceFeatures const& rhs ) const - { - return ( robustBufferAccess == rhs.robustBufferAccess ) - && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) - && ( imageCubeArray == rhs.imageCubeArray ) - && ( independentBlend == rhs.independentBlend ) - && ( geometryShader == rhs.geometryShader ) - && ( tessellationShader == rhs.tessellationShader ) - && ( sampleRateShading == rhs.sampleRateShading ) - && ( dualSrcBlend == rhs.dualSrcBlend ) - && ( logicOp == rhs.logicOp ) - && ( multiDrawIndirect == rhs.multiDrawIndirect ) - && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) - && ( depthClamp == rhs.depthClamp ) - && ( depthBiasClamp == rhs.depthBiasClamp ) - && ( fillModeNonSolid == rhs.fillModeNonSolid ) - && ( depthBounds == rhs.depthBounds ) - && ( wideLines == rhs.wideLines ) - && ( largePoints == rhs.largePoints ) - && ( alphaToOne == rhs.alphaToOne ) - && ( multiViewport == rhs.multiViewport ) - && ( samplerAnisotropy == rhs.samplerAnisotropy ) - && ( textureCompressionETC2 == rhs.textureCompressionETC2 ) - && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) - && ( textureCompressionBC == rhs.textureCompressionBC ) - && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) - && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) - && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) - && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) - && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) - && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) - && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) - && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) - && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) - && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) - && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) - && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) - && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) - && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) - && ( shaderClipDistance == rhs.shaderClipDistance ) - && ( shaderCullDistance == rhs.shaderCullDistance ) - && ( shaderFloat64 == rhs.shaderFloat64 ) - && ( shaderInt64 == rhs.shaderInt64 ) - && ( shaderInt16 == rhs.shaderInt16 ) - && ( shaderResourceResidency == rhs.shaderResourceResidency ) - && ( shaderResourceMinLod == rhs.shaderResourceMinLod ) - && ( sparseBinding == rhs.sparseBinding ) - && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) - && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) - && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) - && ( sparseResidency2Samples == rhs.sparseResidency2Samples ) - && ( sparseResidency4Samples == rhs.sparseResidency4Samples ) - && ( sparseResidency8Samples == rhs.sparseResidency8Samples ) - && ( sparseResidency16Samples == rhs.sparseResidency16Samples ) - && ( sparseResidencyAliased == rhs.sparseResidencyAliased ) - && ( variableMultisampleRate == rhs.variableMultisampleRate ) - && ( inheritedQueries == rhs.inheritedQueries ); - } - - bool operator!=( PhysicalDeviceFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - Bool32 robustBufferAccess; - Bool32 fullDrawIndexUint32; - Bool32 imageCubeArray; - Bool32 independentBlend; - Bool32 geometryShader; - Bool32 tessellationShader; - Bool32 sampleRateShading; - Bool32 dualSrcBlend; - Bool32 logicOp; - Bool32 multiDrawIndirect; - Bool32 drawIndirectFirstInstance; - Bool32 depthClamp; - Bool32 depthBiasClamp; - Bool32 fillModeNonSolid; - Bool32 depthBounds; - Bool32 wideLines; - Bool32 largePoints; - Bool32 alphaToOne; - Bool32 multiViewport; - Bool32 samplerAnisotropy; - Bool32 textureCompressionETC2; - Bool32 textureCompressionASTC_LDR; - Bool32 textureCompressionBC; - Bool32 occlusionQueryPrecise; - Bool32 pipelineStatisticsQuery; - Bool32 vertexPipelineStoresAndAtomics; - Bool32 fragmentStoresAndAtomics; - Bool32 shaderTessellationAndGeometryPointSize; - Bool32 shaderImageGatherExtended; - Bool32 shaderStorageImageExtendedFormats; - Bool32 shaderStorageImageMultisample; - Bool32 shaderStorageImageReadWithoutFormat; - Bool32 shaderStorageImageWriteWithoutFormat; - Bool32 shaderUniformBufferArrayDynamicIndexing; - Bool32 shaderSampledImageArrayDynamicIndexing; - Bool32 shaderStorageBufferArrayDynamicIndexing; - Bool32 shaderStorageImageArrayDynamicIndexing; - Bool32 shaderClipDistance; - Bool32 shaderCullDistance; - Bool32 shaderFloat64; - Bool32 shaderInt64; - Bool32 shaderInt16; - Bool32 shaderResourceResidency; - Bool32 shaderResourceMinLod; - Bool32 sparseBinding; - Bool32 sparseResidencyBuffer; - Bool32 sparseResidencyImage2D; - Bool32 sparseResidencyImage3D; - Bool32 sparseResidency2Samples; - Bool32 sparseResidency4Samples; - Bool32 sparseResidency8Samples; - Bool32 sparseResidency16Samples; - Bool32 sparseResidencyAliased; - Bool32 variableMultisampleRate; - Bool32 inheritedQueries; - }; - static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSparseProperties - { - operator const VkPhysicalDeviceSparseProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceSparseProperties const& rhs ) const - { - return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) - && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) - && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) - && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) - && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); - } - - bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const - { - return !operator==( rhs ); - } - - Bool32 residencyStandard2DBlockShape; - Bool32 residencyStandard2DMultisampleBlockShape; - Bool32 residencyStandard3DBlockShape; - Bool32 residencyAlignedMipSize; - Bool32 residencyNonResidentStrict; - }; - static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" ); - - struct DrawIndirectCommand - { - DrawIndirectCommand( uint32_t vertexCount_ = 0, - uint32_t instanceCount_ = 0, - uint32_t firstVertex_ = 0, - uint32_t firstInstance_ = 0 ) - : vertexCount( vertexCount_ ) - , instanceCount( instanceCount_ ) - , firstVertex( firstVertex_ ) - , firstInstance( firstInstance_ ) - { - } - - DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); - } - - DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); - return *this; - } - DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ ) - { - vertexCount = vertexCount_; - return *this; - } - - DrawIndirectCommand& setInstanceCount( uint32_t instanceCount_ ) - { - instanceCount = instanceCount_; - return *this; - } - - DrawIndirectCommand& setFirstVertex( uint32_t firstVertex_ ) - { - firstVertex = firstVertex_; - return *this; - } - - DrawIndirectCommand& setFirstInstance( uint32_t firstInstance_ ) - { - firstInstance = firstInstance_; - return *this; - } - - operator const VkDrawIndirectCommand&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DrawIndirectCommand const& rhs ) const - { - return ( vertexCount == rhs.vertexCount ) - && ( instanceCount == rhs.instanceCount ) - && ( firstVertex == rhs.firstVertex ) - && ( firstInstance == rhs.firstInstance ); - } - - bool operator!=( DrawIndirectCommand const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; - }; - static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" ); - - struct DrawIndexedIndirectCommand - { - DrawIndexedIndirectCommand( uint32_t indexCount_ = 0, - uint32_t instanceCount_ = 0, - uint32_t firstIndex_ = 0, - int32_t vertexOffset_ = 0, - uint32_t firstInstance_ = 0 ) - : indexCount( indexCount_ ) - , instanceCount( instanceCount_ ) - , firstIndex( firstIndex_ ) - , vertexOffset( vertexOffset_ ) - , firstInstance( firstInstance_ ) - { - } - - DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); - } - - DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); - return *this; - } - DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ ) - { - indexCount = indexCount_; - return *this; - } - - DrawIndexedIndirectCommand& setInstanceCount( uint32_t instanceCount_ ) - { - instanceCount = instanceCount_; - return *this; - } - - DrawIndexedIndirectCommand& setFirstIndex( uint32_t firstIndex_ ) - { - firstIndex = firstIndex_; - return *this; - } - - DrawIndexedIndirectCommand& setVertexOffset( int32_t vertexOffset_ ) - { - vertexOffset = vertexOffset_; - return *this; - } - - DrawIndexedIndirectCommand& setFirstInstance( uint32_t firstInstance_ ) - { - firstInstance = firstInstance_; - return *this; - } - - operator const VkDrawIndexedIndirectCommand&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DrawIndexedIndirectCommand const& rhs ) const - { - return ( indexCount == rhs.indexCount ) - && ( instanceCount == rhs.instanceCount ) - && ( firstIndex == rhs.firstIndex ) - && ( vertexOffset == rhs.vertexOffset ) - && ( firstInstance == rhs.firstInstance ); - } - - bool operator!=( DrawIndexedIndirectCommand const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; - }; - static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" ); - - struct DispatchIndirectCommand - { - DispatchIndirectCommand( uint32_t x_ = 0, - uint32_t y_ = 0, - uint32_t z_ = 0 ) - : x( x_ ) - , y( y_ ) - , z( z_ ) - { - } - - DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); - } - - DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); - return *this; - } - DispatchIndirectCommand& setX( uint32_t x_ ) - { - x = x_; - return *this; - } - - DispatchIndirectCommand& setY( uint32_t y_ ) - { - y = y_; - return *this; - } - - DispatchIndirectCommand& setZ( uint32_t z_ ) - { - z = z_; - return *this; - } - - operator const VkDispatchIndirectCommand&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DispatchIndirectCommand const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( z == rhs.z ); - } - - bool operator!=( DispatchIndirectCommand const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t x; - uint32_t y; - uint32_t z; - }; - static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" ); - - struct DisplayPlanePropertiesKHR - { - operator const VkDisplayPlanePropertiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPlanePropertiesKHR const& rhs ) const - { - return ( currentDisplay == rhs.currentDisplay ) - && ( currentStackIndex == rhs.currentStackIndex ); - } - - bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayKHR currentDisplay; - uint32_t currentStackIndex; - }; - static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" ); - - struct DisplayModeParametersKHR - { - DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(), - uint32_t refreshRate_ = 0 ) - : visibleRegion( visibleRegion_ ) - , refreshRate( refreshRate_ ) - { - } - - DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); - } - - DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); - return *this; - } - DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ ) - { - visibleRegion = visibleRegion_; - return *this; - } - - DisplayModeParametersKHR& setRefreshRate( uint32_t refreshRate_ ) - { - refreshRate = refreshRate_; - return *this; - } - - operator const VkDisplayModeParametersKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayModeParametersKHR const& rhs ) const - { - return ( visibleRegion == rhs.visibleRegion ) - && ( refreshRate == rhs.refreshRate ); - } - - bool operator!=( DisplayModeParametersKHR const& rhs ) const - { - return !operator==( rhs ); - } - - Extent2D visibleRegion; - uint32_t refreshRate; - }; - static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" ); - - struct DisplayModePropertiesKHR - { - operator const VkDisplayModePropertiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayModePropertiesKHR const& rhs ) const - { - return ( displayMode == rhs.displayMode ) - && ( parameters == rhs.parameters ); - } - - bool operator!=( DisplayModePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayModeKHR displayMode; - DisplayModeParametersKHR parameters; - }; - static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" ); - - struct RectLayerKHR - { - RectLayerKHR( Offset2D offset_ = Offset2D(), - Extent2D extent_ = Extent2D(), - uint32_t layer_ = 0 ) - : offset( offset_ ) - , extent( extent_ ) - , layer( layer_ ) - { - } - - explicit RectLayerKHR( Rect2D const& rect2D, - uint32_t layer_ = 0 ) - : offset( rect2D.offset ) - , extent( rect2D.extent ) - , layer( layer_ ) - {} - - RectLayerKHR( VkRectLayerKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( RectLayerKHR ) ); - } - - RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( RectLayerKHR ) ); - return *this; - } - RectLayerKHR& setOffset( Offset2D offset_ ) - { - offset = offset_; - return *this; - } - - RectLayerKHR& setExtent( Extent2D extent_ ) - { - extent = extent_; - return *this; - } - - RectLayerKHR& setLayer( uint32_t layer_ ) - { - layer = layer_; - return *this; - } - - operator const VkRectLayerKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( RectLayerKHR const& rhs ) const - { - return ( offset == rhs.offset ) - && ( extent == rhs.extent ) - && ( layer == rhs.layer ); - } - - bool operator!=( RectLayerKHR const& rhs ) const - { - return !operator==( rhs ); - } - - Offset2D offset; - Extent2D extent; - uint32_t layer; - }; - static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" ); - - struct PresentRegionKHR - { - PresentRegionKHR( uint32_t rectangleCount_ = 0, - const RectLayerKHR* pRectangles_ = nullptr ) - : rectangleCount( rectangleCount_ ) - , pRectangles( pRectangles_ ) - { - } - - PresentRegionKHR( VkPresentRegionKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); - } - - PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); - return *this; - } - PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ ) - { - rectangleCount = rectangleCount_; - return *this; - } - - PresentRegionKHR& setPRectangles( const RectLayerKHR* pRectangles_ ) - { - pRectangles = pRectangles_; - return *this; - } - - operator const VkPresentRegionKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PresentRegionKHR const& rhs ) const - { - return ( rectangleCount == rhs.rectangleCount ) - && ( pRectangles == rhs.pRectangles ); - } - - bool operator!=( PresentRegionKHR const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t rectangleCount; - const RectLayerKHR* pRectangles; - }; - static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); - - struct XYColorEXT - { - XYColorEXT( float x_ = 0, - float y_ = 0 ) - : x( x_ ) - , y( y_ ) - { - } - - XYColorEXT( VkXYColorEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( XYColorEXT ) ); - } - - XYColorEXT& operator=( VkXYColorEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( XYColorEXT ) ); - return *this; - } - XYColorEXT& setX( float x_ ) - { - x = x_; - return *this; - } - - XYColorEXT& setY( float y_ ) - { - y = y_; - return *this; - } - - operator const VkXYColorEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( XYColorEXT const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ); - } - - bool operator!=( XYColorEXT const& rhs ) const - { - return !operator==( rhs ); - } - - float x; - float y; - }; - static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); - - struct RefreshCycleDurationGOOGLE - { - RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = 0 ) - : refreshDuration( refreshDuration_ ) - { - } - - RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); - } - - RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); - return *this; - } - RefreshCycleDurationGOOGLE& setRefreshDuration( uint64_t refreshDuration_ ) - { - refreshDuration = refreshDuration_; - return *this; - } - - operator const VkRefreshCycleDurationGOOGLE&() const - { - return *reinterpret_cast(this); - } - - bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const - { - return ( refreshDuration == rhs.refreshDuration ); - } - - bool operator!=( RefreshCycleDurationGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - uint64_t refreshDuration; - }; - static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" ); - - struct PastPresentationTimingGOOGLE - { - PastPresentationTimingGOOGLE( uint32_t presentID_ = 0, - uint64_t desiredPresentTime_ = 0, - uint64_t actualPresentTime_ = 0, - uint64_t earliestPresentTime_ = 0, - uint64_t presentMargin_ = 0 ) - : presentID( presentID_ ) - , desiredPresentTime( desiredPresentTime_ ) - , actualPresentTime( actualPresentTime_ ) - , earliestPresentTime( earliestPresentTime_ ) - , presentMargin( presentMargin_ ) - { - } - - PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); - } - - PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); - return *this; - } - PastPresentationTimingGOOGLE& setPresentID( uint32_t presentID_ ) - { - presentID = presentID_; - return *this; - } - - PastPresentationTimingGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ ) - { - desiredPresentTime = desiredPresentTime_; - return *this; - } - - PastPresentationTimingGOOGLE& setActualPresentTime( uint64_t actualPresentTime_ ) - { - actualPresentTime = actualPresentTime_; - return *this; - } - - PastPresentationTimingGOOGLE& setEarliestPresentTime( uint64_t earliestPresentTime_ ) - { - earliestPresentTime = earliestPresentTime_; - return *this; - } - - PastPresentationTimingGOOGLE& setPresentMargin( uint64_t presentMargin_ ) - { - presentMargin = presentMargin_; - return *this; - } - - operator const VkPastPresentationTimingGOOGLE&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PastPresentationTimingGOOGLE const& rhs ) const - { - return ( presentID == rhs.presentID ) - && ( desiredPresentTime == rhs.desiredPresentTime ) - && ( actualPresentTime == rhs.actualPresentTime ) - && ( earliestPresentTime == rhs.earliestPresentTime ) - && ( presentMargin == rhs.presentMargin ); - } - - bool operator!=( PastPresentationTimingGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t presentID; - uint64_t desiredPresentTime; - uint64_t actualPresentTime; - uint64_t earliestPresentTime; - uint64_t presentMargin; - }; - static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" ); - - struct PresentTimeGOOGLE - { - PresentTimeGOOGLE( uint32_t presentID_ = 0, - uint64_t desiredPresentTime_ = 0 ) - : presentID( presentID_ ) - , desiredPresentTime( desiredPresentTime_ ) - { - } - - PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); - } - - PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); - return *this; - } - PresentTimeGOOGLE& setPresentID( uint32_t presentID_ ) - { - presentID = presentID_; - return *this; - } - - PresentTimeGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ ) - { - desiredPresentTime = desiredPresentTime_; - return *this; - } - - operator const VkPresentTimeGOOGLE&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PresentTimeGOOGLE const& rhs ) const - { - return ( presentID == rhs.presentID ) - && ( desiredPresentTime == rhs.desiredPresentTime ); - } - - bool operator!=( PresentTimeGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t presentID; - uint64_t desiredPresentTime; - }; - static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); - - struct ViewportWScalingNV - { - ViewportWScalingNV( float xcoeff_ = 0, - float ycoeff_ = 0 ) - : xcoeff( xcoeff_ ) - , ycoeff( ycoeff_ ) - { - } - - ViewportWScalingNV( VkViewportWScalingNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); - } - - ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); - return *this; - } - ViewportWScalingNV& setXcoeff( float xcoeff_ ) - { - xcoeff = xcoeff_; - return *this; - } - - ViewportWScalingNV& setYcoeff( float ycoeff_ ) - { - ycoeff = ycoeff_; - return *this; - } - - operator const VkViewportWScalingNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ViewportWScalingNV const& rhs ) const - { - return ( xcoeff == rhs.xcoeff ) - && ( ycoeff == rhs.ycoeff ); - } - - bool operator!=( ViewportWScalingNV const& rhs ) const - { - return !operator==( rhs ); - } - - float xcoeff; - float ycoeff; - }; - static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); - - struct SampleLocationEXT - { - SampleLocationEXT( float x_ = 0, - float y_ = 0 ) - : x( x_ ) - , y( y_ ) - { - } - - SampleLocationEXT( VkSampleLocationEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationEXT ) ); - } - - SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationEXT ) ); - return *this; - } - SampleLocationEXT& setX( float x_ ) - { - x = x_; - return *this; - } - - SampleLocationEXT& setY( float y_ ) - { - y = y_; - return *this; - } - - operator const VkSampleLocationEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SampleLocationEXT const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ); - } - - bool operator!=( SampleLocationEXT const& rhs ) const - { - return !operator==( rhs ); - } - - float x; - float y; - }; - static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); - - struct ShaderResourceUsageAMD - { - operator const VkShaderResourceUsageAMD&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ShaderResourceUsageAMD const& rhs ) const - { - return ( numUsedVgprs == rhs.numUsedVgprs ) - && ( numUsedSgprs == rhs.numUsedSgprs ) - && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) - && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) - && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); - } - - bool operator!=( ShaderResourceUsageAMD const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t numUsedVgprs; - uint32_t numUsedSgprs; - uint32_t ldsSizePerLocalWorkGroup; - size_t ldsUsageSizeInBytes; - size_t scratchMemUsageInBytes; - }; - static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" ); - - struct VertexInputBindingDivisorDescriptionEXT - { - VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0, - uint32_t divisor_ = 0 ) - : binding( binding_ ) - , divisor( divisor_ ) - { - } - - VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) ); - } - - VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) ); - return *this; - } - VertexInputBindingDivisorDescriptionEXT& setBinding( uint32_t binding_ ) - { - binding = binding_; - return *this; - } - - VertexInputBindingDivisorDescriptionEXT& setDivisor( uint32_t divisor_ ) - { - divisor = divisor_; - return *this; - } - - operator const VkVertexInputBindingDivisorDescriptionEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( VertexInputBindingDivisorDescriptionEXT const& rhs ) const - { - return ( binding == rhs.binding ) - && ( divisor == rhs.divisor ); - } - - bool operator!=( VertexInputBindingDivisorDescriptionEXT const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t binding; - uint32_t divisor; - }; - static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" ); - - enum class ImageLayout - { - eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, - eGeneral = VK_IMAGE_LAYOUT_GENERAL, - eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, - eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED, - eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, - eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, - eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, - eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, - ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, - eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR - }; - - struct DescriptorImageInfo - { - DescriptorImageInfo( Sampler sampler_ = Sampler(), - ImageView imageView_ = ImageView(), - ImageLayout imageLayout_ = ImageLayout::eUndefined ) - : sampler( sampler_ ) - , imageView( imageView_ ) - , imageLayout( imageLayout_ ) - { - } - - DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); - } - - DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); - return *this; - } - DescriptorImageInfo& setSampler( Sampler sampler_ ) - { - sampler = sampler_; - return *this; - } - - DescriptorImageInfo& setImageView( ImageView imageView_ ) - { - imageView = imageView_; - return *this; - } - - DescriptorImageInfo& setImageLayout( ImageLayout imageLayout_ ) - { - imageLayout = imageLayout_; - return *this; - } - - operator const VkDescriptorImageInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorImageInfo const& rhs ) const - { - return ( sampler == rhs.sampler ) - && ( imageView == rhs.imageView ) - && ( imageLayout == rhs.imageLayout ); - } - - bool operator!=( DescriptorImageInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Sampler sampler; - ImageView imageView; - ImageLayout imageLayout; - }; - static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" ); - - struct AttachmentReference - { - AttachmentReference( uint32_t attachment_ = 0, - ImageLayout layout_ = ImageLayout::eUndefined ) - : attachment( attachment_ ) - , layout( layout_ ) - { - } - - AttachmentReference( VkAttachmentReference const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentReference ) ); - } - - AttachmentReference& operator=( VkAttachmentReference const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentReference ) ); - return *this; - } - AttachmentReference& setAttachment( uint32_t attachment_ ) - { - attachment = attachment_; - return *this; - } - - AttachmentReference& setLayout( ImageLayout layout_ ) - { - layout = layout_; - return *this; - } - - operator const VkAttachmentReference&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AttachmentReference const& rhs ) const - { - return ( attachment == rhs.attachment ) - && ( layout == rhs.layout ); - } - - bool operator!=( AttachmentReference const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t attachment; - ImageLayout layout; - }; - static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); - - enum class AttachmentLoadOp - { - eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, - eClear = VK_ATTACHMENT_LOAD_OP_CLEAR, - eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE - }; - - enum class AttachmentStoreOp - { - eStore = VK_ATTACHMENT_STORE_OP_STORE, - eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE - }; - - enum class ImageType - { - e1D = VK_IMAGE_TYPE_1D, - e2D = VK_IMAGE_TYPE_2D, - e3D = VK_IMAGE_TYPE_3D - }; - - enum class ImageTiling - { - eOptimal = VK_IMAGE_TILING_OPTIMAL, - eLinear = VK_IMAGE_TILING_LINEAR - }; - - enum class ImageViewType - { - e1D = VK_IMAGE_VIEW_TYPE_1D, - e2D = VK_IMAGE_VIEW_TYPE_2D, - e3D = VK_IMAGE_VIEW_TYPE_3D, - eCube = VK_IMAGE_VIEW_TYPE_CUBE, - e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY, - e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY, - eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - }; - - enum class CommandBufferLevel - { - ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, - eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY - }; - - enum class ComponentSwizzle - { - eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY, - eZero = VK_COMPONENT_SWIZZLE_ZERO, - eOne = VK_COMPONENT_SWIZZLE_ONE, - eR = VK_COMPONENT_SWIZZLE_R, - eG = VK_COMPONENT_SWIZZLE_G, - eB = VK_COMPONENT_SWIZZLE_B, - eA = VK_COMPONENT_SWIZZLE_A - }; - - struct ComponentMapping - { - ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity, - ComponentSwizzle g_ = ComponentSwizzle::eIdentity, - ComponentSwizzle b_ = ComponentSwizzle::eIdentity, - ComponentSwizzle a_ = ComponentSwizzle::eIdentity ) - : r( r_ ) - , g( g_ ) - , b( b_ ) - , a( a_ ) - { - } - - ComponentMapping( VkComponentMapping const & rhs ) - { - memcpy( this, &rhs, sizeof( ComponentMapping ) ); - } - - ComponentMapping& operator=( VkComponentMapping const & rhs ) - { - memcpy( this, &rhs, sizeof( ComponentMapping ) ); - return *this; - } - ComponentMapping& setR( ComponentSwizzle r_ ) - { - r = r_; - return *this; - } - - ComponentMapping& setG( ComponentSwizzle g_ ) - { - g = g_; - return *this; - } - - ComponentMapping& setB( ComponentSwizzle b_ ) - { - b = b_; - return *this; - } - - ComponentMapping& setA( ComponentSwizzle a_ ) - { - a = a_; - return *this; - } - - operator const VkComponentMapping&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ComponentMapping const& rhs ) const - { - return ( r == rhs.r ) - && ( g == rhs.g ) - && ( b == rhs.b ) - && ( a == rhs.a ); - } - - bool operator!=( ComponentMapping const& rhs ) const - { - return !operator==( rhs ); - } - - ComponentSwizzle r; - ComponentSwizzle g; - ComponentSwizzle b; - ComponentSwizzle a; - }; - static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" ); - - enum class DescriptorType - { - eSampler = VK_DESCRIPTOR_TYPE_SAMPLER, - eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, - eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, - eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, - eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, - eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, - eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, - eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - }; - - struct DescriptorPoolSize - { - DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, - uint32_t descriptorCount_ = 0 ) - : type( type_ ) - , descriptorCount( descriptorCount_ ) - { - } - - DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); - } - - DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); - return *this; - } - DescriptorPoolSize& setType( DescriptorType type_ ) - { - type = type_; - return *this; - } - - DescriptorPoolSize& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - operator const VkDescriptorPoolSize&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorPoolSize const& rhs ) const - { - return ( type == rhs.type ) - && ( descriptorCount == rhs.descriptorCount ); - } - - bool operator!=( DescriptorPoolSize const& rhs ) const - { - return !operator==( rhs ); - } - - DescriptorType type; - uint32_t descriptorCount; - }; - static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); - - struct DescriptorUpdateTemplateEntry - { - DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0, - uint32_t dstArrayElement_ = 0, - uint32_t descriptorCount_ = 0, - DescriptorType descriptorType_ = DescriptorType::eSampler, - size_t offset_ = 0, - size_t stride_ = 0 ) - : dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - , descriptorType( descriptorType_ ) - , offset( offset_ ) - , stride( stride_ ) - { - } - - DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) ); - } - - DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) ); - return *this; - } - DescriptorUpdateTemplateEntry& setDstBinding( uint32_t dstBinding_ ) - { - dstBinding = dstBinding_; - return *this; - } - - DescriptorUpdateTemplateEntry& setDstArrayElement( uint32_t dstArrayElement_ ) - { - dstArrayElement = dstArrayElement_; - return *this; - } - - DescriptorUpdateTemplateEntry& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - DescriptorUpdateTemplateEntry& setDescriptorType( DescriptorType descriptorType_ ) - { - descriptorType = descriptorType_; - return *this; - } - - DescriptorUpdateTemplateEntry& setOffset( size_t offset_ ) - { - offset = offset_; - return *this; - } - - DescriptorUpdateTemplateEntry& setStride( size_t stride_ ) - { - stride = stride_; - return *this; - } - - operator const VkDescriptorUpdateTemplateEntry&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const - { - return ( dstBinding == rhs.dstBinding ) - && ( dstArrayElement == rhs.dstArrayElement ) - && ( descriptorCount == rhs.descriptorCount ) - && ( descriptorType == rhs.descriptorType ) - && ( offset == rhs.offset ) - && ( stride == rhs.stride ); - } - - bool operator!=( DescriptorUpdateTemplateEntry const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - DescriptorType descriptorType; - size_t offset; - size_t stride; - }; - static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" ); - - using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; - - enum class QueryType - { - eOcclusion = VK_QUERY_TYPE_OCCLUSION, - ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, - eTimestamp = VK_QUERY_TYPE_TIMESTAMP - }; - - enum class BorderColor - { - eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, - eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, - eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, - eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK, - eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, - eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE - }; - - enum class PipelineBindPoint - { - eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, - eCompute = VK_PIPELINE_BIND_POINT_COMPUTE - }; - - enum class PipelineCacheHeaderVersion - { - eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE - }; - - enum class PrimitiveTopology - { - ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, - eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, - eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, - eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, - eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, - eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, - eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, - eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, - ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - }; - - enum class SharingMode - { - eExclusive = VK_SHARING_MODE_EXCLUSIVE, - eConcurrent = VK_SHARING_MODE_CONCURRENT - }; - - enum class IndexType - { - eUint16 = VK_INDEX_TYPE_UINT16, - eUint32 = VK_INDEX_TYPE_UINT32 - }; - - enum class Filter - { - eNearest = VK_FILTER_NEAREST, - eLinear = VK_FILTER_LINEAR, - eCubicIMG = VK_FILTER_CUBIC_IMG - }; - - enum class SamplerMipmapMode - { - eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, - eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR - }; - - enum class SamplerAddressMode - { - eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT, - eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, - eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, - eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, - eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - }; - - enum class CompareOp - { - eNever = VK_COMPARE_OP_NEVER, - eLess = VK_COMPARE_OP_LESS, - eEqual = VK_COMPARE_OP_EQUAL, - eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL, - eGreater = VK_COMPARE_OP_GREATER, - eNotEqual = VK_COMPARE_OP_NOT_EQUAL, - eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL, - eAlways = VK_COMPARE_OP_ALWAYS - }; - - enum class PolygonMode - { - eFill = VK_POLYGON_MODE_FILL, - eLine = VK_POLYGON_MODE_LINE, - ePoint = VK_POLYGON_MODE_POINT, - eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV - }; - - enum class CullModeFlagBits - { - eNone = VK_CULL_MODE_NONE, - eFront = VK_CULL_MODE_FRONT_BIT, - eBack = VK_CULL_MODE_BACK_BIT, - eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK - }; - - using CullModeFlags = Flags; - - VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 ) - { - return CullModeFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits ) - { - return ~( CullModeFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(CullModeFlagBits::eNone) | VkFlags(CullModeFlagBits::eFront) | VkFlags(CullModeFlagBits::eBack) | VkFlags(CullModeFlagBits::eFrontAndBack) - }; - }; - - enum class FrontFace - { - eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE, - eClockwise = VK_FRONT_FACE_CLOCKWISE - }; - - enum class BlendFactor - { - eZero = VK_BLEND_FACTOR_ZERO, - eOne = VK_BLEND_FACTOR_ONE, - eSrcColor = VK_BLEND_FACTOR_SRC_COLOR, - eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, - eDstColor = VK_BLEND_FACTOR_DST_COLOR, - eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, - eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA, - eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA, - eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, - eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR, - eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, - eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA, - eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, - eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, - eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR, - eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, - eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA, - eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - }; - - enum class BlendOp - { - eAdd = VK_BLEND_OP_ADD, - eSubtract = VK_BLEND_OP_SUBTRACT, - eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT, - eMin = VK_BLEND_OP_MIN, - eMax = VK_BLEND_OP_MAX, - eZeroEXT = VK_BLEND_OP_ZERO_EXT, - eSrcEXT = VK_BLEND_OP_SRC_EXT, - eDstEXT = VK_BLEND_OP_DST_EXT, - eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT, - eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT, - eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT, - eDstInEXT = VK_BLEND_OP_DST_IN_EXT, - eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT, - eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT, - eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT, - eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT, - eXorEXT = VK_BLEND_OP_XOR_EXT, - eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT, - eScreenEXT = VK_BLEND_OP_SCREEN_EXT, - eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT, - eDarkenEXT = VK_BLEND_OP_DARKEN_EXT, - eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT, - eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT, - eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT, - eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT, - eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT, - eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT, - eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT, - eInvertEXT = VK_BLEND_OP_INVERT_EXT, - eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT, - eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT, - eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT, - eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT, - eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT, - ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT, - eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT, - eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT, - eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT, - eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT, - eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT, - ePlusEXT = VK_BLEND_OP_PLUS_EXT, - ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT, - ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, - ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT, - eMinusEXT = VK_BLEND_OP_MINUS_EXT, - eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT, - eContrastEXT = VK_BLEND_OP_CONTRAST_EXT, - eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT, - eRedEXT = VK_BLEND_OP_RED_EXT, - eGreenEXT = VK_BLEND_OP_GREEN_EXT, - eBlueEXT = VK_BLEND_OP_BLUE_EXT - }; - - enum class StencilOp - { - eKeep = VK_STENCIL_OP_KEEP, - eZero = VK_STENCIL_OP_ZERO, - eReplace = VK_STENCIL_OP_REPLACE, - eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP, - eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP, - eInvert = VK_STENCIL_OP_INVERT, - eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP, - eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP - }; - - struct StencilOpState - { - StencilOpState( StencilOp failOp_ = StencilOp::eKeep, - StencilOp passOp_ = StencilOp::eKeep, - StencilOp depthFailOp_ = StencilOp::eKeep, - CompareOp compareOp_ = CompareOp::eNever, - uint32_t compareMask_ = 0, - uint32_t writeMask_ = 0, - uint32_t reference_ = 0 ) - : failOp( failOp_ ) - , passOp( passOp_ ) - , depthFailOp( depthFailOp_ ) - , compareOp( compareOp_ ) - , compareMask( compareMask_ ) - , writeMask( writeMask_ ) - , reference( reference_ ) - { - } - - StencilOpState( VkStencilOpState const & rhs ) - { - memcpy( this, &rhs, sizeof( StencilOpState ) ); - } - - StencilOpState& operator=( VkStencilOpState const & rhs ) - { - memcpy( this, &rhs, sizeof( StencilOpState ) ); - return *this; - } - StencilOpState& setFailOp( StencilOp failOp_ ) - { - failOp = failOp_; - return *this; - } - - StencilOpState& setPassOp( StencilOp passOp_ ) - { - passOp = passOp_; - return *this; - } - - StencilOpState& setDepthFailOp( StencilOp depthFailOp_ ) - { - depthFailOp = depthFailOp_; - return *this; - } - - StencilOpState& setCompareOp( CompareOp compareOp_ ) - { - compareOp = compareOp_; - return *this; - } - - StencilOpState& setCompareMask( uint32_t compareMask_ ) - { - compareMask = compareMask_; - return *this; - } - - StencilOpState& setWriteMask( uint32_t writeMask_ ) - { - writeMask = writeMask_; - return *this; - } - - StencilOpState& setReference( uint32_t reference_ ) - { - reference = reference_; - return *this; - } - - operator const VkStencilOpState&() const - { - return *reinterpret_cast(this); - } - - bool operator==( StencilOpState const& rhs ) const - { - return ( failOp == rhs.failOp ) - && ( passOp == rhs.passOp ) - && ( depthFailOp == rhs.depthFailOp ) - && ( compareOp == rhs.compareOp ) - && ( compareMask == rhs.compareMask ) - && ( writeMask == rhs.writeMask ) - && ( reference == rhs.reference ); - } - - bool operator!=( StencilOpState const& rhs ) const - { - return !operator==( rhs ); - } - - StencilOp failOp; - StencilOp passOp; - StencilOp depthFailOp; - CompareOp compareOp; - uint32_t compareMask; - uint32_t writeMask; - uint32_t reference; - }; - static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); - - enum class LogicOp - { - eClear = VK_LOGIC_OP_CLEAR, - eAnd = VK_LOGIC_OP_AND, - eAndReverse = VK_LOGIC_OP_AND_REVERSE, - eCopy = VK_LOGIC_OP_COPY, - eAndInverted = VK_LOGIC_OP_AND_INVERTED, - eNoOp = VK_LOGIC_OP_NO_OP, - eXor = VK_LOGIC_OP_XOR, - eOr = VK_LOGIC_OP_OR, - eNor = VK_LOGIC_OP_NOR, - eEquivalent = VK_LOGIC_OP_EQUIVALENT, - eInvert = VK_LOGIC_OP_INVERT, - eOrReverse = VK_LOGIC_OP_OR_REVERSE, - eCopyInverted = VK_LOGIC_OP_COPY_INVERTED, - eOrInverted = VK_LOGIC_OP_OR_INVERTED, - eNand = VK_LOGIC_OP_NAND, - eSet = VK_LOGIC_OP_SET - }; - - enum class InternalAllocationType - { - eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - }; - - enum class SystemAllocationScope - { - eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, - eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, - eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE, - eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, - eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - }; - - enum class PhysicalDeviceType - { - eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER, - eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, - eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, - eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, - eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU - }; - - enum class VertexInputRate - { - eVertex = VK_VERTEX_INPUT_RATE_VERTEX, - eInstance = VK_VERTEX_INPUT_RATE_INSTANCE - }; - - struct VertexInputBindingDescription - { - VertexInputBindingDescription( uint32_t binding_ = 0, - uint32_t stride_ = 0, - VertexInputRate inputRate_ = VertexInputRate::eVertex ) - : binding( binding_ ) - , stride( stride_ ) - , inputRate( inputRate_ ) - { - } - - VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); - } - - VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); - return *this; - } - VertexInputBindingDescription& setBinding( uint32_t binding_ ) - { - binding = binding_; - return *this; - } - - VertexInputBindingDescription& setStride( uint32_t stride_ ) - { - stride = stride_; - return *this; - } - - VertexInputBindingDescription& setInputRate( VertexInputRate inputRate_ ) - { - inputRate = inputRate_; - return *this; - } - - operator const VkVertexInputBindingDescription&() const - { - return *reinterpret_cast(this); - } - - bool operator==( VertexInputBindingDescription const& rhs ) const - { - return ( binding == rhs.binding ) - && ( stride == rhs.stride ) - && ( inputRate == rhs.inputRate ); - } - - bool operator!=( VertexInputBindingDescription const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t binding; - uint32_t stride; - VertexInputRate inputRate; - }; - static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" ); - - enum class Format - { - eUndefined = VK_FORMAT_UNDEFINED, - eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8, - eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, - eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, - eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16, - eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16, - eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, - eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, - eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, - eR8Unorm = VK_FORMAT_R8_UNORM, - eR8Snorm = VK_FORMAT_R8_SNORM, - eR8Uscaled = VK_FORMAT_R8_USCALED, - eR8Sscaled = VK_FORMAT_R8_SSCALED, - eR8Uint = VK_FORMAT_R8_UINT, - eR8Sint = VK_FORMAT_R8_SINT, - eR8Srgb = VK_FORMAT_R8_SRGB, - eR8G8Unorm = VK_FORMAT_R8G8_UNORM, - eR8G8Snorm = VK_FORMAT_R8G8_SNORM, - eR8G8Uscaled = VK_FORMAT_R8G8_USCALED, - eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED, - eR8G8Uint = VK_FORMAT_R8G8_UINT, - eR8G8Sint = VK_FORMAT_R8G8_SINT, - eR8G8Srgb = VK_FORMAT_R8G8_SRGB, - eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM, - eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM, - eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED, - eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED, - eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT, - eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT, - eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB, - eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM, - eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM, - eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED, - eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED, - eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT, - eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT, - eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB, - eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM, - eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM, - eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED, - eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED, - eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT, - eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT, - eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB, - eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM, - eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM, - eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED, - eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED, - eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT, - eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT, - eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB, - eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, - eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, - eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, - eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, - eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, - eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, - eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, - eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, - eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, - eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32, - eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32, - eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, - eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, - eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, - eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, - eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32, - eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32, - eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, - eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, - eR16Unorm = VK_FORMAT_R16_UNORM, - eR16Snorm = VK_FORMAT_R16_SNORM, - eR16Uscaled = VK_FORMAT_R16_USCALED, - eR16Sscaled = VK_FORMAT_R16_SSCALED, - eR16Uint = VK_FORMAT_R16_UINT, - eR16Sint = VK_FORMAT_R16_SINT, - eR16Sfloat = VK_FORMAT_R16_SFLOAT, - eR16G16Unorm = VK_FORMAT_R16G16_UNORM, - eR16G16Snorm = VK_FORMAT_R16G16_SNORM, - eR16G16Uscaled = VK_FORMAT_R16G16_USCALED, - eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED, - eR16G16Uint = VK_FORMAT_R16G16_UINT, - eR16G16Sint = VK_FORMAT_R16G16_SINT, - eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT, - eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM, - eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM, - eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED, - eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED, - eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT, - eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT, - eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT, - eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM, - eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM, - eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED, - eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED, - eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT, - eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT, - eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT, - eR32Uint = VK_FORMAT_R32_UINT, - eR32Sint = VK_FORMAT_R32_SINT, - eR32Sfloat = VK_FORMAT_R32_SFLOAT, - eR32G32Uint = VK_FORMAT_R32G32_UINT, - eR32G32Sint = VK_FORMAT_R32G32_SINT, - eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT, - eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT, - eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT, - eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT, - eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT, - eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT, - eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT, - eR64Uint = VK_FORMAT_R64_UINT, - eR64Sint = VK_FORMAT_R64_SINT, - eR64Sfloat = VK_FORMAT_R64_SFLOAT, - eR64G64Uint = VK_FORMAT_R64G64_UINT, - eR64G64Sint = VK_FORMAT_R64G64_SINT, - eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT, - eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT, - eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT, - eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT, - eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT, - eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT, - eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT, - eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, - eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, - eD16Unorm = VK_FORMAT_D16_UNORM, - eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32, - eD32Sfloat = VK_FORMAT_D32_SFLOAT, - eS8Uint = VK_FORMAT_S8_UINT, - eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT, - eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT, - eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT, - eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK, - eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK, - eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, - eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, - eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK, - eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK, - eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK, - eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK, - eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK, - eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK, - eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK, - eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK, - eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK, - eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK, - eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK, - eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK, - eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, - eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, - eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, - eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, - eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, - eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, - eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK, - eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK, - eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, - eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, - eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, - eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, - eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, - eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, - eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, - eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, - eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, - eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, - eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, - eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, - eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, - eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, - eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, - eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, - eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, - eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, - eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, - eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, - eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, - eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, - eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, - eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, - eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, - eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, - eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, - eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, - eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, - eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, - eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM, - eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM, - eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM, - eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM, - eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, - eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, - eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, - eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, - eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16, - eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16, - eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, - eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, - eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16, - eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16, - eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, - eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, - eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM, - eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM, - eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM, - eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM, - eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, - eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, - eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, - eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, - eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, - eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, - ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, - ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, - ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, - ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, - ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, - ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, - ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, - ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG - }; - - struct VertexInputAttributeDescription - { - VertexInputAttributeDescription( uint32_t location_ = 0, - uint32_t binding_ = 0, - Format format_ = Format::eUndefined, - uint32_t offset_ = 0 ) - : location( location_ ) - , binding( binding_ ) - , format( format_ ) - , offset( offset_ ) - { - } - - VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); - } - - VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); - return *this; - } - VertexInputAttributeDescription& setLocation( uint32_t location_ ) - { - location = location_; - return *this; - } - - VertexInputAttributeDescription& setBinding( uint32_t binding_ ) - { - binding = binding_; - return *this; - } - - VertexInputAttributeDescription& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - VertexInputAttributeDescription& setOffset( uint32_t offset_ ) - { - offset = offset_; - return *this; - } - - operator const VkVertexInputAttributeDescription&() const - { - return *reinterpret_cast(this); - } - - bool operator==( VertexInputAttributeDescription const& rhs ) const - { - return ( location == rhs.location ) - && ( binding == rhs.binding ) - && ( format == rhs.format ) - && ( offset == rhs.offset ); - } - - bool operator!=( VertexInputAttributeDescription const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t location; - uint32_t binding; - Format format; - uint32_t offset; - }; - static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" ); - - enum class StructureType - { - eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO, - eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, - eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO, - eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, - eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, - eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, - eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, - eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, - eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, - eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, - eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, - eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, - eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, - eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, - eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, - ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, - ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, - ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, - ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, - eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, - eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, - ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, - eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, - eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, - eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, - eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, - eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, - eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, - eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, - eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, - eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, - eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, - eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, - eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, - eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER, - eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, - eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, - ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, - eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, - eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, - eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, - eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, - ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, - eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, - eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, - eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, - eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, - eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, - eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, - eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, - eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, - ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, - eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, - eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, - eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, - eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, - eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, - eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, - eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, - eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, - eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, - eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, - eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, - eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, - ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, - eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, - ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, - eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, - ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, - eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, - ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, - eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, - ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, - ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, - eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, - ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, - ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, - eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, - eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, - eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, - eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, - eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, - eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, - eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, - ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, - eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, - ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, - ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, - eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, - eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, - ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, - eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, - eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, - eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, - eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, - eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, - ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, - eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, - ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, - eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, - ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, - eDeviceGroupPresentCapabilitiesKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, - eImageSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, - eBindImageMemorySwapchainInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, - eAcquireNextImageInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, - eDeviceGroupPresentInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, - eDeviceGroupSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, - eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, - eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, - eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, - eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, - eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, - eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, - eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR, - eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, - eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, - eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, - eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, - eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, - eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, - eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, - eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, - eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, - eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, - eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, - eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, - eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, - eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, - eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, - eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, - eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, - eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, - eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, - eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, - eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, - eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, - eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, - eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, - eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, - eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, - eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, - ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, - ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, - eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, - eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, - eCmdProcessCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX, - eCmdReserveSpaceForCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX, - eDeviceGeneratedCommandsLimitsNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX, - eDeviceGeneratedCommandsFeaturesNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX, - ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, - eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, - eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, - eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, - eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, - eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, - ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, - ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, - ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, - ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, - ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, - ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, - ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, - eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, - eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, - eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, - eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, - eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, - eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, - eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, - ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, - eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, - eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, - eDisplayProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, - eDisplayPlaneProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR, - eDisplayModeProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, - eDisplayPlaneInfo2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, - eDisplayPlaneCapabilities2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, - eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, - eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, - eDebugUtilsObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, - eDebugUtilsObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT, - eDebugUtilsLabelEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, - eDebugUtilsMessengerCallbackDataEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, - eDebugUtilsMessengerCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, - eAndroidHardwareBufferUsageANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, - eAndroidHardwareBufferPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, - eAndroidHardwareBufferFormatPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, - eImportAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, - eMemoryGetAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, - eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, - ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, - eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, - eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, - eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, - ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, - ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, - eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, - eImageFormatListCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR, - ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, - ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, - ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, - ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, - ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, - eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, - eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, - eDescriptorSetLayoutBindingFlagsCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, - ePhysicalDeviceDescriptorIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, - ePhysicalDeviceDescriptorIndexingPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, - eDescriptorSetVariableDescriptorCountAllocateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, - eDescriptorSetVariableDescriptorCountLayoutSupportEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, - eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, - eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, - eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, - ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, - ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, - ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, - ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT - }; - - struct ApplicationInfo - { - ApplicationInfo( const char* pApplicationName_ = nullptr, - uint32_t applicationVersion_ = 0, - const char* pEngineName_ = nullptr, - uint32_t engineVersion_ = 0, - uint32_t apiVersion_ = 0 ) - : pApplicationName( pApplicationName_ ) - , applicationVersion( applicationVersion_ ) - , pEngineName( pEngineName_ ) - , engineVersion( engineVersion_ ) - , apiVersion( apiVersion_ ) - { - } - - ApplicationInfo( VkApplicationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ApplicationInfo ) ); - } - - ApplicationInfo& operator=( VkApplicationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ApplicationInfo ) ); - return *this; - } - ApplicationInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ApplicationInfo& setPApplicationName( const char* pApplicationName_ ) - { - pApplicationName = pApplicationName_; - return *this; - } - - ApplicationInfo& setApplicationVersion( uint32_t applicationVersion_ ) - { - applicationVersion = applicationVersion_; - return *this; - } - - ApplicationInfo& setPEngineName( const char* pEngineName_ ) - { - pEngineName = pEngineName_; - return *this; - } - - ApplicationInfo& setEngineVersion( uint32_t engineVersion_ ) - { - engineVersion = engineVersion_; - return *this; - } - - ApplicationInfo& setApiVersion( uint32_t apiVersion_ ) - { - apiVersion = apiVersion_; - return *this; - } - - operator const VkApplicationInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ApplicationInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pApplicationName == rhs.pApplicationName ) - && ( applicationVersion == rhs.applicationVersion ) - && ( pEngineName == rhs.pEngineName ) - && ( engineVersion == rhs.engineVersion ) - && ( apiVersion == rhs.apiVersion ); - } - - bool operator!=( ApplicationInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eApplicationInfo; - - public: - const void* pNext = nullptr; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; - }; - static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); - - struct InstanceCreateInfo - { - InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(), - const ApplicationInfo* pApplicationInfo_ = nullptr, - uint32_t enabledLayerCount_ = 0, - const char* const* ppEnabledLayerNames_ = nullptr, - uint32_t enabledExtensionCount_ = 0, - const char* const* ppEnabledExtensionNames_ = nullptr ) - : flags( flags_ ) - , pApplicationInfo( pApplicationInfo_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - { - } - - InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); - } - - InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); - return *this; - } - InstanceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - InstanceCreateInfo& setFlags( InstanceCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - InstanceCreateInfo& setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ ) - { - pApplicationInfo = pApplicationInfo_; - return *this; - } - - InstanceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ ) - { - enabledLayerCount = enabledLayerCount_; - return *this; - } - - InstanceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ ) - { - ppEnabledLayerNames = ppEnabledLayerNames_; - return *this; - } - - InstanceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) - { - enabledExtensionCount = enabledExtensionCount_; - return *this; - } - - InstanceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ ) - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return *this; - } - - operator const VkInstanceCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( InstanceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pApplicationInfo == rhs.pApplicationInfo ) - && ( enabledLayerCount == rhs.enabledLayerCount ) - && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) - && ( enabledExtensionCount == rhs.enabledExtensionCount ) - && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ); - } - - bool operator!=( InstanceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eInstanceCreateInfo; - - public: - const void* pNext = nullptr; - InstanceCreateFlags flags; - const ApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - }; - static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" ); - - struct MemoryAllocateInfo - { - MemoryAllocateInfo( DeviceSize allocationSize_ = 0, - uint32_t memoryTypeIndex_ = 0 ) - : allocationSize( allocationSize_ ) - , memoryTypeIndex( memoryTypeIndex_ ) - { - } - - MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); - } - - MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); - return *this; - } - MemoryAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryAllocateInfo& setAllocationSize( DeviceSize allocationSize_ ) - { - allocationSize = allocationSize_; - return *this; - } - - MemoryAllocateInfo& setMemoryTypeIndex( uint32_t memoryTypeIndex_ ) - { - memoryTypeIndex = memoryTypeIndex_; - return *this; - } - - operator const VkMemoryAllocateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( allocationSize == rhs.allocationSize ) - && ( memoryTypeIndex == rhs.memoryTypeIndex ); - } - - bool operator!=( MemoryAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryAllocateInfo; - - public: - const void* pNext = nullptr; - DeviceSize allocationSize; - uint32_t memoryTypeIndex; - }; - static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); - - struct MappedMemoryRange - { - MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), - DeviceSize offset_ = 0, - DeviceSize size_ = 0 ) - : memory( memory_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - MappedMemoryRange( VkMappedMemoryRange const & rhs ) - { - memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); - } - - MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) - { - memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); - return *this; - } - MappedMemoryRange& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MappedMemoryRange& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - MappedMemoryRange& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - MappedMemoryRange& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - operator const VkMappedMemoryRange&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MappedMemoryRange const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memory == rhs.memory ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( MappedMemoryRange const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMappedMemoryRange; - - public: - const void* pNext = nullptr; - DeviceMemory memory; - DeviceSize offset; - DeviceSize size; - }; - static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); - - struct WriteDescriptorSet - { - WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(), - uint32_t dstBinding_ = 0, - uint32_t dstArrayElement_ = 0, - uint32_t descriptorCount_ = 0, - DescriptorType descriptorType_ = DescriptorType::eSampler, - const DescriptorImageInfo* pImageInfo_ = nullptr, - const DescriptorBufferInfo* pBufferInfo_ = nullptr, - const BufferView* pTexelBufferView_ = nullptr ) - : dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - , descriptorType( descriptorType_ ) - , pImageInfo( pImageInfo_ ) - , pBufferInfo( pBufferInfo_ ) - , pTexelBufferView( pTexelBufferView_ ) - { - } - - WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); - } - - WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); - return *this; - } - WriteDescriptorSet& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - WriteDescriptorSet& setDstSet( DescriptorSet dstSet_ ) - { - dstSet = dstSet_; - return *this; - } - - WriteDescriptorSet& setDstBinding( uint32_t dstBinding_ ) - { - dstBinding = dstBinding_; - return *this; - } - - WriteDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ ) - { - dstArrayElement = dstArrayElement_; - return *this; - } - - WriteDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - WriteDescriptorSet& setDescriptorType( DescriptorType descriptorType_ ) - { - descriptorType = descriptorType_; - return *this; - } - - WriteDescriptorSet& setPImageInfo( const DescriptorImageInfo* pImageInfo_ ) - { - pImageInfo = pImageInfo_; - return *this; - } - - WriteDescriptorSet& setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ ) - { - pBufferInfo = pBufferInfo_; - return *this; - } - - WriteDescriptorSet& setPTexelBufferView( const BufferView* pTexelBufferView_ ) - { - pTexelBufferView = pTexelBufferView_; - return *this; - } - - operator const VkWriteDescriptorSet&() const - { - return *reinterpret_cast(this); - } - - bool operator==( WriteDescriptorSet const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( dstSet == rhs.dstSet ) - && ( dstBinding == rhs.dstBinding ) - && ( dstArrayElement == rhs.dstArrayElement ) - && ( descriptorCount == rhs.descriptorCount ) - && ( descriptorType == rhs.descriptorType ) - && ( pImageInfo == rhs.pImageInfo ) - && ( pBufferInfo == rhs.pBufferInfo ) - && ( pTexelBufferView == rhs.pTexelBufferView ); - } - - bool operator!=( WriteDescriptorSet const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWriteDescriptorSet; - - public: - const void* pNext = nullptr; - DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - DescriptorType descriptorType; - const DescriptorImageInfo* pImageInfo; - const DescriptorBufferInfo* pBufferInfo; - const BufferView* pTexelBufferView; - }; - static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); - - struct CopyDescriptorSet - { - CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(), - uint32_t srcBinding_ = 0, - uint32_t srcArrayElement_ = 0, - DescriptorSet dstSet_ = DescriptorSet(), - uint32_t dstBinding_ = 0, - uint32_t dstArrayElement_ = 0, - uint32_t descriptorCount_ = 0 ) - : srcSet( srcSet_ ) - , srcBinding( srcBinding_ ) - , srcArrayElement( srcArrayElement_ ) - , dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - { - } - - CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); - } - - CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); - return *this; - } - CopyDescriptorSet& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CopyDescriptorSet& setSrcSet( DescriptorSet srcSet_ ) - { - srcSet = srcSet_; - return *this; - } - - CopyDescriptorSet& setSrcBinding( uint32_t srcBinding_ ) - { - srcBinding = srcBinding_; - return *this; - } - - CopyDescriptorSet& setSrcArrayElement( uint32_t srcArrayElement_ ) - { - srcArrayElement = srcArrayElement_; - return *this; - } - - CopyDescriptorSet& setDstSet( DescriptorSet dstSet_ ) - { - dstSet = dstSet_; - return *this; - } - - CopyDescriptorSet& setDstBinding( uint32_t dstBinding_ ) - { - dstBinding = dstBinding_; - return *this; - } - - CopyDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ ) - { - dstArrayElement = dstArrayElement_; - return *this; - } - - CopyDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - operator const VkCopyDescriptorSet&() const - { - return *reinterpret_cast(this); - } - - bool operator==( CopyDescriptorSet const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcSet == rhs.srcSet ) - && ( srcBinding == rhs.srcBinding ) - && ( srcArrayElement == rhs.srcArrayElement ) - && ( dstSet == rhs.dstSet ) - && ( dstBinding == rhs.dstBinding ) - && ( dstArrayElement == rhs.dstArrayElement ) - && ( descriptorCount == rhs.descriptorCount ); - } - - bool operator!=( CopyDescriptorSet const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCopyDescriptorSet; - - public: - const void* pNext = nullptr; - DescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - }; - static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" ); - - struct BufferViewCreateInfo - { - BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), - Buffer buffer_ = Buffer(), - Format format_ = Format::eUndefined, - DeviceSize offset_ = 0, - DeviceSize range_ = 0 ) - : flags( flags_ ) - , buffer( buffer_ ) - , format( format_ ) - , offset( offset_ ) - , range( range_ ) - { - } - - BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); - } - - BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); - return *this; - } - BufferViewCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferViewCreateInfo& setFlags( BufferViewCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - BufferViewCreateInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - BufferViewCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - BufferViewCreateInfo& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - BufferViewCreateInfo& setRange( DeviceSize range_ ) - { - range = range_; - return *this; - } - - operator const VkBufferViewCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BufferViewCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ) - && ( format == rhs.format ) - && ( offset == rhs.offset ) - && ( range == rhs.range ); - } - - bool operator!=( BufferViewCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferViewCreateInfo; - - public: - const void* pNext = nullptr; - BufferViewCreateFlags flags; - Buffer buffer; - Format format; - DeviceSize offset; - DeviceSize range; - }; - static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); - - struct ShaderModuleCreateInfo - { - ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), - size_t codeSize_ = 0, - const uint32_t* pCode_ = nullptr ) - : flags( flags_ ) - , codeSize( codeSize_ ) - , pCode( pCode_ ) - { - } - - ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); - } - - ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); - return *this; - } - ShaderModuleCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ShaderModuleCreateInfo& setFlags( ShaderModuleCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ShaderModuleCreateInfo& setCodeSize( size_t codeSize_ ) - { - codeSize = codeSize_; - return *this; - } - - ShaderModuleCreateInfo& setPCode( const uint32_t* pCode_ ) - { - pCode = pCode_; - return *this; - } - - operator const VkShaderModuleCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ShaderModuleCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( codeSize == rhs.codeSize ) - && ( pCode == rhs.pCode ); - } - - bool operator!=( ShaderModuleCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eShaderModuleCreateInfo; - - public: - const void* pNext = nullptr; - ShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; - }; - static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" ); - - struct DescriptorSetAllocateInfo - { - DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), - uint32_t descriptorSetCount_ = 0, - const DescriptorSetLayout* pSetLayouts_ = nullptr ) - : descriptorPool( descriptorPool_ ) - , descriptorSetCount( descriptorSetCount_ ) - , pSetLayouts( pSetLayouts_ ) - { - } - - DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); - } - - DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); - return *this; - } - DescriptorSetAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorSetAllocateInfo& setDescriptorPool( DescriptorPool descriptorPool_ ) - { - descriptorPool = descriptorPool_; - return *this; - } - - DescriptorSetAllocateInfo& setDescriptorSetCount( uint32_t descriptorSetCount_ ) - { - descriptorSetCount = descriptorSetCount_; - return *this; - } - - DescriptorSetAllocateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) - { - pSetLayouts = pSetLayouts_; - return *this; - } - - operator const VkDescriptorSetAllocateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorSetAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( descriptorPool == rhs.descriptorPool ) - && ( descriptorSetCount == rhs.descriptorSetCount ) - && ( pSetLayouts == rhs.pSetLayouts ); - } - - bool operator!=( DescriptorSetAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetAllocateInfo; - - public: - const void* pNext = nullptr; - DescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const DescriptorSetLayout* pSetLayouts; - }; - static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" ); - - struct PipelineVertexInputStateCreateInfo - { - PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), - uint32_t vertexBindingDescriptionCount_ = 0, - const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, - uint32_t vertexAttributeDescriptionCount_ = 0, - const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) - : flags( flags_ ) - , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) - , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) - , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) - , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ ) - { - } - - PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); - } - - PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); - return *this; - } - PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setFlags( PipelineVertexInputStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) - { - vertexBindingDescriptionCount = vertexBindingDescriptionCount_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ ) - { - pVertexBindingDescriptions = pVertexBindingDescriptions_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) - { - vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ ) - { - pVertexAttributeDescriptions = pVertexAttributeDescriptions_; - return *this; - } - - operator const VkPipelineVertexInputStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) - && ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) - && ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) - && ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); - } - - bool operator!=( PipelineVertexInputStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VertexInputAttributeDescription* pVertexAttributeDescriptions; - }; - static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineInputAssemblyStateCreateInfo - { - PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), - PrimitiveTopology topology_ = PrimitiveTopology::ePointList, - Bool32 primitiveRestartEnable_ = 0 ) - : flags( flags_ ) - , topology( topology_ ) - , primitiveRestartEnable( primitiveRestartEnable_ ) - { - } - - PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); - } - - PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); - return *this; - } - PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineInputAssemblyStateCreateInfo& setFlags( PipelineInputAssemblyStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineInputAssemblyStateCreateInfo& setTopology( PrimitiveTopology topology_ ) - { - topology = topology_; - return *this; - } - - PipelineInputAssemblyStateCreateInfo& setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ ) - { - primitiveRestartEnable = primitiveRestartEnable_; - return *this; - } - - operator const VkPipelineInputAssemblyStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( topology == rhs.topology ) - && ( primitiveRestartEnable == rhs.primitiveRestartEnable ); - } - - bool operator!=( PipelineInputAssemblyStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineInputAssemblyStateCreateFlags flags; - PrimitiveTopology topology; - Bool32 primitiveRestartEnable; - }; - static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineTessellationStateCreateInfo - { - PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), - uint32_t patchControlPoints_ = 0 ) - : flags( flags_ ) - , patchControlPoints( patchControlPoints_ ) - { - } - - PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); - } - - PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); - return *this; - } - PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineTessellationStateCreateInfo& setFlags( PipelineTessellationStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineTessellationStateCreateInfo& setPatchControlPoints( uint32_t patchControlPoints_ ) - { - patchControlPoints = patchControlPoints_; - return *this; - } - - operator const VkPipelineTessellationStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( patchControlPoints == rhs.patchControlPoints ); - } - - bool operator!=( PipelineTessellationStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; - }; - static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineViewportStateCreateInfo - { - PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), - uint32_t viewportCount_ = 0, - const Viewport* pViewports_ = nullptr, - uint32_t scissorCount_ = 0, - const Rect2D* pScissors_ = nullptr ) - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewports( pViewports_ ) - , scissorCount( scissorCount_ ) - , pScissors( pScissors_ ) - { - } - - PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); - } - - PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); - return *this; - } - PipelineViewportStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineViewportStateCreateInfo& setFlags( PipelineViewportStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineViewportStateCreateInfo& setViewportCount( uint32_t viewportCount_ ) - { - viewportCount = viewportCount_; - return *this; - } - - PipelineViewportStateCreateInfo& setPViewports( const Viewport* pViewports_ ) - { - pViewports = pViewports_; - return *this; - } - - PipelineViewportStateCreateInfo& setScissorCount( uint32_t scissorCount_ ) - { - scissorCount = scissorCount_; - return *this; - } - - PipelineViewportStateCreateInfo& setPScissors( const Rect2D* pScissors_ ) - { - pScissors = pScissors_; - return *this; - } - - operator const VkPipelineViewportStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineViewportStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( viewportCount == rhs.viewportCount ) - && ( pViewports == rhs.pViewports ) - && ( scissorCount == rhs.scissorCount ) - && ( pScissors == rhs.pScissors ); - } - - bool operator!=( PipelineViewportStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineViewportStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const Viewport* pViewports; - uint32_t scissorCount; - const Rect2D* pScissors; - }; - static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineRasterizationStateCreateInfo - { - PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(), - Bool32 depthClampEnable_ = 0, - Bool32 rasterizerDiscardEnable_ = 0, - PolygonMode polygonMode_ = PolygonMode::eFill, - CullModeFlags cullMode_ = CullModeFlags(), - FrontFace frontFace_ = FrontFace::eCounterClockwise, - Bool32 depthBiasEnable_ = 0, - float depthBiasConstantFactor_ = 0, - float depthBiasClamp_ = 0, - float depthBiasSlopeFactor_ = 0, - float lineWidth_ = 0 ) - : flags( flags_ ) - , depthClampEnable( depthClampEnable_ ) - , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) - , polygonMode( polygonMode_ ) - , cullMode( cullMode_ ) - , frontFace( frontFace_ ) - , depthBiasEnable( depthBiasEnable_ ) - , depthBiasConstantFactor( depthBiasConstantFactor_ ) - , depthBiasClamp( depthBiasClamp_ ) - , depthBiasSlopeFactor( depthBiasSlopeFactor_ ) - , lineWidth( lineWidth_ ) - { - } - - PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); - } - - PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); - return *this; - } - PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setFlags( PipelineRasterizationStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthClampEnable( Bool32 depthClampEnable_ ) - { - depthClampEnable = depthClampEnable_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ ) - { - rasterizerDiscardEnable = rasterizerDiscardEnable_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setPolygonMode( PolygonMode polygonMode_ ) - { - polygonMode = polygonMode_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setCullMode( CullModeFlags cullMode_ ) - { - cullMode = cullMode_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setFrontFace( FrontFace frontFace_ ) - { - frontFace = frontFace_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasEnable( Bool32 depthBiasEnable_ ) - { - depthBiasEnable = depthBiasEnable_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) - { - depthBiasConstantFactor = depthBiasConstantFactor_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasClamp( float depthBiasClamp_ ) - { - depthBiasClamp = depthBiasClamp_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) - { - depthBiasSlopeFactor = depthBiasSlopeFactor_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setLineWidth( float lineWidth_ ) - { - lineWidth = lineWidth_; - return *this; - } - - operator const VkPipelineRasterizationStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( depthClampEnable == rhs.depthClampEnable ) - && ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) - && ( polygonMode == rhs.polygonMode ) - && ( cullMode == rhs.cullMode ) - && ( frontFace == rhs.frontFace ) - && ( depthBiasEnable == rhs.depthBiasEnable ) - && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) - && ( depthBiasClamp == rhs.depthBiasClamp ) - && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) - && ( lineWidth == rhs.lineWidth ); - } - - bool operator!=( PipelineRasterizationStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineRasterizationStateCreateFlags flags; - Bool32 depthClampEnable; - Bool32 rasterizerDiscardEnable; - PolygonMode polygonMode; - CullModeFlags cullMode; - FrontFace frontFace; - Bool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; - }; - static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineDepthStencilStateCreateInfo - { - PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(), - Bool32 depthTestEnable_ = 0, - Bool32 depthWriteEnable_ = 0, - CompareOp depthCompareOp_ = CompareOp::eNever, - Bool32 depthBoundsTestEnable_ = 0, - Bool32 stencilTestEnable_ = 0, - StencilOpState front_ = StencilOpState(), - StencilOpState back_ = StencilOpState(), - float minDepthBounds_ = 0, - float maxDepthBounds_ = 0 ) - : flags( flags_ ) - , depthTestEnable( depthTestEnable_ ) - , depthWriteEnable( depthWriteEnable_ ) - , depthCompareOp( depthCompareOp_ ) - , depthBoundsTestEnable( depthBoundsTestEnable_ ) - , stencilTestEnable( stencilTestEnable_ ) - , front( front_ ) - , back( back_ ) - , minDepthBounds( minDepthBounds_ ) - , maxDepthBounds( maxDepthBounds_ ) - { - } - - PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); - } - - PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); - return *this; - } - PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setFlags( PipelineDepthStencilStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthTestEnable( Bool32 depthTestEnable_ ) - { - depthTestEnable = depthTestEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthWriteEnable( Bool32 depthWriteEnable_ ) - { - depthWriteEnable = depthWriteEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthCompareOp( CompareOp depthCompareOp_ ) - { - depthCompareOp = depthCompareOp_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ ) - { - depthBoundsTestEnable = depthBoundsTestEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setStencilTestEnable( Bool32 stencilTestEnable_ ) - { - stencilTestEnable = stencilTestEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setFront( StencilOpState front_ ) - { - front = front_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setBack( StencilOpState back_ ) - { - back = back_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setMinDepthBounds( float minDepthBounds_ ) - { - minDepthBounds = minDepthBounds_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setMaxDepthBounds( float maxDepthBounds_ ) - { - maxDepthBounds = maxDepthBounds_; - return *this; - } - - operator const VkPipelineDepthStencilStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( depthTestEnable == rhs.depthTestEnable ) - && ( depthWriteEnable == rhs.depthWriteEnable ) - && ( depthCompareOp == rhs.depthCompareOp ) - && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) - && ( stencilTestEnable == rhs.stencilTestEnable ) - && ( front == rhs.front ) - && ( back == rhs.back ) - && ( minDepthBounds == rhs.minDepthBounds ) - && ( maxDepthBounds == rhs.maxDepthBounds ); - } - - bool operator!=( PipelineDepthStencilStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineDepthStencilStateCreateFlags flags; - Bool32 depthTestEnable; - Bool32 depthWriteEnable; - CompareOp depthCompareOp; - Bool32 depthBoundsTestEnable; - Bool32 stencilTestEnable; - StencilOpState front; - StencilOpState back; - float minDepthBounds; - float maxDepthBounds; - }; - static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineCacheCreateInfo - { - PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), - size_t initialDataSize_ = 0, - const void* pInitialData_ = nullptr ) - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - { - } - - PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); - } - - PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); - return *this; - } - PipelineCacheCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineCacheCreateInfo& setFlags( PipelineCacheCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineCacheCreateInfo& setInitialDataSize( size_t initialDataSize_ ) - { - initialDataSize = initialDataSize_; - return *this; - } - - PipelineCacheCreateInfo& setPInitialData( const void* pInitialData_ ) - { - pInitialData = pInitialData_; - return *this; - } - - operator const VkPipelineCacheCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineCacheCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( initialDataSize == rhs.initialDataSize ) - && ( pInitialData == rhs.pInitialData ); - } - - bool operator!=( PipelineCacheCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineCacheCreateInfo; - - public: - const void* pNext = nullptr; - PipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" ); - - struct SamplerCreateInfo - { - SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), - Filter magFilter_ = Filter::eNearest, - Filter minFilter_ = Filter::eNearest, - SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, - SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, - SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, - SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, - float mipLodBias_ = 0, - Bool32 anisotropyEnable_ = 0, - float maxAnisotropy_ = 0, - Bool32 compareEnable_ = 0, - CompareOp compareOp_ = CompareOp::eNever, - float minLod_ = 0, - float maxLod_ = 0, - BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, - Bool32 unnormalizedCoordinates_ = 0 ) - : flags( flags_ ) - , magFilter( magFilter_ ) - , minFilter( minFilter_ ) - , mipmapMode( mipmapMode_ ) - , addressModeU( addressModeU_ ) - , addressModeV( addressModeV_ ) - , addressModeW( addressModeW_ ) - , mipLodBias( mipLodBias_ ) - , anisotropyEnable( anisotropyEnable_ ) - , maxAnisotropy( maxAnisotropy_ ) - , compareEnable( compareEnable_ ) - , compareOp( compareOp_ ) - , minLod( minLod_ ) - , maxLod( maxLod_ ) - , borderColor( borderColor_ ) - , unnormalizedCoordinates( unnormalizedCoordinates_ ) - { - } - - SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); - } - - SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); - return *this; - } - SamplerCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - SamplerCreateInfo& setMagFilter( Filter magFilter_ ) - { - magFilter = magFilter_; - return *this; - } - - SamplerCreateInfo& setMinFilter( Filter minFilter_ ) - { - minFilter = minFilter_; - return *this; - } - - SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ ) - { - mipmapMode = mipmapMode_; - return *this; - } - - SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ ) - { - addressModeU = addressModeU_; - return *this; - } - - SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ ) - { - addressModeV = addressModeV_; - return *this; - } - - SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ ) - { - addressModeW = addressModeW_; - return *this; - } - - SamplerCreateInfo& setMipLodBias( float mipLodBias_ ) - { - mipLodBias = mipLodBias_; - return *this; - } - - SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ ) - { - anisotropyEnable = anisotropyEnable_; - return *this; - } - - SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ ) - { - maxAnisotropy = maxAnisotropy_; - return *this; - } - - SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ ) - { - compareEnable = compareEnable_; - return *this; - } - - SamplerCreateInfo& setCompareOp( CompareOp compareOp_ ) - { - compareOp = compareOp_; - return *this; - } - - SamplerCreateInfo& setMinLod( float minLod_ ) - { - minLod = minLod_; - return *this; - } - - SamplerCreateInfo& setMaxLod( float maxLod_ ) - { - maxLod = maxLod_; - return *this; - } - - SamplerCreateInfo& setBorderColor( BorderColor borderColor_ ) - { - borderColor = borderColor_; - return *this; - } - - SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) - { - unnormalizedCoordinates = unnormalizedCoordinates_; - return *this; - } - - operator const VkSamplerCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SamplerCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( magFilter == rhs.magFilter ) - && ( minFilter == rhs.minFilter ) - && ( mipmapMode == rhs.mipmapMode ) - && ( addressModeU == rhs.addressModeU ) - && ( addressModeV == rhs.addressModeV ) - && ( addressModeW == rhs.addressModeW ) - && ( mipLodBias == rhs.mipLodBias ) - && ( anisotropyEnable == rhs.anisotropyEnable ) - && ( maxAnisotropy == rhs.maxAnisotropy ) - && ( compareEnable == rhs.compareEnable ) - && ( compareOp == rhs.compareOp ) - && ( minLod == rhs.minLod ) - && ( maxLod == rhs.maxLod ) - && ( borderColor == rhs.borderColor ) - && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); - } - - bool operator!=( SamplerCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerCreateInfo; - - public: - const void* pNext = nullptr; - SamplerCreateFlags flags; - Filter magFilter; - Filter minFilter; - SamplerMipmapMode mipmapMode; - SamplerAddressMode addressModeU; - SamplerAddressMode addressModeV; - SamplerAddressMode addressModeW; - float mipLodBias; - Bool32 anisotropyEnable; - float maxAnisotropy; - Bool32 compareEnable; - CompareOp compareOp; - float minLod; - float maxLod; - BorderColor borderColor; - Bool32 unnormalizedCoordinates; - }; - static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); - - struct CommandBufferAllocateInfo - { - CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), - CommandBufferLevel level_ = CommandBufferLevel::ePrimary, - uint32_t commandBufferCount_ = 0 ) - : commandPool( commandPool_ ) - , level( level_ ) - , commandBufferCount( commandBufferCount_ ) - { - } - - CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); - } - - CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); - return *this; - } - CommandBufferAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandBufferAllocateInfo& setCommandPool( CommandPool commandPool_ ) - { - commandPool = commandPool_; - return *this; - } - - CommandBufferAllocateInfo& setLevel( CommandBufferLevel level_ ) - { - level = level_; - return *this; - } - - CommandBufferAllocateInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) - { - commandBufferCount = commandBufferCount_; - return *this; - } - - operator const VkCommandBufferAllocateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( CommandBufferAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( commandPool == rhs.commandPool ) - && ( level == rhs.level ) - && ( commandBufferCount == rhs.commandBufferCount ); - } - - bool operator!=( CommandBufferAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandBufferAllocateInfo; - - public: - const void* pNext = nullptr; - CommandPool commandPool; - CommandBufferLevel level; - uint32_t commandBufferCount; - }; - static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" ); - - struct RenderPassBeginInfo - { - RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), - Framebuffer framebuffer_ = Framebuffer(), - Rect2D renderArea_ = Rect2D(), - uint32_t clearValueCount_ = 0, - const ClearValue* pClearValues_ = nullptr ) - : renderPass( renderPass_ ) - , framebuffer( framebuffer_ ) - , renderArea( renderArea_ ) - , clearValueCount( clearValueCount_ ) - , pClearValues( pClearValues_ ) - { - } - - RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); - } - - RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); - return *this; - } - RenderPassBeginInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassBeginInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - RenderPassBeginInfo& setFramebuffer( Framebuffer framebuffer_ ) - { - framebuffer = framebuffer_; - return *this; - } - - RenderPassBeginInfo& setRenderArea( Rect2D renderArea_ ) - { - renderArea = renderArea_; - return *this; - } - - RenderPassBeginInfo& setClearValueCount( uint32_t clearValueCount_ ) - { - clearValueCount = clearValueCount_; - return *this; - } - - RenderPassBeginInfo& setPClearValues( const ClearValue* pClearValues_ ) - { - pClearValues = pClearValues_; - return *this; - } - - operator const VkRenderPassBeginInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( RenderPassBeginInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( renderPass == rhs.renderPass ) - && ( framebuffer == rhs.framebuffer ) - && ( renderArea == rhs.renderArea ) - && ( clearValueCount == rhs.clearValueCount ) - && ( pClearValues == rhs.pClearValues ); - } - - bool operator!=( RenderPassBeginInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassBeginInfo; - - public: - const void* pNext = nullptr; - RenderPass renderPass; - Framebuffer framebuffer; - Rect2D renderArea; - uint32_t clearValueCount; - const ClearValue* pClearValues; - }; - static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); - - struct EventCreateInfo - { - EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() ) - : flags( flags_ ) - { - } - - EventCreateInfo( VkEventCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( EventCreateInfo ) ); - } - - EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( EventCreateInfo ) ); - return *this; - } - EventCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - EventCreateInfo& setFlags( EventCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkEventCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( EventCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ); - } - - bool operator!=( EventCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eEventCreateInfo; - - public: - const void* pNext = nullptr; - EventCreateFlags flags; - }; - static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); - - struct SemaphoreCreateInfo - { - SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() ) - : flags( flags_ ) - { - } - - SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); - } - - SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); - return *this; - } - SemaphoreCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SemaphoreCreateInfo& setFlags( SemaphoreCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkSemaphoreCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SemaphoreCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ); - } - - bool operator!=( SemaphoreCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSemaphoreCreateInfo; - - public: - const void* pNext = nullptr; - SemaphoreCreateFlags flags; - }; - static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); - - struct FramebufferCreateInfo - { - FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(), - RenderPass renderPass_ = RenderPass(), - uint32_t attachmentCount_ = 0, - const ImageView* pAttachments_ = nullptr, - uint32_t width_ = 0, - uint32_t height_ = 0, - uint32_t layers_ = 0 ) - : flags( flags_ ) - , renderPass( renderPass_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , width( width_ ) - , height( height_ ) - , layers( layers_ ) - { - } - - FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); - } - - FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); - return *this; - } - FramebufferCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FramebufferCreateInfo& setFlags( FramebufferCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - FramebufferCreateInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - FramebufferCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) - { - attachmentCount = attachmentCount_; - return *this; - } - - FramebufferCreateInfo& setPAttachments( const ImageView* pAttachments_ ) - { - pAttachments = pAttachments_; - return *this; - } - - FramebufferCreateInfo& setWidth( uint32_t width_ ) - { - width = width_; - return *this; - } - - FramebufferCreateInfo& setHeight( uint32_t height_ ) - { - height = height_; - return *this; - } - - FramebufferCreateInfo& setLayers( uint32_t layers_ ) - { - layers = layers_; - return *this; - } - - operator const VkFramebufferCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( FramebufferCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( renderPass == rhs.renderPass ) - && ( attachmentCount == rhs.attachmentCount ) - && ( pAttachments == rhs.pAttachments ) - && ( width == rhs.width ) - && ( height == rhs.height ) - && ( layers == rhs.layers ); - } - - bool operator!=( FramebufferCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFramebufferCreateInfo; - - public: - const void* pNext = nullptr; - FramebufferCreateFlags flags; - RenderPass renderPass; - uint32_t attachmentCount; - const ImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; - }; - static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" ); - - struct DisplayModeCreateInfoKHR - { - DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), - DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() ) - : flags( flags_ ) - , parameters( parameters_ ) - { - } - - DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); - } - - DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); - return *this; - } - DisplayModeCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayModeCreateInfoKHR& setFlags( DisplayModeCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - DisplayModeCreateInfoKHR& setParameters( DisplayModeParametersKHR parameters_ ) - { - parameters = parameters_; - return *this; - } - - operator const VkDisplayModeCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayModeCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( parameters == rhs.parameters ); - } - - bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayModeCreateInfoKHR; - - public: - const void* pNext = nullptr; - DisplayModeCreateFlagsKHR flags; - DisplayModeParametersKHR parameters; - }; - static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct DisplayPresentInfoKHR - { - DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), - Rect2D dstRect_ = Rect2D(), - Bool32 persistent_ = 0 ) - : srcRect( srcRect_ ) - , dstRect( dstRect_ ) - , persistent( persistent_ ) - { - } - - DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); - } - - DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); - return *this; - } - DisplayPresentInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayPresentInfoKHR& setSrcRect( Rect2D srcRect_ ) - { - srcRect = srcRect_; - return *this; - } - - DisplayPresentInfoKHR& setDstRect( Rect2D dstRect_ ) - { - dstRect = dstRect_; - return *this; - } - - DisplayPresentInfoKHR& setPersistent( Bool32 persistent_ ) - { - persistent = persistent_; - return *this; - } - - operator const VkDisplayPresentInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPresentInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcRect == rhs.srcRect ) - && ( dstRect == rhs.dstRect ) - && ( persistent == rhs.persistent ); - } - - bool operator!=( DisplayPresentInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayPresentInfoKHR; - - public: - const void* pNext = nullptr; - Rect2D srcRect; - Rect2D dstRect; - Bool32 persistent; - }; - static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - struct AndroidSurfaceCreateInfoKHR - { - AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), - struct ANativeWindow* window_ = nullptr ) - : flags( flags_ ) - , window( window_ ) - { - } - - AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); - } - - AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); - return *this; - } - AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - AndroidSurfaceCreateInfoKHR& setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - AndroidSurfaceCreateInfoKHR& setWindow( struct ANativeWindow* window_ ) - { - window = window_; - return *this; - } - - operator const VkAndroidSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( window == rhs.window ); - } - - bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - AndroidSurfaceCreateFlagsKHR flags; - struct ANativeWindow* window; - }; - static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - struct MirSurfaceCreateInfoKHR - { - MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), - MirConnection* connection_ = nullptr, - MirSurface* mirSurface_ = nullptr ) - : flags( flags_ ) - , connection( connection_ ) - , mirSurface( mirSurface_ ) - { - } - - MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); - } - - MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); - return *this; - } - MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MirSurfaceCreateInfoKHR& setFlags( MirSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - MirSurfaceCreateInfoKHR& setConnection( MirConnection* connection_ ) - { - connection = connection_; - return *this; - } - - MirSurfaceCreateInfoKHR& setMirSurface( MirSurface* mirSurface_ ) - { - mirSurface = mirSurface_; - return *this; - } - - operator const VkMirSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( connection == rhs.connection ) - && ( mirSurface == rhs.mirSurface ); - } - - bool operator!=( MirSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMirSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - MirSurfaceCreateFlagsKHR flags; - MirConnection* connection; - MirSurface* mirSurface; - }; - static_assert( sizeof( MirSurfaceCreateInfoKHR ) == sizeof( VkMirSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_VI_NN - struct ViSurfaceCreateInfoNN - { - ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(), - void* window_ = nullptr ) - : flags( flags_ ) - , window( window_ ) - { - } - - ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) - { - memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); - } - - ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) - { - memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); - return *this; - } - ViSurfaceCreateInfoNN& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ViSurfaceCreateInfoNN& setFlags( ViSurfaceCreateFlagsNN flags_ ) - { - flags = flags_; - return *this; - } - - ViSurfaceCreateInfoNN& setWindow( void* window_ ) - { - window = window_; - return *this; - } - - operator const VkViSurfaceCreateInfoNN&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ViSurfaceCreateInfoNN const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( window == rhs.window ); - } - - bool operator!=( ViSurfaceCreateInfoNN const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eViSurfaceCreateInfoNN; - - public: - const void* pNext = nullptr; - ViSurfaceCreateFlagsNN flags; - void* window; - }; - static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - struct WaylandSurfaceCreateInfoKHR - { - WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), - struct wl_display* display_ = nullptr, - struct wl_surface* surface_ = nullptr ) - : flags( flags_ ) - , display( display_ ) - , surface( surface_ ) - { - } - - WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); - } - - WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); - return *this; - } - WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - WaylandSurfaceCreateInfoKHR& setFlags( WaylandSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - WaylandSurfaceCreateInfoKHR& setDisplay( struct wl_display* display_ ) - { - display = display_; - return *this; - } - - WaylandSurfaceCreateInfoKHR& setSurface( struct wl_surface* surface_ ) - { - surface = surface_; - return *this; - } - - operator const VkWaylandSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( display == rhs.display ) - && ( surface == rhs.surface ); - } - - bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - WaylandSurfaceCreateFlagsKHR flags; - struct wl_display* display; - struct wl_surface* surface; - }; - static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct Win32SurfaceCreateInfoKHR - { - Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), - HINSTANCE hinstance_ = 0, - HWND hwnd_ = 0 ) - : flags( flags_ ) - , hinstance( hinstance_ ) - , hwnd( hwnd_ ) - { - } - - Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); - } - - Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); - return *this; - } - Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - Win32SurfaceCreateInfoKHR& setFlags( Win32SurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - Win32SurfaceCreateInfoKHR& setHinstance( HINSTANCE hinstance_ ) - { - hinstance = hinstance_; - return *this; - } - - Win32SurfaceCreateInfoKHR& setHwnd( HWND hwnd_ ) - { - hwnd = hwnd_; - return *this; - } - - operator const VkWin32SurfaceCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( hinstance == rhs.hinstance ) - && ( hwnd == rhs.hwnd ); - } - - bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - Win32SurfaceCreateFlagsKHR flags; - HINSTANCE hinstance; - HWND hwnd; - }; - static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - struct XlibSurfaceCreateInfoKHR - { - XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), - Display* dpy_ = nullptr, - Window window_ = 0 ) - : flags( flags_ ) - , dpy( dpy_ ) - , window( window_ ) - { - } - - XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); - } - - XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); - return *this; - } - XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - XlibSurfaceCreateInfoKHR& setFlags( XlibSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - XlibSurfaceCreateInfoKHR& setDpy( Display* dpy_ ) - { - dpy = dpy_; - return *this; - } - - XlibSurfaceCreateInfoKHR& setWindow( Window window_ ) - { - window = window_; - return *this; - } - - operator const VkXlibSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( dpy == rhs.dpy ) - && ( window == rhs.window ); - } - - bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - XlibSurfaceCreateFlagsKHR flags; - Display* dpy; - Window window; - }; - static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - struct XcbSurfaceCreateInfoKHR - { - XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), - xcb_connection_t* connection_ = nullptr, - xcb_window_t window_ = 0 ) - : flags( flags_ ) - , connection( connection_ ) - , window( window_ ) - { - } - - XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); - } - - XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); - return *this; - } - XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - XcbSurfaceCreateInfoKHR& setFlags( XcbSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - XcbSurfaceCreateInfoKHR& setConnection( xcb_connection_t* connection_ ) - { - connection = connection_; - return *this; - } - - XcbSurfaceCreateInfoKHR& setWindow( xcb_window_t window_ ) - { - window = window_; - return *this; - } - - operator const VkXcbSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( connection == rhs.connection ) - && ( window == rhs.window ); - } - - bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - XcbSurfaceCreateFlagsKHR flags; - xcb_connection_t* connection; - xcb_window_t window; - }; - static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - struct DebugMarkerMarkerInfoEXT - { - DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, - std::array const& color_ = { { 0, 0, 0, 0 } } ) - : pMarkerName( pMarkerName_ ) - { - memcpy( &color, color_.data(), 4 * sizeof( float ) ); - } - - DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); - } - - DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); - return *this; - } - DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugMarkerMarkerInfoEXT& setPMarkerName( const char* pMarkerName_ ) - { - pMarkerName = pMarkerName_; - return *this; - } - - DebugMarkerMarkerInfoEXT& setColor( std::array color_ ) - { - memcpy( &color, color_.data(), 4 * sizeof( float ) ); - return *this; - } - - operator const VkDebugMarkerMarkerInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pMarkerName == rhs.pMarkerName ) - && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 ); - } - - bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; - - public: - const void* pNext = nullptr; - const char* pMarkerName; - float color[4]; - }; - static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" ); - - struct DedicatedAllocationImageCreateInfoNV - { - DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) - : dedicatedAllocation( dedicatedAllocation_ ) - { - } - - DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); - } - - DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); - return *this; - } - DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DedicatedAllocationImageCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ ) - { - dedicatedAllocation = dedicatedAllocation_; - return *this; - } - - operator const VkDedicatedAllocationImageCreateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( dedicatedAllocation == rhs.dedicatedAllocation ); - } - - bool operator!=( DedicatedAllocationImageCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; - - public: - const void* pNext = nullptr; - Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" ); - - struct DedicatedAllocationBufferCreateInfoNV - { - DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) - : dedicatedAllocation( dedicatedAllocation_ ) - { - } - - DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); - } - - DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); - return *this; - } - DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DedicatedAllocationBufferCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ ) - { - dedicatedAllocation = dedicatedAllocation_; - return *this; - } - - operator const VkDedicatedAllocationBufferCreateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( dedicatedAllocation == rhs.dedicatedAllocation ); - } - - bool operator!=( DedicatedAllocationBufferCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; - - public: - const void* pNext = nullptr; - Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" ); - - struct DedicatedAllocationMemoryAllocateInfoNV - { - DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), - Buffer buffer_ = Buffer() ) - : image( image_ ) - , buffer( buffer_ ) - { - } - - DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); - } - - DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); - return *this; - } - DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DedicatedAllocationMemoryAllocateInfoNV& setImage( Image image_ ) - { - image = image_; - return *this; - } - - DedicatedAllocationMemoryAllocateInfoNV& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkDedicatedAllocationMemoryAllocateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; - - public: - const void* pNext = nullptr; - Image image; - Buffer buffer; - }; - static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_NV - struct ExportMemoryWin32HandleInfoNV - { - ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - { - } - - ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); - } - - ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); - return *this; - } - ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - operator const VkExportMemoryWin32HandleInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ); - } - - bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_NV*/ - -#ifdef VK_USE_PLATFORM_WIN32_NV - struct Win32KeyedMutexAcquireReleaseInfoNV - { - Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, - const DeviceMemory* pAcquireSyncs_ = nullptr, - const uint64_t* pAcquireKeys_ = nullptr, - const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, - uint32_t releaseCount_ = 0, - const DeviceMemory* pReleaseSyncs_ = nullptr, - const uint64_t* pReleaseKeys_ = nullptr ) - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - { - } - - Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); - } - - Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); - return *this; - } - Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ ) - { - acquireCount = acquireCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) - { - pAcquireSyncs = pAcquireSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) - { - pAcquireKeys = pAcquireKeys_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ ) - { - pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ ) - { - releaseCount = releaseCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) - { - pReleaseSyncs = pReleaseSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) - { - pReleaseKeys = pReleaseKeys_; - return *this; - } - - operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( acquireCount == rhs.acquireCount ) - && ( pAcquireSyncs == rhs.pAcquireSyncs ) - && ( pAcquireKeys == rhs.pAcquireKeys ) - && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) - && ( releaseCount == rhs.releaseCount ) - && ( pReleaseSyncs == rhs.pReleaseSyncs ) - && ( pReleaseKeys == rhs.pReleaseKeys ); - } - - bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; - - public: - const void* pNext = nullptr; - uint32_t acquireCount; - const DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeoutMilliseconds; - uint32_t releaseCount; - const DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_NV*/ - - struct DeviceGeneratedCommandsFeaturesNVX - { - DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 ) - : computeBindingPointSupport( computeBindingPointSupport_ ) - { - } - - DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); - } - - DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); - return *this; - } - DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGeneratedCommandsFeaturesNVX& setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ ) - { - computeBindingPointSupport = computeBindingPointSupport_; - return *this; - } - - operator const VkDeviceGeneratedCommandsFeaturesNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( computeBindingPointSupport == rhs.computeBindingPointSupport ); - } - - bool operator!=( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; - - public: - const void* pNext = nullptr; - Bool32 computeBindingPointSupport; - }; - static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" ); - - struct DeviceGeneratedCommandsLimitsNVX - { - DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, - uint32_t maxObjectEntryCounts_ = 0, - uint32_t minSequenceCountBufferOffsetAlignment_ = 0, - uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, - uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) - : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) - , maxObjectEntryCounts( maxObjectEntryCounts_ ) - , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) - , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) - , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ ) - { - } - - DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); - } - - DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); - return *this; - } - DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMaxIndirectCommandsLayoutTokenCount( uint32_t maxIndirectCommandsLayoutTokenCount_ ) - { - maxIndirectCommandsLayoutTokenCount = maxIndirectCommandsLayoutTokenCount_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMaxObjectEntryCounts( uint32_t maxObjectEntryCounts_ ) - { - maxObjectEntryCounts = maxObjectEntryCounts_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMinSequenceCountBufferOffsetAlignment( uint32_t minSequenceCountBufferOffsetAlignment_ ) - { - minSequenceCountBufferOffsetAlignment = minSequenceCountBufferOffsetAlignment_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMinSequenceIndexBufferOffsetAlignment( uint32_t minSequenceIndexBufferOffsetAlignment_ ) - { - minSequenceIndexBufferOffsetAlignment = minSequenceIndexBufferOffsetAlignment_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMinCommandsTokenBufferOffsetAlignment( uint32_t minCommandsTokenBufferOffsetAlignment_ ) - { - minCommandsTokenBufferOffsetAlignment = minCommandsTokenBufferOffsetAlignment_; - return *this; - } - - operator const VkDeviceGeneratedCommandsLimitsNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxIndirectCommandsLayoutTokenCount == rhs.maxIndirectCommandsLayoutTokenCount ) - && ( maxObjectEntryCounts == rhs.maxObjectEntryCounts ) - && ( minSequenceCountBufferOffsetAlignment == rhs.minSequenceCountBufferOffsetAlignment ) - && ( minSequenceIndexBufferOffsetAlignment == rhs.minSequenceIndexBufferOffsetAlignment ) - && ( minCommandsTokenBufferOffsetAlignment == rhs.minCommandsTokenBufferOffsetAlignment ); - } - - bool operator!=( DeviceGeneratedCommandsLimitsNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; - - public: - const void* pNext = nullptr; - uint32_t maxIndirectCommandsLayoutTokenCount; - uint32_t maxObjectEntryCounts; - uint32_t minSequenceCountBufferOffsetAlignment; - uint32_t minSequenceIndexBufferOffsetAlignment; - uint32_t minCommandsTokenBufferOffsetAlignment; - }; - static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" ); - - struct CmdReserveSpaceForCommandsInfoNVX - { - CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), - IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), - uint32_t maxSequencesCount_ = 0 ) - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , maxSequencesCount( maxSequencesCount_ ) - { - } - - CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); - } - - CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); - return *this; - } - CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CmdReserveSpaceForCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ ) - { - objectTable = objectTable_; - return *this; - } - - CmdReserveSpaceForCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ ) - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - CmdReserveSpaceForCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ ) - { - maxSequencesCount = maxSequencesCount_; - return *this; - } - - operator const VkCmdReserveSpaceForCommandsInfoNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectTable == rhs.objectTable ) - && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) - && ( maxSequencesCount == rhs.maxSequencesCount ); - } - - bool operator!=( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; - - public: - const void* pNext = nullptr; - ObjectTableNVX objectTable; - IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t maxSequencesCount; - }; - static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceFeatures2 - { - PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() ) - : features( features_ ) - { - } - - PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) ); - } - - PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) ); - return *this; - } - PhysicalDeviceFeatures2& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceFeatures2& setFeatures( PhysicalDeviceFeatures features_ ) - { - features = features_; - return *this; - } - - operator const VkPhysicalDeviceFeatures2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceFeatures2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( features == rhs.features ); - } - - bool operator!=( PhysicalDeviceFeatures2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceFeatures2; - - public: - void* pNext = nullptr; - PhysicalDeviceFeatures features; - }; - static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" ); - - using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; - - struct PhysicalDevicePushDescriptorPropertiesKHR - { - PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 ) - : maxPushDescriptors( maxPushDescriptors_ ) - { - } - - PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); - } - - PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); - return *this; - } - PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDevicePushDescriptorPropertiesKHR& setMaxPushDescriptors( uint32_t maxPushDescriptors_ ) - { - maxPushDescriptors = maxPushDescriptors_; - return *this; - } - - operator const VkPhysicalDevicePushDescriptorPropertiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxPushDescriptors == rhs.maxPushDescriptors ); - } - - bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; - - public: - void* pNext = nullptr; - uint32_t maxPushDescriptors; - }; - static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" ); - - struct PresentRegionsKHR - { - PresentRegionsKHR( uint32_t swapchainCount_ = 0, - const PresentRegionKHR* pRegions_ = nullptr ) - : swapchainCount( swapchainCount_ ) - , pRegions( pRegions_ ) - { - } - - PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); - } - - PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); - return *this; - } - PresentRegionsKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PresentRegionsKHR& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - PresentRegionsKHR& setPRegions( const PresentRegionKHR* pRegions_ ) - { - pRegions = pRegions_; - return *this; - } - - operator const VkPresentRegionsKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PresentRegionsKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pRegions == rhs.pRegions ); - } - - bool operator!=( PresentRegionsKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePresentRegionsKHR; - - public: - const void* pNext = nullptr; - uint32_t swapchainCount; - const PresentRegionKHR* pRegions; - }; - static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceVariablePointerFeatures - { - PhysicalDeviceVariablePointerFeatures( Bool32 variablePointersStorageBuffer_ = 0, - Bool32 variablePointers_ = 0 ) - : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) - , variablePointers( variablePointers_ ) - { - } - - PhysicalDeviceVariablePointerFeatures( VkPhysicalDeviceVariablePointerFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) ); - } - - PhysicalDeviceVariablePointerFeatures& operator=( VkPhysicalDeviceVariablePointerFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) ); - return *this; - } - PhysicalDeviceVariablePointerFeatures& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceVariablePointerFeatures& setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) - { - variablePointersStorageBuffer = variablePointersStorageBuffer_; - return *this; - } - - PhysicalDeviceVariablePointerFeatures& setVariablePointers( Bool32 variablePointers_ ) - { - variablePointers = variablePointers_; - return *this; - } - - operator const VkPhysicalDeviceVariablePointerFeatures&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceVariablePointerFeatures const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) - && ( variablePointers == rhs.variablePointers ); - } - - bool operator!=( PhysicalDeviceVariablePointerFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeatures; - - public: - void* pNext = nullptr; - Bool32 variablePointersStorageBuffer; - Bool32 variablePointers; - }; - static_assert( sizeof( PhysicalDeviceVariablePointerFeatures ) == sizeof( VkPhysicalDeviceVariablePointerFeatures ), "struct and wrapper have different size!" ); - - using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointerFeatures; - - struct PhysicalDeviceIDProperties - { - operator const VkPhysicalDeviceIDProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceIDProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( deviceNodeMask == rhs.deviceNodeMask ) - && ( deviceLUIDValid == rhs.deviceLUIDValid ); - } - - bool operator!=( PhysicalDeviceIDProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceIdProperties; - - public: - void* pNext = nullptr; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - Bool32 deviceLUIDValid; - }; - static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" ); - - using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ExportMemoryWin32HandleInfoKHR - { - ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - { - } - - ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); - } - - ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); - return *this; - } - ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkExportMemoryWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ) - && ( name == rhs.name ); - } - - bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct MemoryWin32HandlePropertiesKHR - { - operator const VkMemoryWin32HandlePropertiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; - - public: - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct MemoryFdPropertiesKHR - { - operator const VkMemoryFdPropertiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryFdPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryFdPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryFdPropertiesKHR; - - public: - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct Win32KeyedMutexAcquireReleaseInfoKHR - { - Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, - const DeviceMemory* pAcquireSyncs_ = nullptr, - const uint64_t* pAcquireKeys_ = nullptr, - const uint32_t* pAcquireTimeouts_ = nullptr, - uint32_t releaseCount_ = 0, - const DeviceMemory* pReleaseSyncs_ = nullptr, - const uint64_t* pReleaseKeys_ = nullptr ) - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeouts( pAcquireTimeouts_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - { - } - - Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); - } - - Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); - return *this; - } - Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ ) - { - acquireCount = acquireCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) - { - pAcquireSyncs = pAcquireSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) - { - pAcquireKeys = pAcquireKeys_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ ) - { - pAcquireTimeouts = pAcquireTimeouts_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ ) - { - releaseCount = releaseCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) - { - pReleaseSyncs = pReleaseSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) - { - pReleaseKeys = pReleaseKeys_; - return *this; - } - - operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( acquireCount == rhs.acquireCount ) - && ( pAcquireSyncs == rhs.pAcquireSyncs ) - && ( pAcquireKeys == rhs.pAcquireKeys ) - && ( pAcquireTimeouts == rhs.pAcquireTimeouts ) - && ( releaseCount == rhs.releaseCount ) - && ( pReleaseSyncs == rhs.pReleaseSyncs ) - && ( pReleaseKeys == rhs.pReleaseKeys ); - } - - bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t acquireCount; - const DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeouts; - uint32_t releaseCount; - const DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ExportSemaphoreWin32HandleInfoKHR - { - ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - { - } - - ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); - } - - ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); - return *this; - } - ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkExportSemaphoreWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ) - && ( name == rhs.name ); - } - - bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct D3D12FenceSubmitInfoKHR - { - D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, - const uint64_t* pWaitSemaphoreValues_ = nullptr, - uint32_t signalSemaphoreValuesCount_ = 0, - const uint64_t* pSignalSemaphoreValues_ = nullptr ) - : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) - , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) - , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) - , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) - { - } - - D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); - } - - D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); - return *this; - } - D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) - { - waitSemaphoreValuesCount = waitSemaphoreValuesCount_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ ) - { - pWaitSemaphoreValues = pWaitSemaphoreValues_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) - { - signalSemaphoreValuesCount = signalSemaphoreValuesCount_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ ) - { - pSignalSemaphoreValues = pSignalSemaphoreValues_; - return *this; - } - - operator const VkD3D12FenceSubmitInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) - && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) - && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) - && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); - } - - bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues; - }; - static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ExportFenceWin32HandleInfoKHR - { - ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - { - } - - ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); - } - - ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); - return *this; - } - ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkExportFenceWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ) - && ( name == rhs.name ); - } - - bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct PhysicalDeviceMultiviewFeatures - { - PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = 0, - Bool32 multiviewGeometryShader_ = 0, - Bool32 multiviewTessellationShader_ = 0 ) - : multiview( multiview_ ) - , multiviewGeometryShader( multiviewGeometryShader_ ) - , multiviewTessellationShader( multiviewTessellationShader_ ) - { - } - - PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) ); - } - - PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) ); - return *this; - } - PhysicalDeviceMultiviewFeatures& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceMultiviewFeatures& setMultiview( Bool32 multiview_ ) - { - multiview = multiview_; - return *this; - } - - PhysicalDeviceMultiviewFeatures& setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) - { - multiviewGeometryShader = multiviewGeometryShader_; - return *this; - } - - PhysicalDeviceMultiviewFeatures& setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) - { - multiviewTessellationShader = multiviewTessellationShader_; - return *this; - } - - operator const VkPhysicalDeviceMultiviewFeatures&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceMultiviewFeatures const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( multiview == rhs.multiview ) - && ( multiviewGeometryShader == rhs.multiviewGeometryShader ) - && ( multiviewTessellationShader == rhs.multiviewTessellationShader ); - } - - bool operator!=( PhysicalDeviceMultiviewFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; - - public: - void* pNext = nullptr; - Bool32 multiview; - Bool32 multiviewGeometryShader; - Bool32 multiviewTessellationShader; - }; - static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" ); - - using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; - - struct PhysicalDeviceMultiviewProperties - { - operator const VkPhysicalDeviceMultiviewProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceMultiviewProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) - && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); - } - - bool operator!=( PhysicalDeviceMultiviewProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; - - public: - void* pNext = nullptr; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - }; - static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" ); - - using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; - - struct RenderPassMultiviewCreateInfo - { - RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0, - const uint32_t* pViewMasks_ = nullptr, - uint32_t dependencyCount_ = 0, - const int32_t* pViewOffsets_ = nullptr, - uint32_t correlationMaskCount_ = 0, - const uint32_t* pCorrelationMasks_ = nullptr ) - : subpassCount( subpassCount_ ) - , pViewMasks( pViewMasks_ ) - , dependencyCount( dependencyCount_ ) - , pViewOffsets( pViewOffsets_ ) - , correlationMaskCount( correlationMaskCount_ ) - , pCorrelationMasks( pCorrelationMasks_ ) - { - } - - RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) ); - } - - RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) ); - return *this; - } - RenderPassMultiviewCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassMultiviewCreateInfo& setSubpassCount( uint32_t subpassCount_ ) - { - subpassCount = subpassCount_; - return *this; - } - - RenderPassMultiviewCreateInfo& setPViewMasks( const uint32_t* pViewMasks_ ) - { - pViewMasks = pViewMasks_; - return *this; - } - - RenderPassMultiviewCreateInfo& setDependencyCount( uint32_t dependencyCount_ ) - { - dependencyCount = dependencyCount_; - return *this; - } - - RenderPassMultiviewCreateInfo& setPViewOffsets( const int32_t* pViewOffsets_ ) - { - pViewOffsets = pViewOffsets_; - return *this; - } - - RenderPassMultiviewCreateInfo& setCorrelationMaskCount( uint32_t correlationMaskCount_ ) - { - correlationMaskCount = correlationMaskCount_; - return *this; - } - - RenderPassMultiviewCreateInfo& setPCorrelationMasks( const uint32_t* pCorrelationMasks_ ) - { - pCorrelationMasks = pCorrelationMasks_; - return *this; - } - - operator const VkRenderPassMultiviewCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( RenderPassMultiviewCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( subpassCount == rhs.subpassCount ) - && ( pViewMasks == rhs.pViewMasks ) - && ( dependencyCount == rhs.dependencyCount ) - && ( pViewOffsets == rhs.pViewOffsets ) - && ( correlationMaskCount == rhs.correlationMaskCount ) - && ( pCorrelationMasks == rhs.pCorrelationMasks ); - } - - bool operator!=( RenderPassMultiviewCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; - - public: - const void* pNext = nullptr; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; - }; - static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" ); - - using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; - - struct BindBufferMemoryInfo - { - BindBufferMemoryInfo( Buffer buffer_ = Buffer(), - DeviceMemory memory_ = DeviceMemory(), - DeviceSize memoryOffset_ = 0 ) - : buffer( buffer_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - { - } - - BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) ); - } - - BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) ); - return *this; - } - BindBufferMemoryInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindBufferMemoryInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - BindBufferMemoryInfo& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - BindBufferMemoryInfo& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - operator const VkBindBufferMemoryInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BindBufferMemoryInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( buffer == rhs.buffer ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ); - } - - bool operator!=( BindBufferMemoryInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindBufferMemoryInfo; - - public: - const void* pNext = nullptr; - Buffer buffer; - DeviceMemory memory; - DeviceSize memoryOffset; - }; - static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" ); - - using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; - - struct BindBufferMemoryDeviceGroupInfo - { - BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr ) - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - { - } - - BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) ); - } - - BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) ); - return *this; - } - BindBufferMemoryDeviceGroupInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindBufferMemoryDeviceGroupInfo& setDeviceIndexCount( uint32_t deviceIndexCount_ ) - { - deviceIndexCount = deviceIndexCount_; - return *this; - } - - BindBufferMemoryDeviceGroupInfo& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) - { - pDeviceIndices = pDeviceIndices_; - return *this; - } - - operator const VkBindBufferMemoryDeviceGroupInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BindBufferMemoryDeviceGroupInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceIndexCount == rhs.deviceIndexCount ) - && ( pDeviceIndices == rhs.pDeviceIndices ); - } - - bool operator!=( BindBufferMemoryDeviceGroupInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; - - public: - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - }; - static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); - - using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; - - struct BindImageMemoryInfo - { - BindImageMemoryInfo( Image image_ = Image(), - DeviceMemory memory_ = DeviceMemory(), - DeviceSize memoryOffset_ = 0 ) - : image( image_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - { - } - - BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) ); - } - - BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) ); - return *this; - } - BindImageMemoryInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImageMemoryInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - BindImageMemoryInfo& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - BindImageMemoryInfo& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - operator const VkBindImageMemoryInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BindImageMemoryInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ); - } - - bool operator!=( BindImageMemoryInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImageMemoryInfo; - - public: - const void* pNext = nullptr; - Image image; - DeviceMemory memory; - DeviceSize memoryOffset; - }; - static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" ); - - using BindImageMemoryInfoKHR = BindImageMemoryInfo; - - struct BindImageMemoryDeviceGroupInfo - { - BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr, - uint32_t splitInstanceBindRegionCount_ = 0, - const Rect2D* pSplitInstanceBindRegions_ = nullptr ) - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ ) - , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ ) - { - } - - BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) ); - } - - BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) ); - return *this; - } - BindImageMemoryDeviceGroupInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImageMemoryDeviceGroupInfo& setDeviceIndexCount( uint32_t deviceIndexCount_ ) - { - deviceIndexCount = deviceIndexCount_; - return *this; - } - - BindImageMemoryDeviceGroupInfo& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) - { - pDeviceIndices = pDeviceIndices_; - return *this; - } - - BindImageMemoryDeviceGroupInfo& setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) - { - splitInstanceBindRegionCount = splitInstanceBindRegionCount_; - return *this; - } - - BindImageMemoryDeviceGroupInfo& setPSplitInstanceBindRegions( const Rect2D* pSplitInstanceBindRegions_ ) - { - pSplitInstanceBindRegions = pSplitInstanceBindRegions_; - return *this; - } - - operator const VkBindImageMemoryDeviceGroupInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BindImageMemoryDeviceGroupInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceIndexCount == rhs.deviceIndexCount ) - && ( pDeviceIndices == rhs.pDeviceIndices ) - && ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) - && ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions ); - } - - bool operator!=( BindImageMemoryDeviceGroupInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; - - public: - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const Rect2D* pSplitInstanceBindRegions; - }; - static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); - - using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; - - struct DeviceGroupRenderPassBeginInfo - { - DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0, - uint32_t deviceRenderAreaCount_ = 0, - const Rect2D* pDeviceRenderAreas_ = nullptr ) - : deviceMask( deviceMask_ ) - , deviceRenderAreaCount( deviceRenderAreaCount_ ) - , pDeviceRenderAreas( pDeviceRenderAreas_ ) - { - } - - DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) ); - } - - DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) ); - return *this; - } - DeviceGroupRenderPassBeginInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupRenderPassBeginInfo& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - DeviceGroupRenderPassBeginInfo& setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ ) - { - deviceRenderAreaCount = deviceRenderAreaCount_; - return *this; - } - - DeviceGroupRenderPassBeginInfo& setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ ) - { - pDeviceRenderAreas = pDeviceRenderAreas_; - return *this; - } - - operator const VkDeviceGroupRenderPassBeginInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupRenderPassBeginInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceMask == rhs.deviceMask ) - && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) - && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); - } - - bool operator!=( DeviceGroupRenderPassBeginInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; - - public: - const void* pNext = nullptr; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const Rect2D* pDeviceRenderAreas; - }; - static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" ); - - using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; - - struct DeviceGroupCommandBufferBeginInfo - { - DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) - : deviceMask( deviceMask_ ) - { - } - - DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) ); - } - - DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) ); - return *this; - } - DeviceGroupCommandBufferBeginInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupCommandBufferBeginInfo& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - operator const VkDeviceGroupCommandBufferBeginInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupCommandBufferBeginInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceMask == rhs.deviceMask ); - } - - bool operator!=( DeviceGroupCommandBufferBeginInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; - - public: - const void* pNext = nullptr; - uint32_t deviceMask; - }; - static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" ); - - using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; - - struct DeviceGroupSubmitInfo - { - DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0, - const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, - uint32_t commandBufferCount_ = 0, - const uint32_t* pCommandBufferDeviceMasks_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ ) - { - } - - DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) ); - } - - DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) ); - return *this; - } - DeviceGroupSubmitInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupSubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - DeviceGroupSubmitInfo& setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ ) - { - pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_; - return *this; - } - - DeviceGroupSubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) - { - commandBufferCount = commandBufferCount_; - return *this; - } - - DeviceGroupSubmitInfo& setPCommandBufferDeviceMasks( const uint32_t* pCommandBufferDeviceMasks_ ) - { - pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_; - return *this; - } - - DeviceGroupSubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - DeviceGroupSubmitInfo& setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ ) - { - pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_; - return *this; - } - - operator const VkDeviceGroupSubmitInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupSubmitInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) - && ( commandBufferCount == rhs.commandBufferCount ) - && ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) - && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) - && ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices ); - } - - bool operator!=( DeviceGroupSubmitInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupSubmitInfo; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; - }; - static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" ); - - using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; - - struct DeviceGroupBindSparseInfo - { - DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0, - uint32_t memoryDeviceIndex_ = 0 ) - : resourceDeviceIndex( resourceDeviceIndex_ ) - , memoryDeviceIndex( memoryDeviceIndex_ ) - { - } - - DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) ); - } - - DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) ); - return *this; - } - DeviceGroupBindSparseInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupBindSparseInfo& setResourceDeviceIndex( uint32_t resourceDeviceIndex_ ) - { - resourceDeviceIndex = resourceDeviceIndex_; - return *this; - } - - DeviceGroupBindSparseInfo& setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ ) - { - memoryDeviceIndex = memoryDeviceIndex_; - return *this; - } - - operator const VkDeviceGroupBindSparseInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupBindSparseInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) - && ( memoryDeviceIndex == rhs.memoryDeviceIndex ); - } - - bool operator!=( DeviceGroupBindSparseInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupBindSparseInfo; - - public: - const void* pNext = nullptr; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; - }; - static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" ); - - using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; - - struct ImageSwapchainCreateInfoKHR - { - ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR() ) - : swapchain( swapchain_ ) - { - } - - ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) ); - } - - ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) ); - return *this; - } - ImageSwapchainCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageSwapchainCreateInfoKHR& setSwapchain( SwapchainKHR swapchain_ ) - { - swapchain = swapchain_; - return *this; - } - - operator const VkImageSwapchainCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageSwapchainCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchain == rhs.swapchain ); - } - - bool operator!=( ImageSwapchainCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; - - public: - const void* pNext = nullptr; - SwapchainKHR swapchain; - }; - static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct BindImageMemorySwapchainInfoKHR - { - BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(), - uint32_t imageIndex_ = 0 ) - : swapchain( swapchain_ ) - , imageIndex( imageIndex_ ) - { - } - - BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) ); - } - - BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) ); - return *this; - } - BindImageMemorySwapchainInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImageMemorySwapchainInfoKHR& setSwapchain( SwapchainKHR swapchain_ ) - { - swapchain = swapchain_; - return *this; - } - - BindImageMemorySwapchainInfoKHR& setImageIndex( uint32_t imageIndex_ ) - { - imageIndex = imageIndex_; - return *this; - } - - operator const VkBindImageMemorySwapchainInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BindImageMemorySwapchainInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchain == rhs.swapchain ) - && ( imageIndex == rhs.imageIndex ); - } - - bool operator!=( BindImageMemorySwapchainInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; - - public: - const void* pNext = nullptr; - SwapchainKHR swapchain; - uint32_t imageIndex; - }; - static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" ); - - struct AcquireNextImageInfoKHR - { - AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(), - uint64_t timeout_ = 0, - Semaphore semaphore_ = Semaphore(), - Fence fence_ = Fence(), - uint32_t deviceMask_ = 0 ) - : swapchain( swapchain_ ) - , timeout( timeout_ ) - , semaphore( semaphore_ ) - , fence( fence_ ) - , deviceMask( deviceMask_ ) - { - } - - AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) ); - } - - AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) ); - return *this; - } - AcquireNextImageInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - AcquireNextImageInfoKHR& setSwapchain( SwapchainKHR swapchain_ ) - { - swapchain = swapchain_; - return *this; - } - - AcquireNextImageInfoKHR& setTimeout( uint64_t timeout_ ) - { - timeout = timeout_; - return *this; - } - - AcquireNextImageInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - AcquireNextImageInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - AcquireNextImageInfoKHR& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - operator const VkAcquireNextImageInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AcquireNextImageInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchain == rhs.swapchain ) - && ( timeout == rhs.timeout ) - && ( semaphore == rhs.semaphore ) - && ( fence == rhs.fence ) - && ( deviceMask == rhs.deviceMask ); - } - - bool operator!=( AcquireNextImageInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAcquireNextImageInfoKHR; - - public: - const void* pNext = nullptr; - SwapchainKHR swapchain; - uint64_t timeout; - Semaphore semaphore; - Fence fence; - uint32_t deviceMask; - }; - static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" ); - - struct HdrMetadataEXT - { - HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(), - XYColorEXT displayPrimaryGreen_ = XYColorEXT(), - XYColorEXT displayPrimaryBlue_ = XYColorEXT(), - XYColorEXT whitePoint_ = XYColorEXT(), - float maxLuminance_ = 0, - float minLuminance_ = 0, - float maxContentLightLevel_ = 0, - float maxFrameAverageLightLevel_ = 0 ) - : displayPrimaryRed( displayPrimaryRed_ ) - , displayPrimaryGreen( displayPrimaryGreen_ ) - , displayPrimaryBlue( displayPrimaryBlue_ ) - , whitePoint( whitePoint_ ) - , maxLuminance( maxLuminance_ ) - , minLuminance( minLuminance_ ) - , maxContentLightLevel( maxContentLightLevel_ ) - , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ ) - { - } - - HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); - } - - HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); - return *this; - } - HdrMetadataEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - HdrMetadataEXT& setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ ) - { - displayPrimaryRed = displayPrimaryRed_; - return *this; - } - - HdrMetadataEXT& setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ ) - { - displayPrimaryGreen = displayPrimaryGreen_; - return *this; - } - - HdrMetadataEXT& setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ ) - { - displayPrimaryBlue = displayPrimaryBlue_; - return *this; - } - - HdrMetadataEXT& setWhitePoint( XYColorEXT whitePoint_ ) - { - whitePoint = whitePoint_; - return *this; - } - - HdrMetadataEXT& setMaxLuminance( float maxLuminance_ ) - { - maxLuminance = maxLuminance_; - return *this; - } - - HdrMetadataEXT& setMinLuminance( float minLuminance_ ) - { - minLuminance = minLuminance_; - return *this; - } - - HdrMetadataEXT& setMaxContentLightLevel( float maxContentLightLevel_ ) - { - maxContentLightLevel = maxContentLightLevel_; - return *this; - } - - HdrMetadataEXT& setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) - { - maxFrameAverageLightLevel = maxFrameAverageLightLevel_; - return *this; - } - - operator const VkHdrMetadataEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( HdrMetadataEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( displayPrimaryRed == rhs.displayPrimaryRed ) - && ( displayPrimaryGreen == rhs.displayPrimaryGreen ) - && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) - && ( whitePoint == rhs.whitePoint ) - && ( maxLuminance == rhs.maxLuminance ) - && ( minLuminance == rhs.minLuminance ) - && ( maxContentLightLevel == rhs.maxContentLightLevel ) - && ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel ); - } - - bool operator!=( HdrMetadataEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eHdrMetadataEXT; - - public: - const void* pNext = nullptr; - XYColorEXT displayPrimaryRed; - XYColorEXT displayPrimaryGreen; - XYColorEXT displayPrimaryBlue; - XYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; - }; - static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); - - struct PresentTimesInfoGOOGLE - { - PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, - const PresentTimeGOOGLE* pTimes_ = nullptr ) - : swapchainCount( swapchainCount_ ) - , pTimes( pTimes_ ) - { - } - - PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); - } - - PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); - return *this; - } - PresentTimesInfoGOOGLE& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PresentTimesInfoGOOGLE& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - PresentTimesInfoGOOGLE& setPTimes( const PresentTimeGOOGLE* pTimes_ ) - { - pTimes = pTimes_; - return *this; - } - - operator const VkPresentTimesInfoGOOGLE&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PresentTimesInfoGOOGLE const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pTimes == rhs.pTimes ); - } - - bool operator!=( PresentTimesInfoGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePresentTimesInfoGOOGLE; - - public: - const void* pNext = nullptr; - uint32_t swapchainCount; - const PresentTimeGOOGLE* pTimes; - }; - static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_IOS_MVK - struct IOSSurfaceCreateInfoMVK - { - IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), - const void* pView_ = nullptr ) - : flags( flags_ ) - , pView( pView_ ) - { - } - - IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); - } - - IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); - return *this; - } - IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - IOSSurfaceCreateInfoMVK& setFlags( IOSSurfaceCreateFlagsMVK flags_ ) - { - flags = flags_; - return *this; - } - - IOSSurfaceCreateInfoMVK& setPView( const void* pView_ ) - { - pView = pView_; - return *this; - } - - operator const VkIOSSurfaceCreateInfoMVK&() const - { - return *reinterpret_cast(this); - } - - bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pView == rhs.pView ); - } - - bool operator!=( IOSSurfaceCreateInfoMVK const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; - - public: - const void* pNext = nullptr; - IOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - struct MacOSSurfaceCreateInfoMVK - { - MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), - const void* pView_ = nullptr ) - : flags( flags_ ) - , pView( pView_ ) - { - } - - MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); - } - - MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); - return *this; - } - MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MacOSSurfaceCreateInfoMVK& setFlags( MacOSSurfaceCreateFlagsMVK flags_ ) - { - flags = flags_; - return *this; - } - - MacOSSurfaceCreateInfoMVK& setPView( const void* pView_ ) - { - pView = pView_; - return *this; - } - - operator const VkMacOSSurfaceCreateInfoMVK&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pView == rhs.pView ); - } - - bool operator!=( MacOSSurfaceCreateInfoMVK const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; - - public: - const void* pNext = nullptr; - MacOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - struct PipelineViewportWScalingStateCreateInfoNV - { - PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, - uint32_t viewportCount_ = 0, - const ViewportWScalingNV* pViewportWScalings_ = nullptr ) - : viewportWScalingEnable( viewportWScalingEnable_ ) - , viewportCount( viewportCount_ ) - , pViewportWScalings( pViewportWScalings_ ) - { - } - - PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); - } - - PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); - return *this; - } - PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineViewportWScalingStateCreateInfoNV& setViewportWScalingEnable( Bool32 viewportWScalingEnable_ ) - { - viewportWScalingEnable = viewportWScalingEnable_; - return *this; - } - - PipelineViewportWScalingStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ ) - { - viewportCount = viewportCount_; - return *this; - } - - PipelineViewportWScalingStateCreateInfoNV& setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ ) - { - pViewportWScalings = pViewportWScalings_; - return *this; - } - - operator const VkPipelineViewportWScalingStateCreateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( viewportWScalingEnable == rhs.viewportWScalingEnable ) - && ( viewportCount == rhs.viewportCount ) - && ( pViewportWScalings == rhs.pViewportWScalings ); - } - - bool operator!=( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; - - public: - const void* pNext = nullptr; - Bool32 viewportWScalingEnable; - uint32_t viewportCount; - const ViewportWScalingNV* pViewportWScalings; - }; - static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceDiscardRectanglePropertiesEXT - { - PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 ) - : maxDiscardRectangles( maxDiscardRectangles_ ) - { - } - - PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); - } - - PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); - return *this; - } - PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceDiscardRectanglePropertiesEXT& setMaxDiscardRectangles( uint32_t maxDiscardRectangles_ ) - { - maxDiscardRectangles = maxDiscardRectangles_; - return *this; - } - - operator const VkPhysicalDeviceDiscardRectanglePropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); - } - - bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t maxDiscardRectangles; - }; - static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX - { - operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); - } - - bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - - public: - void* pNext = nullptr; - Bool32 perViewPositionAllComponents; - }; - static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSurfaceInfo2KHR - { - PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() ) - : surface( surface_ ) - { - } - - PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); - } - - PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); - return *this; - } - PhysicalDeviceSurfaceInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceSurfaceInfo2KHR& setSurface( SurfaceKHR surface_ ) - { - surface = surface_; - return *this; - } - - operator const VkPhysicalDeviceSurfaceInfo2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surface == rhs.surface ); - } - - bool operator!=( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; - - public: - const void* pNext = nullptr; - SurfaceKHR surface; - }; - static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); - - struct DisplayPlaneProperties2KHR - { - operator const VkDisplayPlaneProperties2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPlaneProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( displayPlaneProperties == rhs.displayPlaneProperties ); - } - - bool operator!=( DisplayPlaneProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayPlaneProperties2KHR; - - public: - void* pNext = nullptr; - DisplayPlanePropertiesKHR displayPlaneProperties; - }; - static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" ); - - struct DisplayModeProperties2KHR - { - operator const VkDisplayModeProperties2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayModeProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( displayModeProperties == rhs.displayModeProperties ); - } - - bool operator!=( DisplayModeProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayModeProperties2KHR; - - public: - void* pNext = nullptr; - DisplayModePropertiesKHR displayModeProperties; - }; - static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" ); - - struct DisplayPlaneInfo2KHR - { - DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = DisplayModeKHR(), - uint32_t planeIndex_ = 0 ) - : mode( mode_ ) - , planeIndex( planeIndex_ ) - { - } - - DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) ); - } - - DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) ); - return *this; - } - DisplayPlaneInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayPlaneInfo2KHR& setMode( DisplayModeKHR mode_ ) - { - mode = mode_; - return *this; - } - - DisplayPlaneInfo2KHR& setPlaneIndex( uint32_t planeIndex_ ) - { - planeIndex = planeIndex_; - return *this; - } - - operator const VkDisplayPlaneInfo2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPlaneInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( mode == rhs.mode ) - && ( planeIndex == rhs.planeIndex ); - } - - bool operator!=( DisplayPlaneInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayPlaneInfo2KHR; - - public: - const void* pNext = nullptr; - DisplayModeKHR mode; - uint32_t planeIndex; - }; - static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" ); - - struct PhysicalDevice16BitStorageFeatures - { - PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = 0, - Bool32 uniformAndStorageBuffer16BitAccess_ = 0, - Bool32 storagePushConstant16_ = 0, - Bool32 storageInputOutput16_ = 0 ) - : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) - , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) - , storagePushConstant16( storagePushConstant16_ ) - , storageInputOutput16( storageInputOutput16_ ) - { - } - - PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) ); - } - - PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) ); - return *this; - } - PhysicalDevice16BitStorageFeatures& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDevice16BitStorageFeatures& setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) - { - storageBuffer16BitAccess = storageBuffer16BitAccess_; - return *this; - } - - PhysicalDevice16BitStorageFeatures& setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) - { - uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; - return *this; - } - - PhysicalDevice16BitStorageFeatures& setStoragePushConstant16( Bool32 storagePushConstant16_ ) - { - storagePushConstant16 = storagePushConstant16_; - return *this; - } - - PhysicalDevice16BitStorageFeatures& setStorageInputOutput16( Bool32 storageInputOutput16_ ) - { - storageInputOutput16 = storageInputOutput16_; - return *this; - } - - operator const VkPhysicalDevice16BitStorageFeatures&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDevice16BitStorageFeatures const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) - && ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) - && ( storagePushConstant16 == rhs.storagePushConstant16 ) - && ( storageInputOutput16 == rhs.storageInputOutput16 ); - } - - bool operator!=( PhysicalDevice16BitStorageFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; - - public: - void* pNext = nullptr; - Bool32 storageBuffer16BitAccess; - Bool32 uniformAndStorageBuffer16BitAccess; - Bool32 storagePushConstant16; - Bool32 storageInputOutput16; - }; - static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" ); - - using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; - - struct BufferMemoryRequirementsInfo2 - { - BufferMemoryRequirementsInfo2( Buffer buffer_ = Buffer() ) - : buffer( buffer_ ) - { - } - - BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) ); - } - - BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) ); - return *this; - } - BufferMemoryRequirementsInfo2& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferMemoryRequirementsInfo2& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkBufferMemoryRequirementsInfo2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BufferMemoryRequirementsInfo2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( BufferMemoryRequirementsInfo2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; - - public: - const void* pNext = nullptr; - Buffer buffer; - }; - static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); - - using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; - - struct ImageMemoryRequirementsInfo2 - { - ImageMemoryRequirementsInfo2( Image image_ = Image() ) - : image( image_ ) - { - } - - ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) ); - } - - ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) ); - return *this; - } - ImageMemoryRequirementsInfo2& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageMemoryRequirementsInfo2& setImage( Image image_ ) - { - image = image_; - return *this; - } - - operator const VkImageMemoryRequirementsInfo2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageMemoryRequirementsInfo2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ); - } - - bool operator!=( ImageMemoryRequirementsInfo2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageMemoryRequirementsInfo2; - - public: - const void* pNext = nullptr; - Image image; - }; - static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); - - using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; - - struct ImageSparseMemoryRequirementsInfo2 - { - ImageSparseMemoryRequirementsInfo2( Image image_ = Image() ) - : image( image_ ) - { - } - - ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) ); - } - - ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) ); - return *this; - } - ImageSparseMemoryRequirementsInfo2& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageSparseMemoryRequirementsInfo2& setImage( Image image_ ) - { - image = image_; - return *this; - } - - operator const VkImageSparseMemoryRequirementsInfo2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageSparseMemoryRequirementsInfo2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ); - } - - bool operator!=( ImageSparseMemoryRequirementsInfo2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; - - public: - const void* pNext = nullptr; - Image image; - }; - static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); - - using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; - - struct MemoryRequirements2 - { - operator const VkMemoryRequirements2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryRequirements2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryRequirements == rhs.memoryRequirements ); - } - - bool operator!=( MemoryRequirements2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryRequirements2; - - public: - void* pNext = nullptr; - MemoryRequirements memoryRequirements; - }; - static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" ); - - using MemoryRequirements2KHR = MemoryRequirements2; - - struct MemoryDedicatedRequirements - { - operator const VkMemoryDedicatedRequirements&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryDedicatedRequirements const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) - && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); - } - - bool operator!=( MemoryDedicatedRequirements const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryDedicatedRequirements; - - public: - void* pNext = nullptr; - Bool32 prefersDedicatedAllocation; - Bool32 requiresDedicatedAllocation; - }; - static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" ); - - using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; - - struct MemoryDedicatedAllocateInfo - { - MemoryDedicatedAllocateInfo( Image image_ = Image(), - Buffer buffer_ = Buffer() ) - : image( image_ ) - , buffer( buffer_ ) - { - } - - MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) ); - } - - MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) ); - return *this; - } - MemoryDedicatedAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryDedicatedAllocateInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - MemoryDedicatedAllocateInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkMemoryDedicatedAllocateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryDedicatedAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( MemoryDedicatedAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; - - public: - const void* pNext = nullptr; - Image image; - Buffer buffer; - }; - static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" ); - - using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; - - struct SamplerYcbcrConversionInfo - { - SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = SamplerYcbcrConversion() ) - : conversion( conversion_ ) - { - } - - SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) ); - } - - SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) ); - return *this; - } - SamplerYcbcrConversionInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerYcbcrConversionInfo& setConversion( SamplerYcbcrConversion conversion_ ) - { - conversion = conversion_; - return *this; - } - - operator const VkSamplerYcbcrConversionInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SamplerYcbcrConversionInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( conversion == rhs.conversion ); - } - - bool operator!=( SamplerYcbcrConversionInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerYcbcrConversionInfo; - - public: - const void* pNext = nullptr; - SamplerYcbcrConversion conversion; - }; - static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" ); - - using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; - - struct PhysicalDeviceSamplerYcbcrConversionFeatures - { - PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = 0 ) - : samplerYcbcrConversion( samplerYcbcrConversion_ ) - { - } - - PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) ); - } - - PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) ); - return *this; - } - PhysicalDeviceSamplerYcbcrConversionFeatures& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceSamplerYcbcrConversionFeatures& setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) - { - samplerYcbcrConversion = samplerYcbcrConversion_; - return *this; - } - - operator const VkPhysicalDeviceSamplerYcbcrConversionFeatures&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); - } - - bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; - - public: - void* pNext = nullptr; - Bool32 samplerYcbcrConversion; - }; - static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" ); - - using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; - - struct SamplerYcbcrConversionImageFormatProperties - { - operator const VkSamplerYcbcrConversionImageFormatProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SamplerYcbcrConversionImageFormatProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); - } - - bool operator!=( SamplerYcbcrConversionImageFormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; - - public: - void* pNext = nullptr; - uint32_t combinedImageSamplerDescriptorCount; - }; - static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" ); - - using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; - - struct TextureLODGatherFormatPropertiesAMD - { - operator const VkTextureLODGatherFormatPropertiesAMD&() const - { - return *reinterpret_cast(this); - } - - bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); - } - - bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; - - public: - void* pNext = nullptr; - Bool32 supportsTextureGatherLODBiasAMD; - }; - static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); - - struct ProtectedSubmitInfo - { - ProtectedSubmitInfo( Bool32 protectedSubmit_ = 0 ) - : protectedSubmit( protectedSubmit_ ) - { - } - - ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) ); - } - - ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) ); - return *this; - } - ProtectedSubmitInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ProtectedSubmitInfo& setProtectedSubmit( Bool32 protectedSubmit_ ) - { - protectedSubmit = protectedSubmit_; - return *this; - } - - operator const VkProtectedSubmitInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ProtectedSubmitInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( protectedSubmit == rhs.protectedSubmit ); - } - - bool operator!=( ProtectedSubmitInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eProtectedSubmitInfo; - - public: - const void* pNext = nullptr; - Bool32 protectedSubmit; - }; - static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceProtectedMemoryFeatures - { - PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = 0 ) - : protectedMemory( protectedMemory_ ) - { - } - - PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) ); - } - - PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) ); - return *this; - } - PhysicalDeviceProtectedMemoryFeatures& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceProtectedMemoryFeatures& setProtectedMemory( Bool32 protectedMemory_ ) - { - protectedMemory = protectedMemory_; - return *this; - } - - operator const VkPhysicalDeviceProtectedMemoryFeatures&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( protectedMemory == rhs.protectedMemory ); - } - - bool operator!=( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; - - public: - void* pNext = nullptr; - Bool32 protectedMemory; - }; - static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceProtectedMemoryProperties - { - PhysicalDeviceProtectedMemoryProperties( Bool32 protectedNoFault_ = 0 ) - : protectedNoFault( protectedNoFault_ ) - { - } - - PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) ); - } - - PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) ); - return *this; - } - PhysicalDeviceProtectedMemoryProperties& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceProtectedMemoryProperties& setProtectedNoFault( Bool32 protectedNoFault_ ) - { - protectedNoFault = protectedNoFault_; - return *this; - } - - operator const VkPhysicalDeviceProtectedMemoryProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceProtectedMemoryProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( protectedNoFault == rhs.protectedNoFault ); - } - - bool operator!=( PhysicalDeviceProtectedMemoryProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; - - public: - void* pNext = nullptr; - Bool32 protectedNoFault; - }; - static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" ); - - struct PipelineCoverageToColorStateCreateInfoNV - { - PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), - Bool32 coverageToColorEnable_ = 0, - uint32_t coverageToColorLocation_ = 0 ) - : flags( flags_ ) - , coverageToColorEnable( coverageToColorEnable_ ) - , coverageToColorLocation( coverageToColorLocation_ ) - { - } - - PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); - } - - PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); - return *this; - } - PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) - { - flags = flags_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) - { - coverageToColorEnable = coverageToColorEnable_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) - { - coverageToColorLocation = coverageToColorLocation_; - return *this; - } - - operator const VkPipelineCoverageToColorStateCreateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( coverageToColorEnable == rhs.coverageToColorEnable ) - && ( coverageToColorLocation == rhs.coverageToColorLocation ); - } - - bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; - - public: - const void* pNext = nullptr; - PipelineCoverageToColorStateCreateFlagsNV flags; - Bool32 coverageToColorEnable; - uint32_t coverageToColorLocation; - }; - static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT - { - operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) - && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); - } - - bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; - - public: - void* pNext = nullptr; - Bool32 filterMinmaxSingleComponentFormats; - Bool32 filterMinmaxImageComponentMapping; - }; - static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); - - struct MultisamplePropertiesEXT - { - operator const VkMultisamplePropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MultisamplePropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); - } - - bool operator!=( MultisamplePropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMultisamplePropertiesEXT; - - public: - void* pNext = nullptr; - Extent2D maxSampleLocationGridSize; - }; - static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT - { - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 ) - : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) - { - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); - return *this; - } - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) - { - advancedBlendCoherentOperations = advancedBlendCoherentOperations_; - return *this; - } - - operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); - } - - bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; - - public: - void* pNext = nullptr; - Bool32 advancedBlendCoherentOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT - { - operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) - && ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) - && ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) - && ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) - && ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) - && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); - } - - bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t advancedBlendMaxColorAttachments; - Bool32 advancedBlendIndependentBlend; - Bool32 advancedBlendNonPremultipliedSrcColor; - Bool32 advancedBlendNonPremultipliedDstColor; - Bool32 advancedBlendCorrelatedOverlap; - Bool32 advancedBlendAllOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); - - struct ImageFormatListCreateInfoKHR - { - ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, - const Format* pViewFormats_ = nullptr ) - : viewFormatCount( viewFormatCount_ ) - , pViewFormats( pViewFormats_ ) - { - } - - ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) ); - } - - ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) ); - return *this; - } - ImageFormatListCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageFormatListCreateInfoKHR& setViewFormatCount( uint32_t viewFormatCount_ ) - { - viewFormatCount = viewFormatCount_; - return *this; - } - - ImageFormatListCreateInfoKHR& setPViewFormats( const Format* pViewFormats_ ) - { - pViewFormats = pViewFormats_; - return *this; - } - - operator const VkImageFormatListCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( viewFormatCount == rhs.viewFormatCount ) - && ( pViewFormats == rhs.pViewFormats ); - } - - bool operator!=( ImageFormatListCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageFormatListCreateInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t viewFormatCount; - const Format* pViewFormats; - }; - static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct ValidationCacheCreateInfoEXT - { - ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(), - size_t initialDataSize_ = 0, - const void* pInitialData_ = nullptr ) - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - { - } - - ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) ); - } - - ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) ); - return *this; - } - ValidationCacheCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ValidationCacheCreateInfoEXT& setFlags( ValidationCacheCreateFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - ValidationCacheCreateInfoEXT& setInitialDataSize( size_t initialDataSize_ ) - { - initialDataSize = initialDataSize_; - return *this; - } - - ValidationCacheCreateInfoEXT& setPInitialData( const void* pInitialData_ ) - { - pInitialData = pInitialData_; - return *this; - } - - operator const VkValidationCacheCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( initialDataSize == rhs.initialDataSize ) - && ( pInitialData == rhs.pInitialData ); - } - - bool operator!=( ValidationCacheCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eValidationCacheCreateInfoEXT; - - public: - const void* pNext = nullptr; - ValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); - - struct ShaderModuleValidationCacheCreateInfoEXT - { - ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() ) - : validationCache( validationCache_ ) - { - } - - ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) ); - } - - ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) ); - return *this; - } - ShaderModuleValidationCacheCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ShaderModuleValidationCacheCreateInfoEXT& setValidationCache( ValidationCacheEXT validationCache_ ) - { - validationCache = validationCache_; - return *this; - } - - operator const VkShaderModuleValidationCacheCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( validationCache == rhs.validationCache ); - } - - bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; - - public: - const void* pNext = nullptr; - ValidationCacheEXT validationCache; - }; - static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMaintenance3Properties - { - operator const VkPhysicalDeviceMaintenance3Properties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceMaintenance3Properties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) - && ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); - } - - bool operator!=( PhysicalDeviceMaintenance3Properties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; - - public: - void* pNext = nullptr; - uint32_t maxPerSetDescriptors; - DeviceSize maxMemoryAllocationSize; - }; - static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" ); - - using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; - - struct DescriptorSetLayoutSupport - { - operator const VkDescriptorSetLayoutSupport&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorSetLayoutSupport const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( supported == rhs.supported ); - } - - bool operator!=( DescriptorSetLayoutSupport const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetLayoutSupport; - - public: - void* pNext = nullptr; - Bool32 supported; - }; - static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" ); - - using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; - - struct PhysicalDeviceShaderDrawParameterFeatures - { - PhysicalDeviceShaderDrawParameterFeatures( Bool32 shaderDrawParameters_ = 0 ) - : shaderDrawParameters( shaderDrawParameters_ ) - { - } - - PhysicalDeviceShaderDrawParameterFeatures( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) ); - } - - PhysicalDeviceShaderDrawParameterFeatures& operator=( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) ); - return *this; - } - PhysicalDeviceShaderDrawParameterFeatures& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceShaderDrawParameterFeatures& setShaderDrawParameters( Bool32 shaderDrawParameters_ ) - { - shaderDrawParameters = shaderDrawParameters_; - return *this; - } - - operator const VkPhysicalDeviceShaderDrawParameterFeatures&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( shaderDrawParameters == rhs.shaderDrawParameters ); - } - - bool operator!=( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceShaderDrawParameterFeatures; - - public: - void* pNext = nullptr; - Bool32 shaderDrawParameters; - }; - static_assert( sizeof( PhysicalDeviceShaderDrawParameterFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParameterFeatures ), "struct and wrapper have different size!" ); - - struct DebugUtilsLabelEXT - { - DebugUtilsLabelEXT( const char* pLabelName_ = nullptr, - std::array const& color_ = { { 0, 0, 0, 0 } } ) - : pLabelName( pLabelName_ ) - { - memcpy( &color, color_.data(), 4 * sizeof( float ) ); - } - - DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) ); - } - - DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) ); - return *this; - } - DebugUtilsLabelEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugUtilsLabelEXT& setPLabelName( const char* pLabelName_ ) - { - pLabelName = pLabelName_; - return *this; - } - - DebugUtilsLabelEXT& setColor( std::array color_ ) - { - memcpy( &color, color_.data(), 4 * sizeof( float ) ); - return *this; - } - - operator const VkDebugUtilsLabelEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugUtilsLabelEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pLabelName == rhs.pLabelName ) - && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 ); - } - - bool operator!=( DebugUtilsLabelEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugUtilsLabelEXT; - - public: - const void* pNext = nullptr; - const char* pLabelName; - float color[4]; - }; - static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" ); - - struct MemoryHostPointerPropertiesEXT - { - MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 ) - : memoryTypeBits( memoryTypeBits_ ) - { - } - - MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) ); - } - - MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) ); - return *this; - } - MemoryHostPointerPropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryHostPointerPropertiesEXT& setMemoryTypeBits( uint32_t memoryTypeBits_ ) - { - memoryTypeBits = memoryTypeBits_; - return *this; - } - - operator const VkMemoryHostPointerPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryHostPointerPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceExternalMemoryHostPropertiesEXT - { - PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 ) - : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) - { - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) ); - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) ); - return *this; - } - PhysicalDeviceExternalMemoryHostPropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT& setMinImportedHostPointerAlignment( DeviceSize minImportedHostPointerAlignment_ ) - { - minImportedHostPointerAlignment = minImportedHostPointerAlignment_; - return *this; - } - - operator const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); - } - - bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; - - public: - void* pNext = nullptr; - DeviceSize minImportedHostPointerAlignment; - }; - static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceConservativeRasterizationPropertiesEXT - { - PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0, - float maxExtraPrimitiveOverestimationSize_ = 0, - float extraPrimitiveOverestimationSizeGranularity_ = 0, - Bool32 primitiveUnderestimation_ = 0, - Bool32 conservativePointAndLineRasterization_ = 0, - Bool32 degenerateTrianglesRasterized_ = 0, - Bool32 degenerateLinesRasterized_ = 0, - Bool32 fullyCoveredFragmentShaderInputVariable_ = 0, - Bool32 conservativeRasterizationPostDepthCoverage_ = 0 ) - : primitiveOverestimationSize( primitiveOverestimationSize_ ) - , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ ) - , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ ) - , primitiveUnderestimation( primitiveUnderestimation_ ) - , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ ) - , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ ) - , degenerateLinesRasterized( degenerateLinesRasterized_ ) - , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ ) - , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ ) - { - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) ); - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) ); - return *this; - } - PhysicalDeviceConservativeRasterizationPropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveOverestimationSize( float primitiveOverestimationSize_ ) - { - primitiveOverestimationSize = primitiveOverestimationSize_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setMaxExtraPrimitiveOverestimationSize( float maxExtraPrimitiveOverestimationSize_ ) - { - maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setExtraPrimitiveOverestimationSizeGranularity( float extraPrimitiveOverestimationSizeGranularity_ ) - { - extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveUnderestimation( Bool32 primitiveUnderestimation_ ) - { - primitiveUnderestimation = primitiveUnderestimation_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativePointAndLineRasterization( Bool32 conservativePointAndLineRasterization_ ) - { - conservativePointAndLineRasterization = conservativePointAndLineRasterization_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateTrianglesRasterized( Bool32 degenerateTrianglesRasterized_ ) - { - degenerateTrianglesRasterized = degenerateTrianglesRasterized_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateLinesRasterized( Bool32 degenerateLinesRasterized_ ) - { - degenerateLinesRasterized = degenerateLinesRasterized_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setFullyCoveredFragmentShaderInputVariable( Bool32 fullyCoveredFragmentShaderInputVariable_ ) - { - fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativeRasterizationPostDepthCoverage( Bool32 conservativeRasterizationPostDepthCoverage_ ) - { - conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage_; - return *this; - } - - operator const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) - && ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) - && ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) - && ( primitiveUnderestimation == rhs.primitiveUnderestimation ) - && ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) - && ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) - && ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) - && ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) - && ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage ); - } - - bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; - - public: - void* pNext = nullptr; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - Bool32 primitiveUnderestimation; - Bool32 conservativePointAndLineRasterization; - Bool32 degenerateTrianglesRasterized; - Bool32 degenerateLinesRasterized; - Bool32 fullyCoveredFragmentShaderInputVariable; - Bool32 conservativeRasterizationPostDepthCoverage; - }; - static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceShaderCorePropertiesAMD - { - operator const VkPhysicalDeviceShaderCorePropertiesAMD&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( shaderEngineCount == rhs.shaderEngineCount ) - && ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) - && ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) - && ( simdPerComputeUnit == rhs.simdPerComputeUnit ) - && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) - && ( wavefrontSize == rhs.wavefrontSize ) - && ( sgprsPerSimd == rhs.sgprsPerSimd ) - && ( minSgprAllocation == rhs.minSgprAllocation ) - && ( maxSgprAllocation == rhs.maxSgprAllocation ) - && ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) - && ( vgprsPerSimd == rhs.vgprsPerSimd ) - && ( minVgprAllocation == rhs.minVgprAllocation ) - && ( maxVgprAllocation == rhs.maxVgprAllocation ) - && ( vgprAllocationGranularity == rhs.vgprAllocationGranularity ); - } - - bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; - - public: - void* pNext = nullptr; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; - }; - static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceDescriptorIndexingFeaturesEXT - { - PhysicalDeviceDescriptorIndexingFeaturesEXT( Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0, - Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0, - Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0, - Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0, - Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0, - Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0, - Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0, - Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0, - Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0, - Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0, - Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0, - Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0, - Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0, - Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0, - Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0, - Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0, - Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0, - Bool32 descriptorBindingPartiallyBound_ = 0, - Bool32 descriptorBindingVariableDescriptorCount_ = 0, - Bool32 runtimeDescriptorArray_ = 0 ) - : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ ) - , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ ) - , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ ) - , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ ) - , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ ) - , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ ) - , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ ) - , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ ) - , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ ) - , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ ) - , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ ) - , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ ) - , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ ) - , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ ) - , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ ) - , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ ) - , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ ) - , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ ) - , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ ) - , runtimeDescriptorArray( runtimeDescriptorArray_ ) - { - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) ); - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) ); - return *this; - } - PhysicalDeviceDescriptorIndexingFeaturesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) - { - shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) - { - shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) - { - shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) - { - shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) - { - shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) - { - shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) - { - shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) - { - shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) - { - shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) - { - shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) - { - descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) - { - descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) - { - descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) - { - descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) - { - descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) - { - descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) - { - descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) - { - descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) - { - descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; - return *this; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) - { - runtimeDescriptorArray = runtimeDescriptorArray_; - return *this; - } - - operator const VkPhysicalDeviceDescriptorIndexingFeaturesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceDescriptorIndexingFeaturesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) - && ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) - && ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) - && ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) - && ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) - && ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) - && ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) - && ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) - && ( shaderUniformTexelBufferArrayNonUniformIndexing == rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) - && ( shaderStorageTexelBufferArrayNonUniformIndexing == rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) - && ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) - && ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) - && ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) - && ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) - && ( descriptorBindingUniformTexelBufferUpdateAfterBind == rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) - && ( descriptorBindingStorageTexelBufferUpdateAfterBind == rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) - && ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) - && ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) - && ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) - && ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ); - } - - bool operator!=( PhysicalDeviceDescriptorIndexingFeaturesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT; - - public: - void* pNext = nullptr; - Bool32 shaderInputAttachmentArrayDynamicIndexing; - Bool32 shaderUniformTexelBufferArrayDynamicIndexing; - Bool32 shaderStorageTexelBufferArrayDynamicIndexing; - Bool32 shaderUniformBufferArrayNonUniformIndexing; - Bool32 shaderSampledImageArrayNonUniformIndexing; - Bool32 shaderStorageBufferArrayNonUniformIndexing; - Bool32 shaderStorageImageArrayNonUniformIndexing; - Bool32 shaderInputAttachmentArrayNonUniformIndexing; - Bool32 shaderUniformTexelBufferArrayNonUniformIndexing; - Bool32 shaderStorageTexelBufferArrayNonUniformIndexing; - Bool32 descriptorBindingUniformBufferUpdateAfterBind; - Bool32 descriptorBindingSampledImageUpdateAfterBind; - Bool32 descriptorBindingStorageImageUpdateAfterBind; - Bool32 descriptorBindingStorageBufferUpdateAfterBind; - Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - Bool32 descriptorBindingUpdateUnusedWhilePending; - Bool32 descriptorBindingPartiallyBound; - Bool32 descriptorBindingVariableDescriptorCount; - Bool32 runtimeDescriptorArray; - }; - static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceDescriptorIndexingPropertiesEXT - { - operator const VkPhysicalDeviceDescriptorIndexingPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceDescriptorIndexingPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) - && ( shaderUniformBufferArrayNonUniformIndexingNative == rhs.shaderUniformBufferArrayNonUniformIndexingNative ) - && ( shaderSampledImageArrayNonUniformIndexingNative == rhs.shaderSampledImageArrayNonUniformIndexingNative ) - && ( shaderStorageBufferArrayNonUniformIndexingNative == rhs.shaderStorageBufferArrayNonUniformIndexingNative ) - && ( shaderStorageImageArrayNonUniformIndexingNative == rhs.shaderStorageImageArrayNonUniformIndexingNative ) - && ( shaderInputAttachmentArrayNonUniformIndexingNative == rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) - && ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) - && ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) - && ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) - && ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) - && ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) - && ( maxPerStageDescriptorUpdateAfterBindSampledImages == rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) - && ( maxPerStageDescriptorUpdateAfterBindStorageImages == rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) - && ( maxPerStageDescriptorUpdateAfterBindInputAttachments == rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) - && ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) - && ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) - && ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) - && ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) - && ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) - && ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) - && ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) - && ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) - && ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ); - } - - bool operator!=( PhysicalDeviceDescriptorIndexingPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - Bool32 shaderUniformBufferArrayNonUniformIndexingNative; - Bool32 shaderSampledImageArrayNonUniformIndexingNative; - Bool32 shaderStorageBufferArrayNonUniformIndexingNative; - Bool32 shaderStorageImageArrayNonUniformIndexingNative; - Bool32 shaderInputAttachmentArrayNonUniformIndexingNative; - Bool32 robustBufferAccessUpdateAfterBind; - Bool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; - }; - static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" ); - - struct DescriptorSetVariableDescriptorCountAllocateInfoEXT - { - DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0, - const uint32_t* pDescriptorCounts_ = nullptr ) - : descriptorSetCount( descriptorSetCount_ ) - , pDescriptorCounts( pDescriptorCounts_ ) - { - } - - DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) ); - } - - DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) ); - return *this; - } - DescriptorSetVariableDescriptorCountAllocateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorSetVariableDescriptorCountAllocateInfoEXT& setDescriptorSetCount( uint32_t descriptorSetCount_ ) - { - descriptorSetCount = descriptorSetCount_; - return *this; - } - - DescriptorSetVariableDescriptorCountAllocateInfoEXT& setPDescriptorCounts( const uint32_t* pDescriptorCounts_ ) - { - pDescriptorCounts = pDescriptorCounts_; - return *this; - } - - operator const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( descriptorSetCount == rhs.descriptorSetCount ) - && ( pDescriptorCounts == rhs.pDescriptorCounts ); - } - - bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT; - - public: - const void* pNext = nullptr; - uint32_t descriptorSetCount; - const uint32_t* pDescriptorCounts; - }; - static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" ); - - struct DescriptorSetVariableDescriptorCountLayoutSupportEXT - { - operator const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount ); - } - - bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT; - - public: - void* pNext = nullptr; - uint32_t maxVariableDescriptorCount; - }; - static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" ); - - struct PipelineVertexInputDivisorStateCreateInfoEXT - { - PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0, - const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) - : vertexBindingDivisorCount( vertexBindingDivisorCount_ ) - , pVertexBindingDivisors( pVertexBindingDivisors_ ) - { - } - - PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) ); - } - - PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) ); - return *this; - } - PipelineVertexInputDivisorStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineVertexInputDivisorStateCreateInfoEXT& setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ ) - { - vertexBindingDivisorCount = vertexBindingDivisorCount_; - return *this; - } - - PipelineVertexInputDivisorStateCreateInfoEXT& setPVertexBindingDivisors( const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ ) - { - pVertexBindingDivisors = pVertexBindingDivisors_; - return *this; - } - - operator const VkPipelineVertexInputDivisorStateCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) - && ( pVertexBindingDivisors == rhs.pVertexBindingDivisors ); - } - - bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - uint32_t vertexBindingDivisorCount; - const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; - }; - static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT - { - PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 ) - : maxVertexAttribDivisor( maxVertexAttribDivisor_ ) - { - } - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) ); - } - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) ); - return *this; - } - PhysicalDeviceVertexAttributeDivisorPropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT& setMaxVertexAttribDivisor( uint32_t maxVertexAttribDivisor_ ) - { - maxVertexAttribDivisor = maxVertexAttribDivisor_; - return *this; - } - - operator const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ); - } - - bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t maxVertexAttribDivisor; - }; - static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - struct ImportAndroidHardwareBufferInfoANDROID - { - ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) - : buffer( buffer_ ) - { - } - - ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) ); - } - - ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) ); - return *this; - } - ImportAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportAndroidHardwareBufferInfoANDROID& setBuffer( struct AHardwareBuffer* buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkImportAndroidHardwareBufferInfoANDROID&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; - - public: - const void* pNext = nullptr; - struct AHardwareBuffer* buffer; - }; - static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - struct AndroidHardwareBufferUsageANDROID - { - operator const VkAndroidHardwareBufferUsageANDROID&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AndroidHardwareBufferUsageANDROID const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage ); - } - - bool operator!=( AndroidHardwareBufferUsageANDROID const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; - - public: - void* pNext = nullptr; - uint64_t androidHardwareBufferUsage; - }; - static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - struct AndroidHardwareBufferPropertiesANDROID - { - operator const VkAndroidHardwareBufferPropertiesANDROID&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AndroidHardwareBufferPropertiesANDROID const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( allocationSize == rhs.allocationSize ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( AndroidHardwareBufferPropertiesANDROID const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; - - public: - void* pNext = nullptr; - DeviceSize allocationSize; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - struct MemoryGetAndroidHardwareBufferInfoANDROID - { - MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = DeviceMemory() ) - : memory( memory_ ) - { - } - - MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) ); - } - - MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) ); - return *this; - } - MemoryGetAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryGetAndroidHardwareBufferInfoANDROID& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - operator const VkMemoryGetAndroidHardwareBufferInfoANDROID&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memory == rhs.memory ); - } - - bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; - - public: - const void* pNext = nullptr; - DeviceMemory memory; - }; - static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - struct ExternalFormatANDROID - { - ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) - : externalFormat( externalFormat_ ) - { - } - - ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) ); - } - - ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) ); - return *this; - } - ExternalFormatANDROID& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExternalFormatANDROID& setExternalFormat( uint64_t externalFormat_ ) - { - externalFormat = externalFormat_; - return *this; - } - - operator const VkExternalFormatANDROID&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalFormatANDROID const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( externalFormat == rhs.externalFormat ); - } - - bool operator!=( ExternalFormatANDROID const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalFormatANDROID; - - public: - void* pNext = nullptr; - uint64_t externalFormat; - }; - static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - - enum class SubpassContents - { - eInline = VK_SUBPASS_CONTENTS_INLINE, - eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - }; - - struct PresentInfoKHR - { - PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, - const Semaphore* pWaitSemaphores_ = nullptr, - uint32_t swapchainCount_ = 0, - const SwapchainKHR* pSwapchains_ = nullptr, - const uint32_t* pImageIndices_ = nullptr, - Result* pResults_ = nullptr ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , swapchainCount( swapchainCount_ ) - , pSwapchains( pSwapchains_ ) - , pImageIndices( pImageIndices_ ) - , pResults( pResults_ ) - { - } - - PresentInfoKHR( VkPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); - } - - PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); - return *this; - } - PresentInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ ) - { - pSwapchains = pSwapchains_; - return *this; - } - - PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ ) - { - pImageIndices = pImageIndices_; - return *this; - } - - PresentInfoKHR& setPResults( Result* pResults_ ) - { - pResults = pResults_; - return *this; - } - - operator const VkPresentInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PresentInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pSwapchains == rhs.pSwapchains ) - && ( pImageIndices == rhs.pImageIndices ) - && ( pResults == rhs.pResults ); - } - - bool operator!=( PresentInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePresentInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - uint32_t swapchainCount; - const SwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - Result* pResults; - }; - static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); - - enum class DynamicState - { - eViewport = VK_DYNAMIC_STATE_VIEWPORT, - eScissor = VK_DYNAMIC_STATE_SCISSOR, - eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, - eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, - eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, - eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, - eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, - eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, - eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, - eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, - eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, - eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT - }; - - struct PipelineDynamicStateCreateInfo - { - PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), - uint32_t dynamicStateCount_ = 0, - const DynamicState* pDynamicStates_ = nullptr ) - : flags( flags_ ) - , dynamicStateCount( dynamicStateCount_ ) - , pDynamicStates( pDynamicStates_ ) - { - } - - PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); - } - - PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); - return *this; - } - PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ ) - { - dynamicStateCount = dynamicStateCount_; - return *this; - } - - PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ ) - { - pDynamicStates = pDynamicStates_; - return *this; - } - - operator const VkPipelineDynamicStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( dynamicStateCount == rhs.dynamicStateCount ) - && ( pDynamicStates == rhs.pDynamicStates ); - } - - bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const DynamicState* pDynamicStates; - }; - static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); - - enum class DescriptorUpdateTemplateType - { - eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - }; - - struct DescriptorUpdateTemplateCreateInfo - { - DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(), - uint32_t descriptorUpdateEntryCount_ = 0, - const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr, - DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet, - DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), - PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - PipelineLayout pipelineLayout_ = PipelineLayout(), - uint32_t set_ = 0 ) - : flags( flags_ ) - , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) - , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) - , templateType( templateType_ ) - , descriptorSetLayout( descriptorSetLayout_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , pipelineLayout( pipelineLayout_ ) - , set( set_ ) - { - } - - DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) ); - } - - DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) ); - return *this; - } - DescriptorUpdateTemplateCreateInfo& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) - { - descriptorUpdateEntryCount = descriptorUpdateEntryCount_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ ) - { - pDescriptorUpdateEntries = pDescriptorUpdateEntries_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setTemplateType( DescriptorUpdateTemplateType templateType_ ) - { - templateType = templateType_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) - { - descriptorSetLayout = descriptorSetLayout_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setPipelineLayout( PipelineLayout pipelineLayout_ ) - { - pipelineLayout = pipelineLayout_; - return *this; - } - - DescriptorUpdateTemplateCreateInfo& setSet( uint32_t set_ ) - { - set = set_; - return *this; - } - - operator const VkDescriptorUpdateTemplateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) - && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) - && ( templateType == rhs.templateType ) - && ( descriptorSetLayout == rhs.descriptorSetLayout ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( set == rhs.set ); - } - - bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; - - public: - void* pNext = nullptr; - DescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - DescriptorUpdateTemplateType templateType; - DescriptorSetLayout descriptorSetLayout; - PipelineBindPoint pipelineBindPoint; - PipelineLayout pipelineLayout; - uint32_t set; - }; - static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" ); - - using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; - - enum class ObjectType - { - eUnknown = VK_OBJECT_TYPE_UNKNOWN, - eInstance = VK_OBJECT_TYPE_INSTANCE, - ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, - eDevice = VK_OBJECT_TYPE_DEVICE, - eQueue = VK_OBJECT_TYPE_QUEUE, - eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, - eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, - eFence = VK_OBJECT_TYPE_FENCE, - eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, - eBuffer = VK_OBJECT_TYPE_BUFFER, - eImage = VK_OBJECT_TYPE_IMAGE, - eEvent = VK_OBJECT_TYPE_EVENT, - eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, - eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, - eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, - eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, - ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, - ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, - eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, - ePipeline = VK_OBJECT_TYPE_PIPELINE, - eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, - eSampler = VK_OBJECT_TYPE_SAMPLER, - eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, - eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, - eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, - eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, - eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, - eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, - eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, - eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, - eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, - eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, - eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, - eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX, - eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX, - eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, - eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT - }; - - struct DebugUtilsObjectNameInfoEXT - { - DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, - uint64_t objectHandle_ = 0, - const char* pObjectName_ = nullptr ) - : objectType( objectType_ ) - , objectHandle( objectHandle_ ) - , pObjectName( pObjectName_ ) - { - } - - DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) ); - } - - DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) ); - return *this; - } - DebugUtilsObjectNameInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugUtilsObjectNameInfoEXT& setObjectType( ObjectType objectType_ ) - { - objectType = objectType_; - return *this; - } - - DebugUtilsObjectNameInfoEXT& setObjectHandle( uint64_t objectHandle_ ) - { - objectHandle = objectHandle_; - return *this; - } - - DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ ) - { - pObjectName = pObjectName_; - return *this; - } - - operator const VkDebugUtilsObjectNameInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( objectHandle == rhs.objectHandle ) - && ( pObjectName == rhs.pObjectName ); - } - - bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; - - public: - const void* pNext = nullptr; - ObjectType objectType; - uint64_t objectHandle; - const char* pObjectName; - }; - static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" ); - - struct DebugUtilsObjectTagInfoEXT - { - DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, - uint64_t objectHandle_ = 0, - uint64_t tagName_ = 0, - size_t tagSize_ = 0, - const void* pTag_ = nullptr ) - : objectType( objectType_ ) - , objectHandle( objectHandle_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - { - } - - DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) ); - } - - DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) ); - return *this; - } - DebugUtilsObjectTagInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugUtilsObjectTagInfoEXT& setObjectType( ObjectType objectType_ ) - { - objectType = objectType_; - return *this; - } - - DebugUtilsObjectTagInfoEXT& setObjectHandle( uint64_t objectHandle_ ) - { - objectHandle = objectHandle_; - return *this; - } - - DebugUtilsObjectTagInfoEXT& setTagName( uint64_t tagName_ ) - { - tagName = tagName_; - return *this; - } - - DebugUtilsObjectTagInfoEXT& setTagSize( size_t tagSize_ ) - { - tagSize = tagSize_; - return *this; - } - - DebugUtilsObjectTagInfoEXT& setPTag( const void* pTag_ ) - { - pTag = pTag_; - return *this; - } - - operator const VkDebugUtilsObjectTagInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugUtilsObjectTagInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( objectHandle == rhs.objectHandle ) - && ( tagName == rhs.tagName ) - && ( tagSize == rhs.tagSize ) - && ( pTag == rhs.pTag ); - } - - bool operator!=( DebugUtilsObjectTagInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; - - public: - const void* pNext = nullptr; - ObjectType objectType; - uint64_t objectHandle; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" ); - - struct DebugUtilsMessengerCallbackDataEXT - { - DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(), - const char* pMessageIdName_ = nullptr, - int32_t messageIdNumber_ = 0, - const char* pMessage_ = nullptr, - uint32_t queueLabelCount_ = 0, - DebugUtilsLabelEXT* pQueueLabels_ = nullptr, - uint32_t cmdBufLabelCount_ = 0, - DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr, - uint32_t objectCount_ = 0, - DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr ) - : flags( flags_ ) - , pMessageIdName( pMessageIdName_ ) - , messageIdNumber( messageIdNumber_ ) - , pMessage( pMessage_ ) - , queueLabelCount( queueLabelCount_ ) - , pQueueLabels( pQueueLabels_ ) - , cmdBufLabelCount( cmdBufLabelCount_ ) - , pCmdBufLabels( pCmdBufLabels_ ) - , objectCount( objectCount_ ) - , pObjects( pObjects_ ) - { - } - - DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) ); - } - - DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) ); - return *this; - } - DebugUtilsMessengerCallbackDataEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setPMessageIdName( const char* pMessageIdName_ ) - { - pMessageIdName = pMessageIdName_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setMessageIdNumber( int32_t messageIdNumber_ ) - { - messageIdNumber = messageIdNumber_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setPMessage( const char* pMessage_ ) - { - pMessage = pMessage_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setQueueLabelCount( uint32_t queueLabelCount_ ) - { - queueLabelCount = queueLabelCount_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setPQueueLabels( DebugUtilsLabelEXT* pQueueLabels_ ) - { - pQueueLabels = pQueueLabels_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) - { - cmdBufLabelCount = cmdBufLabelCount_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setPCmdBufLabels( DebugUtilsLabelEXT* pCmdBufLabels_ ) - { - pCmdBufLabels = pCmdBufLabels_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setObjectCount( uint32_t objectCount_ ) - { - objectCount = objectCount_; - return *this; - } - - DebugUtilsMessengerCallbackDataEXT& setPObjects( DebugUtilsObjectNameInfoEXT* pObjects_ ) - { - pObjects = pObjects_; - return *this; - } - - operator const VkDebugUtilsMessengerCallbackDataEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugUtilsMessengerCallbackDataEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pMessageIdName == rhs.pMessageIdName ) - && ( messageIdNumber == rhs.messageIdNumber ) - && ( pMessage == rhs.pMessage ) - && ( queueLabelCount == rhs.queueLabelCount ) - && ( pQueueLabels == rhs.pQueueLabels ) - && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) - && ( pCmdBufLabels == rhs.pCmdBufLabels ) - && ( objectCount == rhs.objectCount ) - && ( pObjects == rhs.pObjects ); - } - - bool operator!=( DebugUtilsMessengerCallbackDataEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; - - public: - const void* pNext = nullptr; - DebugUtilsMessengerCallbackDataFlagsEXT flags; - const char* pMessageIdName; - int32_t messageIdNumber; - const char* pMessage; - uint32_t queueLabelCount; - DebugUtilsLabelEXT* pQueueLabels; - uint32_t cmdBufLabelCount; - DebugUtilsLabelEXT* pCmdBufLabels; - uint32_t objectCount; - DebugUtilsObjectNameInfoEXT* pObjects; - }; - static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" ); - - enum class QueueFlagBits - { - eGraphics = VK_QUEUE_GRAPHICS_BIT, - eCompute = VK_QUEUE_COMPUTE_BIT, - eTransfer = VK_QUEUE_TRANSFER_BIT, - eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT, - eProtected = VK_QUEUE_PROTECTED_BIT - }; - - using QueueFlags = Flags; - - VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 ) - { - return QueueFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits ) - { - return ~( QueueFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) | VkFlags(QueueFlagBits::eProtected) - }; - }; - - struct QueueFamilyProperties - { - operator const VkQueueFamilyProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( QueueFamilyProperties const& rhs ) const - { - return ( queueFlags == rhs.queueFlags ) - && ( queueCount == rhs.queueCount ) - && ( timestampValidBits == rhs.timestampValidBits ) - && ( minImageTransferGranularity == rhs.minImageTransferGranularity ); - } - - bool operator!=( QueueFamilyProperties const& rhs ) const - { - return !operator==( rhs ); - } - - QueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - Extent3D minImageTransferGranularity; - }; - static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); - - struct QueueFamilyProperties2 - { - operator const VkQueueFamilyProperties2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( QueueFamilyProperties2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( queueFamilyProperties == rhs.queueFamilyProperties ); - } - - bool operator!=( QueueFamilyProperties2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eQueueFamilyProperties2; - - public: - void* pNext = nullptr; - QueueFamilyProperties queueFamilyProperties; - }; - static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" ); - - using QueueFamilyProperties2KHR = QueueFamilyProperties2; - - enum class DeviceQueueCreateFlagBits - { - eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT - }; - - using DeviceQueueCreateFlags = Flags; - - VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 ) - { - return DeviceQueueCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits ) - { - return ~( DeviceQueueCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected) - }; - }; - - struct DeviceQueueCreateInfo - { - DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), - uint32_t queueFamilyIndex_ = 0, - uint32_t queueCount_ = 0, - const float* pQueuePriorities_ = nullptr ) - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueCount( queueCount_ ) - , pQueuePriorities( pQueuePriorities_ ) - { - } - - DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); - } - - DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); - return *this; - } - DeviceQueueCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ ) - { - queueCount = queueCount_; - return *this; - } - - DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ ) - { - pQueuePriorities = pQueuePriorities_; - return *this; - } - - operator const VkDeviceQueueCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceQueueCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueFamilyIndex == rhs.queueFamilyIndex ) - && ( queueCount == rhs.queueCount ) - && ( pQueuePriorities == rhs.pQueuePriorities ); - } - - bool operator!=( DeviceQueueCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceQueueCreateInfo; - - public: - const void* pNext = nullptr; - DeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; - }; - static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" ); - - struct DeviceCreateInfo - { - DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(), - uint32_t queueCreateInfoCount_ = 0, - const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, - uint32_t enabledLayerCount_ = 0, - const char* const* ppEnabledLayerNames_ = nullptr, - uint32_t enabledExtensionCount_ = 0, - const char* const* ppEnabledExtensionNames_ = nullptr, - const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) - : flags( flags_ ) - , queueCreateInfoCount( queueCreateInfoCount_ ) - , pQueueCreateInfos( pQueueCreateInfos_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - , pEnabledFeatures( pEnabledFeatures_ ) - { - } - - DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); - } - - DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); - return *this; - } - DeviceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ ) - { - queueCreateInfoCount = queueCreateInfoCount_; - return *this; - } - - DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ ) - { - pQueueCreateInfos = pQueueCreateInfos_; - return *this; - } - - DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ ) - { - enabledLayerCount = enabledLayerCount_; - return *this; - } - - DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ ) - { - ppEnabledLayerNames = ppEnabledLayerNames_; - return *this; - } - - DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) - { - enabledExtensionCount = enabledExtensionCount_; - return *this; - } - - DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ ) - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return *this; - } - - DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ ) - { - pEnabledFeatures = pEnabledFeatures_; - return *this; - } - - operator const VkDeviceCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) - && ( pQueueCreateInfos == rhs.pQueueCreateInfos ) - && ( enabledLayerCount == rhs.enabledLayerCount ) - && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) - && ( enabledExtensionCount == rhs.enabledExtensionCount ) - && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ) - && ( pEnabledFeatures == rhs.pEnabledFeatures ); - } - - bool operator!=( DeviceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceCreateInfo; - - public: - const void* pNext = nullptr; - DeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const DeviceQueueCreateInfo* pQueueCreateInfos; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const PhysicalDeviceFeatures* pEnabledFeatures; - }; - static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); - - struct DeviceQueueInfo2 - { - DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), - uint32_t queueFamilyIndex_ = 0, - uint32_t queueIndex_ = 0 ) - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueIndex( queueIndex_ ) - { - } - - DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) ); - } - - DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) ); - return *this; - } - DeviceQueueInfo2& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceQueueInfo2& setFlags( DeviceQueueCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DeviceQueueInfo2& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - DeviceQueueInfo2& setQueueIndex( uint32_t queueIndex_ ) - { - queueIndex = queueIndex_; - return *this; - } - - operator const VkDeviceQueueInfo2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceQueueInfo2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueFamilyIndex == rhs.queueFamilyIndex ) - && ( queueIndex == rhs.queueIndex ); - } - - bool operator!=( DeviceQueueInfo2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceQueueInfo2; - - public: - const void* pNext = nullptr; - DeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; - }; - static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" ); - - enum class MemoryPropertyFlagBits - { - eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, - eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, - eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT - }; - - using MemoryPropertyFlags = Flags; - - VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 ) - { - return MemoryPropertyFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits ) - { - return ~( MemoryPropertyFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected) - }; - }; - - struct MemoryType - { - operator const VkMemoryType&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryType const& rhs ) const - { - return ( propertyFlags == rhs.propertyFlags ) - && ( heapIndex == rhs.heapIndex ); - } - - bool operator!=( MemoryType const& rhs ) const - { - return !operator==( rhs ); - } - - MemoryPropertyFlags propertyFlags; - uint32_t heapIndex; - }; - static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); - - enum class MemoryHeapFlagBits - { - eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, - eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, - eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT - }; - - using MemoryHeapFlags = Flags; - - VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 ) - { - return MemoryHeapFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits ) - { - return ~( MemoryHeapFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstance) - }; - }; - - struct MemoryHeap - { - operator const VkMemoryHeap&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryHeap const& rhs ) const - { - return ( size == rhs.size ) - && ( flags == rhs.flags ); - } - - bool operator!=( MemoryHeap const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize size; - MemoryHeapFlags flags; - }; - static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMemoryProperties - { - operator const VkPhysicalDeviceMemoryProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const - { - return ( memoryTypeCount == rhs.memoryTypeCount ) - && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 ) - && ( memoryHeapCount == rhs.memoryHeapCount ) - && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 ); - } - - bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t memoryTypeCount; - MemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMemoryProperties2 - { - operator const VkPhysicalDeviceMemoryProperties2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceMemoryProperties2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryProperties == rhs.memoryProperties ); - } - - bool operator!=( PhysicalDeviceMemoryProperties2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; - - public: - void* pNext = nullptr; - PhysicalDeviceMemoryProperties memoryProperties; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" ); - - using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; - - enum class AccessFlagBits - { - eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, - eIndexRead = VK_ACCESS_INDEX_READ_BIT, - eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, - eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, - eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, - eShaderRead = VK_ACCESS_SHADER_READ_BIT, - eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, - eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, - eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, - eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, - eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, - eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, - eHostRead = VK_ACCESS_HOST_READ_BIT, - eHostWrite = VK_ACCESS_HOST_WRITE_BIT, - eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, - eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, - eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, - eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, - eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT - }; - - using AccessFlags = Flags; - - VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 ) - { - return AccessFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits ) - { - return ~( AccessFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) - }; - }; - - struct MemoryBarrier - { - MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), - AccessFlags dstAccessMask_ = AccessFlags() ) - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - { - } - - MemoryBarrier( VkMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryBarrier ) ); - } - - MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryBarrier ) ); - return *this; - } - MemoryBarrier& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - operator const VkMemoryBarrier&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryBarrier const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ); - } - - bool operator!=( MemoryBarrier const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryBarrier; - - public: - const void* pNext = nullptr; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - }; - static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); - - struct BufferMemoryBarrier - { - BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), - AccessFlags dstAccessMask_ = AccessFlags(), - uint32_t srcQueueFamilyIndex_ = 0, - uint32_t dstQueueFamilyIndex_ = 0, - Buffer buffer_ = Buffer(), - DeviceSize offset_ = 0, - DeviceSize size_ = 0 ) - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , buffer( buffer_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); - } - - BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); - return *this; - } - BufferMemoryBarrier& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - BufferMemoryBarrier& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - BufferMemoryBarrier& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - BufferMemoryBarrier& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - operator const VkBufferMemoryBarrier&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BufferMemoryBarrier const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) - && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) - && ( buffer == rhs.buffer ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( BufferMemoryBarrier const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferMemoryBarrier; - - public: - const void* pNext = nullptr; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - Buffer buffer; - DeviceSize offset; - DeviceSize size; - }; - static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); - - enum class BufferUsageFlagBits - { - eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, - eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, - eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, - eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, - eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT - }; - - using BufferUsageFlags = Flags; - - VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 ) - { - return BufferUsageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits ) - { - return ~( BufferUsageFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) - }; - }; - - enum class BufferCreateFlagBits - { - eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, - eProtected = VK_BUFFER_CREATE_PROTECTED_BIT - }; - - using BufferCreateFlags = Flags; - - VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 ) - { - return BufferCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits ) - { - return ~( BufferCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected) - }; - }; - - struct BufferCreateInfo - { - BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), - DeviceSize size_ = 0, - BufferUsageFlags usage_ = BufferUsageFlags(), - SharingMode sharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr ) - : flags( flags_ ) - , size( size_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - { - } - - BufferCreateInfo( VkBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); - } - - BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); - return *this; - } - BufferCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferCreateInfo& setFlags( BufferCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - BufferCreateInfo& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - BufferCreateInfo& setUsage( BufferUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - BufferCreateInfo& setSharingMode( SharingMode sharingMode_ ) - { - sharingMode = sharingMode_; - return *this; - } - - BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - operator const VkBufferCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BufferCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( size == rhs.size ) - && ( usage == rhs.usage ) - && ( sharingMode == rhs.sharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); - } - - bool operator!=( BufferCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferCreateInfo; - - public: - const void* pNext = nullptr; - BufferCreateFlags flags; - DeviceSize size; - BufferUsageFlags usage; - SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - }; - static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); - - enum class ShaderStageFlagBits - { - eVertex = VK_SHADER_STAGE_VERTEX_BIT, - eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, - eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, - eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, - eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, - eCompute = VK_SHADER_STAGE_COMPUTE_BIT, - eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, - eAll = VK_SHADER_STAGE_ALL - }; - - using ShaderStageFlags = Flags; - - VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 ) - { - return ShaderStageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits ) - { - return ~( ShaderStageFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) - }; - }; - - struct DescriptorSetLayoutBinding - { - DescriptorSetLayoutBinding( uint32_t binding_ = 0, - DescriptorType descriptorType_ = DescriptorType::eSampler, - uint32_t descriptorCount_ = 0, - ShaderStageFlags stageFlags_ = ShaderStageFlags(), - const Sampler* pImmutableSamplers_ = nullptr ) - : binding( binding_ ) - , descriptorType( descriptorType_ ) - , descriptorCount( descriptorCount_ ) - , stageFlags( stageFlags_ ) - , pImmutableSamplers( pImmutableSamplers_ ) - { - } - - DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); - } - - DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); - return *this; - } - DescriptorSetLayoutBinding& setBinding( uint32_t binding_ ) - { - binding = binding_; - return *this; - } - - DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ ) - { - descriptorType = descriptorType_; - return *this; - } - - DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ ) - { - stageFlags = stageFlags_; - return *this; - } - - DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ ) - { - pImmutableSamplers = pImmutableSamplers_; - return *this; - } - - operator const VkDescriptorSetLayoutBinding&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorSetLayoutBinding const& rhs ) const - { - return ( binding == rhs.binding ) - && ( descriptorType == rhs.descriptorType ) - && ( descriptorCount == rhs.descriptorCount ) - && ( stageFlags == rhs.stageFlags ) - && ( pImmutableSamplers == rhs.pImmutableSamplers ); - } - - bool operator!=( DescriptorSetLayoutBinding const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t binding; - DescriptorType descriptorType; - uint32_t descriptorCount; - ShaderStageFlags stageFlags; - const Sampler* pImmutableSamplers; - }; - static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); - - struct PipelineShaderStageCreateInfo - { - PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), - ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, - ShaderModule module_ = ShaderModule(), - const char* pName_ = nullptr, - const SpecializationInfo* pSpecializationInfo_ = nullptr ) - : flags( flags_ ) - , stage( stage_ ) - , module( module_ ) - , pName( pName_ ) - , pSpecializationInfo( pSpecializationInfo_ ) - { - } - - PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); - } - - PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); - return *this; - } - PipelineShaderStageCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ ) - { - stage = stage_; - return *this; - } - - PipelineShaderStageCreateInfo& setModule( ShaderModule module_ ) - { - module = module_; - return *this; - } - - PipelineShaderStageCreateInfo& setPName( const char* pName_ ) - { - pName = pName_; - return *this; - } - - PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ ) - { - pSpecializationInfo = pSpecializationInfo_; - return *this; - } - - operator const VkPipelineShaderStageCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineShaderStageCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stage == rhs.stage ) - && ( module == rhs.module ) - && ( pName == rhs.pName ) - && ( pSpecializationInfo == rhs.pSpecializationInfo ); - } - - bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineShaderStageCreateInfo; - - public: - const void* pNext = nullptr; - PipelineShaderStageCreateFlags flags; - ShaderStageFlagBits stage; - ShaderModule module; - const char* pName; - const SpecializationInfo* pSpecializationInfo; - }; - static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); - - struct PushConstantRange - { - PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), - uint32_t offset_ = 0, - uint32_t size_ = 0 ) - : stageFlags( stageFlags_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - PushConstantRange( VkPushConstantRange const & rhs ) - { - memcpy( this, &rhs, sizeof( PushConstantRange ) ); - } - - PushConstantRange& operator=( VkPushConstantRange const & rhs ) - { - memcpy( this, &rhs, sizeof( PushConstantRange ) ); - return *this; - } - PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ ) - { - stageFlags = stageFlags_; - return *this; - } - - PushConstantRange& setOffset( uint32_t offset_ ) - { - offset = offset_; - return *this; - } - - PushConstantRange& setSize( uint32_t size_ ) - { - size = size_; - return *this; - } - - operator const VkPushConstantRange&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PushConstantRange const& rhs ) const - { - return ( stageFlags == rhs.stageFlags ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( PushConstantRange const& rhs ) const - { - return !operator==( rhs ); - } - - ShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; - }; - static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); - - struct PipelineLayoutCreateInfo - { - PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), - uint32_t setLayoutCount_ = 0, - const DescriptorSetLayout* pSetLayouts_ = nullptr, - uint32_t pushConstantRangeCount_ = 0, - const PushConstantRange* pPushConstantRanges_ = nullptr ) - : flags( flags_ ) - , setLayoutCount( setLayoutCount_ ) - , pSetLayouts( pSetLayouts_ ) - , pushConstantRangeCount( pushConstantRangeCount_ ) - , pPushConstantRanges( pPushConstantRanges_ ) - { - } - - PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); - } - - PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); - return *this; - } - PipelineLayoutCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ ) - { - setLayoutCount = setLayoutCount_; - return *this; - } - - PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) - { - pSetLayouts = pSetLayouts_; - return *this; - } - - PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) - { - pushConstantRangeCount = pushConstantRangeCount_; - return *this; - } - - PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ ) - { - pPushConstantRanges = pPushConstantRanges_; - return *this; - } - - operator const VkPipelineLayoutCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineLayoutCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( setLayoutCount == rhs.setLayoutCount ) - && ( pSetLayouts == rhs.pSetLayouts ) - && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) - && ( pPushConstantRanges == rhs.pPushConstantRanges ); - } - - bool operator!=( PipelineLayoutCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineLayoutCreateInfo; - - public: - const void* pNext = nullptr; - PipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const DescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const PushConstantRange* pPushConstantRanges; - }; - static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); - - struct ShaderStatisticsInfoAMD - { - operator const VkShaderStatisticsInfoAMD&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ShaderStatisticsInfoAMD const& rhs ) const - { - return ( shaderStageMask == rhs.shaderStageMask ) - && ( resourceUsage == rhs.resourceUsage ) - && ( numPhysicalVgprs == rhs.numPhysicalVgprs ) - && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) - && ( numAvailableVgprs == rhs.numAvailableVgprs ) - && ( numAvailableSgprs == rhs.numAvailableSgprs ) - && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ); - } - - bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const - { - return !operator==( rhs ); - } - - ShaderStageFlags shaderStageMask; - ShaderResourceUsageAMD resourceUsage; - uint32_t numPhysicalVgprs; - uint32_t numPhysicalSgprs; - uint32_t numAvailableVgprs; - uint32_t numAvailableSgprs; - uint32_t computeWorkGroupSize[3]; - }; - static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" ); - - enum class ImageUsageFlagBits - { - eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, - eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, - eStorage = VK_IMAGE_USAGE_STORAGE_BIT, - eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, - eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT - }; - - using ImageUsageFlags = Flags; - - VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 ) - { - return ImageUsageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits ) - { - return ~( ImageUsageFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) - }; - }; - - struct SharedPresentSurfaceCapabilitiesKHR - { - operator const VkSharedPresentSurfaceCapabilitiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); - } - - bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; - - public: - void* pNext = nullptr; - ImageUsageFlags sharedPresentSupportedUsageFlags; - }; - static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); - - struct ImageViewUsageCreateInfo - { - ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() ) - : usage( usage_ ) - { - } - - ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) ); - } - - ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) ); - return *this; - } - ImageViewUsageCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageViewUsageCreateInfo& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - operator const VkImageViewUsageCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageViewUsageCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( usage == rhs.usage ); - } - - bool operator!=( ImageViewUsageCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageViewUsageCreateInfo; - - public: - const void* pNext = nullptr; - ImageUsageFlags usage; - }; - static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" ); - - using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; - - enum class ImageCreateFlagBits - { - eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, - eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, - eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, - eAlias = VK_IMAGE_CREATE_ALIAS_BIT, - eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT, - eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, - eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, - e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, - e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, - eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, - eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, - eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, - eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, - eProtected = VK_IMAGE_CREATE_PROTECTED_BIT, - eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT, - eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT, - eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT - }; - - using ImageCreateFlags = Flags; - - VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 ) - { - return ImageCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits ) - { - return ~( ImageCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) - }; - }; - - struct PhysicalDeviceImageFormatInfo2 - { - PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined, - ImageType type_ = ImageType::e1D, - ImageTiling tiling_ = ImageTiling::eOptimal, - ImageUsageFlags usage_ = ImageUsageFlags(), - ImageCreateFlags flags_ = ImageCreateFlags() ) - : format( format_ ) - , type( type_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , flags( flags_ ) - { - } - - PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) ); - } - - PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) ); - return *this; - } - PhysicalDeviceImageFormatInfo2& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceImageFormatInfo2& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - PhysicalDeviceImageFormatInfo2& setType( ImageType type_ ) - { - type = type_; - return *this; - } - - PhysicalDeviceImageFormatInfo2& setTiling( ImageTiling tiling_ ) - { - tiling = tiling_; - return *this; - } - - PhysicalDeviceImageFormatInfo2& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - PhysicalDeviceImageFormatInfo2& setFlags( ImageCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkPhysicalDeviceImageFormatInfo2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceImageFormatInfo2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( type == rhs.type ) - && ( tiling == rhs.tiling ) - && ( usage == rhs.usage ) - && ( flags == rhs.flags ); - } - - bool operator!=( PhysicalDeviceImageFormatInfo2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; - - public: - const void* pNext = nullptr; - Format format; - ImageType type; - ImageTiling tiling; - ImageUsageFlags usage; - ImageCreateFlags flags; - }; - static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" ); - - using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; - - enum class PipelineCreateFlagBits - { - eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, - eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, - eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, - eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE, - eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE - }; - - using PipelineCreateFlags = Flags; - - VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 ) - { - return PipelineCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits ) - { - return ~( PipelineCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) - }; - }; - - struct ComputePipelineCreateInfo - { - ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), - PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), - PipelineLayout layout_ = PipelineLayout(), - Pipeline basePipelineHandle_ = Pipeline(), - int32_t basePipelineIndex_ = 0 ) - : flags( flags_ ) - , stage( stage_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } - - ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); - } - - ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); - return *this; - } - ComputePipelineCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ ) - { - stage = stage_; - return *this; - } - - ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ ) - { - layout = layout_; - return *this; - } - - ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - operator const VkComputePipelineCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ComputePipelineCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stage == rhs.stage ) - && ( layout == rhs.layout ) - && ( basePipelineHandle == rhs.basePipelineHandle ) - && ( basePipelineIndex == rhs.basePipelineIndex ); - } - - bool operator!=( ComputePipelineCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eComputePipelineCreateInfo; - - public: - const void* pNext = nullptr; - PipelineCreateFlags flags; - PipelineShaderStageCreateInfo stage; - PipelineLayout layout; - Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); - - enum class ColorComponentFlagBits - { - eR = VK_COLOR_COMPONENT_R_BIT, - eG = VK_COLOR_COMPONENT_G_BIT, - eB = VK_COLOR_COMPONENT_B_BIT, - eA = VK_COLOR_COMPONENT_A_BIT - }; - - using ColorComponentFlags = Flags; - - VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 ) - { - return ColorComponentFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits ) - { - return ~( ColorComponentFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA) - }; - }; - - struct PipelineColorBlendAttachmentState - { - PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, - BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, - BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, - BlendOp colorBlendOp_ = BlendOp::eAdd, - BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, - BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, - BlendOp alphaBlendOp_ = BlendOp::eAdd, - ColorComponentFlags colorWriteMask_ = ColorComponentFlags() ) - : blendEnable( blendEnable_ ) - , srcColorBlendFactor( srcColorBlendFactor_ ) - , dstColorBlendFactor( dstColorBlendFactor_ ) - , colorBlendOp( colorBlendOp_ ) - , srcAlphaBlendFactor( srcAlphaBlendFactor_ ) - , dstAlphaBlendFactor( dstAlphaBlendFactor_ ) - , alphaBlendOp( alphaBlendOp_ ) - , colorWriteMask( colorWriteMask_ ) - { - } - - PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); - } - - PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); - return *this; - } - PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ ) - { - blendEnable = blendEnable_; - return *this; - } - - PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) - { - srcColorBlendFactor = srcColorBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) - { - dstColorBlendFactor = dstColorBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ ) - { - colorBlendOp = colorBlendOp_; - return *this; - } - - PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) - { - srcAlphaBlendFactor = srcAlphaBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) - { - dstAlphaBlendFactor = dstAlphaBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ ) - { - alphaBlendOp = alphaBlendOp_; - return *this; - } - - PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ ) - { - colorWriteMask = colorWriteMask_; - return *this; - } - - operator const VkPipelineColorBlendAttachmentState&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineColorBlendAttachmentState const& rhs ) const - { - return ( blendEnable == rhs.blendEnable ) - && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) - && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) - && ( colorBlendOp == rhs.colorBlendOp ) - && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) - && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) - && ( alphaBlendOp == rhs.alphaBlendOp ) - && ( colorWriteMask == rhs.colorWriteMask ); - } - - bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const - { - return !operator==( rhs ); - } - - Bool32 blendEnable; - BlendFactor srcColorBlendFactor; - BlendFactor dstColorBlendFactor; - BlendOp colorBlendOp; - BlendFactor srcAlphaBlendFactor; - BlendFactor dstAlphaBlendFactor; - BlendOp alphaBlendOp; - ColorComponentFlags colorWriteMask; - }; - static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); - - struct PipelineColorBlendStateCreateInfo - { - PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), - Bool32 logicOpEnable_ = 0, - LogicOp logicOp_ = LogicOp::eClear, - uint32_t attachmentCount_ = 0, - const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, - std::array const& blendConstants_ = { { 0, 0, 0, 0 } } ) - : flags( flags_ ) - , logicOpEnable( logicOpEnable_ ) - , logicOp( logicOp_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - { - memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); - } - - PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); - } - - PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); - return *this; - } - PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ ) - { - logicOpEnable = logicOpEnable_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ ) - { - logicOp = logicOp_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) - { - attachmentCount = attachmentCount_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ ) - { - pAttachments = pAttachments_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setBlendConstants( std::array blendConstants_ ) - { - memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); - return *this; - } - - operator const VkPipelineColorBlendStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( logicOpEnable == rhs.logicOpEnable ) - && ( logicOp == rhs.logicOp ) - && ( attachmentCount == rhs.attachmentCount ) - && ( pAttachments == rhs.pAttachments ) - && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 ); - } - - bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineColorBlendStateCreateFlags flags; - Bool32 logicOpEnable; - LogicOp logicOp; - uint32_t attachmentCount; - const PipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; - }; - static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); - - enum class FenceCreateFlagBits - { - eSignaled = VK_FENCE_CREATE_SIGNALED_BIT - }; - - using FenceCreateFlags = Flags; - - VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 ) - { - return FenceCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits ) - { - return ~( FenceCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(FenceCreateFlagBits::eSignaled) - }; - }; - - struct FenceCreateInfo - { - FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() ) - : flags( flags_ ) - { - } - - FenceCreateInfo( VkFenceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); - } - - FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); - return *this; - } - FenceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FenceCreateInfo& setFlags( FenceCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkFenceCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( FenceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ); - } - - bool operator!=( FenceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFenceCreateInfo; - - public: - const void* pNext = nullptr; - FenceCreateFlags flags; - }; - static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); - - enum class FormatFeatureFlagBits - { - eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, - eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, - eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, - eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, - eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, - eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, - eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, - eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, - eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, - eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, - eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, - eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, - eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, - eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, - eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT, - eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT, - eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, - eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT - }; - - using FormatFeatureFlags = Flags; - - VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 ) - { - return FormatFeatureFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits ) - { - return ~( FormatFeatureFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) - }; - }; - - struct FormatProperties - { - operator const VkFormatProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( FormatProperties const& rhs ) const - { - return ( linearTilingFeatures == rhs.linearTilingFeatures ) - && ( optimalTilingFeatures == rhs.optimalTilingFeatures ) - && ( bufferFeatures == rhs.bufferFeatures ); - } - - bool operator!=( FormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - FormatFeatureFlags linearTilingFeatures; - FormatFeatureFlags optimalTilingFeatures; - FormatFeatureFlags bufferFeatures; - }; - static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); - - struct FormatProperties2 - { - operator const VkFormatProperties2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( FormatProperties2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( formatProperties == rhs.formatProperties ); - } - - bool operator!=( FormatProperties2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFormatProperties2; - - public: - void* pNext = nullptr; - FormatProperties formatProperties; - }; - static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" ); - - using FormatProperties2KHR = FormatProperties2; - - enum class QueryControlFlagBits - { - ePrecise = VK_QUERY_CONTROL_PRECISE_BIT - }; - - using QueryControlFlags = Flags; - - VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 ) - { - return QueryControlFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits ) - { - return ~( QueryControlFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(QueryControlFlagBits::ePrecise) - }; - }; - - enum class QueryResultFlagBits - { - e64 = VK_QUERY_RESULT_64_BIT, - eWait = VK_QUERY_RESULT_WAIT_BIT, - eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, - ePartial = VK_QUERY_RESULT_PARTIAL_BIT - }; - - using QueryResultFlags = Flags; - - VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 ) - { - return QueryResultFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits ) - { - return ~( QueryResultFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial) - }; - }; - - enum class CommandBufferUsageFlagBits - { - eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, - eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, - eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT - }; - - using CommandBufferUsageFlags = Flags; - - VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 ) - { - return CommandBufferUsageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits ) - { - return ~( CommandBufferUsageFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse) - }; - }; - - enum class QueryPipelineStatisticFlagBits - { - eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, - eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, - eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, - eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, - eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, - eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, - eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, - eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, - eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, - eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, - eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT - }; - - using QueryPipelineStatisticFlags = Flags; - - VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 ) - { - return QueryPipelineStatisticFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits ) - { - return ~( QueryPipelineStatisticFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations) - }; - }; - - struct CommandBufferInheritanceInfo - { - CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), - uint32_t subpass_ = 0, - Framebuffer framebuffer_ = Framebuffer(), - Bool32 occlusionQueryEnable_ = 0, - QueryControlFlags queryFlags_ = QueryControlFlags(), - QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : renderPass( renderPass_ ) - , subpass( subpass_ ) - , framebuffer( framebuffer_ ) - , occlusionQueryEnable( occlusionQueryEnable_ ) - , queryFlags( queryFlags_ ) - , pipelineStatistics( pipelineStatistics_ ) - { - } - - CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); - } - - CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); - return *this; - } - CommandBufferInheritanceInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ ) - { - subpass = subpass_; - return *this; - } - - CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ ) - { - framebuffer = framebuffer_; - return *this; - } - - CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) - { - occlusionQueryEnable = occlusionQueryEnable_; - return *this; - } - - CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ ) - { - queryFlags = queryFlags_; - return *this; - } - - CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) - { - pipelineStatistics = pipelineStatistics_; - return *this; - } - - operator const VkCommandBufferInheritanceInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( CommandBufferInheritanceInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( renderPass == rhs.renderPass ) - && ( subpass == rhs.subpass ) - && ( framebuffer == rhs.framebuffer ) - && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) - && ( queryFlags == rhs.queryFlags ) - && ( pipelineStatistics == rhs.pipelineStatistics ); - } - - bool operator!=( CommandBufferInheritanceInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandBufferInheritanceInfo; - - public: - const void* pNext = nullptr; - RenderPass renderPass; - uint32_t subpass; - Framebuffer framebuffer; - Bool32 occlusionQueryEnable; - QueryControlFlags queryFlags; - QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); - - struct CommandBufferBeginInfo - { - CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), - const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) - : flags( flags_ ) - , pInheritanceInfo( pInheritanceInfo_ ) - { - } - - CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); - } - - CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); - return *this; - } - CommandBufferBeginInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ ) - { - flags = flags_; - return *this; - } - - CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ ) - { - pInheritanceInfo = pInheritanceInfo_; - return *this; - } - - operator const VkCommandBufferBeginInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( CommandBufferBeginInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pInheritanceInfo == rhs.pInheritanceInfo ); - } - - bool operator!=( CommandBufferBeginInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandBufferBeginInfo; - - public: - const void* pNext = nullptr; - CommandBufferUsageFlags flags; - const CommandBufferInheritanceInfo* pInheritanceInfo; - }; - static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); - - struct QueryPoolCreateInfo - { - QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), - QueryType queryType_ = QueryType::eOcclusion, - uint32_t queryCount_ = 0, - QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : flags( flags_ ) - , queryType( queryType_ ) - , queryCount( queryCount_ ) - , pipelineStatistics( pipelineStatistics_ ) - { - } - - QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); - } - - QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); - return *this; - } - QueryPoolCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - QueryPoolCreateInfo& setQueryType( QueryType queryType_ ) - { - queryType = queryType_; - return *this; - } - - QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ ) - { - queryCount = queryCount_; - return *this; - } - - QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) - { - pipelineStatistics = pipelineStatistics_; - return *this; - } - - operator const VkQueryPoolCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( QueryPoolCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queryType == rhs.queryType ) - && ( queryCount == rhs.queryCount ) - && ( pipelineStatistics == rhs.pipelineStatistics ); - } - - bool operator!=( QueryPoolCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eQueryPoolCreateInfo; - - public: - const void* pNext = nullptr; - QueryPoolCreateFlags flags; - QueryType queryType; - uint32_t queryCount; - QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); - - enum class ImageAspectFlagBits - { - eColor = VK_IMAGE_ASPECT_COLOR_BIT, - eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, - eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, - eMetadata = VK_IMAGE_ASPECT_METADATA_BIT, - ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT, - ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, - ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT, - ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, - ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT, - ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT - }; - - using ImageAspectFlags = Flags; - - VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 ) - { - return ImageAspectFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits ) - { - return ~( ImageAspectFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0) | VkFlags(ImageAspectFlagBits::ePlane1) | VkFlags(ImageAspectFlagBits::ePlane2) - }; - }; - - struct ImageSubresource - { - ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), - uint32_t mipLevel_ = 0, - uint32_t arrayLayer_ = 0 ) - : aspectMask( aspectMask_ ) - , mipLevel( mipLevel_ ) - , arrayLayer( arrayLayer_ ) - { - } - - ImageSubresource( VkImageSubresource const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresource ) ); - } - - ImageSubresource& operator=( VkImageSubresource const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresource ) ); - return *this; - } - ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ImageSubresource& setMipLevel( uint32_t mipLevel_ ) - { - mipLevel = mipLevel_; - return *this; - } - - ImageSubresource& setArrayLayer( uint32_t arrayLayer_ ) - { - arrayLayer = arrayLayer_; - return *this; - } - - operator const VkImageSubresource&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageSubresource const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( mipLevel == rhs.mipLevel ) - && ( arrayLayer == rhs.arrayLayer ); - } - - bool operator!=( ImageSubresource const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t arrayLayer; - }; - static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); - - struct ImageSubresourceLayers - { - ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), - uint32_t mipLevel_ = 0, - uint32_t baseArrayLayer_ = 0, - uint32_t layerCount_ = 0 ) - : aspectMask( aspectMask_ ) - , mipLevel( mipLevel_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } - - ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); - } - - ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); - return *this; - } - ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ ) - { - mipLevel = mipLevel_; - return *this; - } - - ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ ) - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } - - operator const VkImageSubresourceLayers&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageSubresourceLayers const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( mipLevel == rhs.mipLevel ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } - - bool operator!=( ImageSubresourceLayers const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; - }; - static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" ); - - struct ImageSubresourceRange - { - ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), - uint32_t baseMipLevel_ = 0, - uint32_t levelCount_ = 0, - uint32_t baseArrayLayer_ = 0, - uint32_t layerCount_ = 0 ) - : aspectMask( aspectMask_ ) - , baseMipLevel( baseMipLevel_ ) - , levelCount( levelCount_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } - - ImageSubresourceRange( VkImageSubresourceRange const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); - } - - ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); - return *this; - } - ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ ) - { - baseMipLevel = baseMipLevel_; - return *this; - } - - ImageSubresourceRange& setLevelCount( uint32_t levelCount_ ) - { - levelCount = levelCount_; - return *this; - } - - ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ ) - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - ImageSubresourceRange& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } - - operator const VkImageSubresourceRange&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageSubresourceRange const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( baseMipLevel == rhs.baseMipLevel ) - && ( levelCount == rhs.levelCount ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } - - bool operator!=( ImageSubresourceRange const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t levelCount; - uint32_t baseArrayLayer; - uint32_t layerCount; - }; - static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); - - struct ImageMemoryBarrier - { - ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), - AccessFlags dstAccessMask_ = AccessFlags(), - ImageLayout oldLayout_ = ImageLayout::eUndefined, - ImageLayout newLayout_ = ImageLayout::eUndefined, - uint32_t srcQueueFamilyIndex_ = 0, - uint32_t dstQueueFamilyIndex_ = 0, - Image image_ = Image(), - ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , oldLayout( oldLayout_ ) - , newLayout( newLayout_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , image( image_ ) - , subresourceRange( subresourceRange_ ) - { - } - - ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); - } - - ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); - return *this; - } - ImageMemoryBarrier& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ ) - { - oldLayout = oldLayout_; - return *this; - } - - ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ ) - { - newLayout = newLayout_; - return *this; - } - - ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - ImageMemoryBarrier& setImage( Image image_ ) - { - image = image_; - return *this; - } - - ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) - { - subresourceRange = subresourceRange_; - return *this; - } - - operator const VkImageMemoryBarrier&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageMemoryBarrier const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( oldLayout == rhs.oldLayout ) - && ( newLayout == rhs.newLayout ) - && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) - && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) - && ( image == rhs.image ) - && ( subresourceRange == rhs.subresourceRange ); - } - - bool operator!=( ImageMemoryBarrier const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageMemoryBarrier; - - public: - const void* pNext = nullptr; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - ImageLayout oldLayout; - ImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - Image image; - ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); - - struct ImageViewCreateInfo - { - ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), - Image image_ = Image(), - ImageViewType viewType_ = ImageViewType::e1D, - Format format_ = Format::eUndefined, - ComponentMapping components_ = ComponentMapping(), - ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) - : flags( flags_ ) - , image( image_ ) - , viewType( viewType_ ) - , format( format_ ) - , components( components_ ) - , subresourceRange( subresourceRange_ ) - { - } - - ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); - } - - ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); - return *this; - } - ImageViewCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImageViewCreateInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - ImageViewCreateInfo& setViewType( ImageViewType viewType_ ) - { - viewType = viewType_; - return *this; - } - - ImageViewCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - ImageViewCreateInfo& setComponents( ComponentMapping components_ ) - { - components = components_; - return *this; - } - - ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) - { - subresourceRange = subresourceRange_; - return *this; - } - - operator const VkImageViewCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageViewCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( image == rhs.image ) - && ( viewType == rhs.viewType ) - && ( format == rhs.format ) - && ( components == rhs.components ) - && ( subresourceRange == rhs.subresourceRange ); - } - - bool operator!=( ImageViewCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageViewCreateInfo; - - public: - const void* pNext = nullptr; - ImageViewCreateFlags flags; - Image image; - ImageViewType viewType; - Format format; - ComponentMapping components; - ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); - - struct ImageCopy - { - ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), - Offset3D srcOffset_ = Offset3D(), - ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), - Offset3D dstOffset_ = Offset3D(), - Extent3D extent_ = Extent3D() ) - : srcSubresource( srcSubresource_ ) - , srcOffset( srcOffset_ ) - , dstSubresource( dstSubresource_ ) - , dstOffset( dstOffset_ ) - , extent( extent_ ) - { - } - - ImageCopy( VkImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCopy ) ); - } - - ImageCopy& operator=( VkImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCopy ) ); - return *this; - } - ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) - { - srcSubresource = srcSubresource_; - return *this; - } - - ImageCopy& setSrcOffset( Offset3D srcOffset_ ) - { - srcOffset = srcOffset_; - return *this; - } - - ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) - { - dstSubresource = dstSubresource_; - return *this; - } - - ImageCopy& setDstOffset( Offset3D dstOffset_ ) - { - dstOffset = dstOffset_; - return *this; - } - - ImageCopy& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - operator const VkImageCopy&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageCopy const& rhs ) const - { - return ( srcSubresource == rhs.srcSubresource ) - && ( srcOffset == rhs.srcOffset ) - && ( dstSubresource == rhs.dstSubresource ) - && ( dstOffset == rhs.dstOffset ) - && ( extent == rhs.extent ); - } - - bool operator!=( ImageCopy const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresourceLayers srcSubresource; - Offset3D srcOffset; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffset; - Extent3D extent; - }; - static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); - - struct ImageBlit - { - ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), - std::array const& srcOffsets_ = { { Offset3D(), Offset3D() } }, - ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), - std::array const& dstOffsets_ = { { Offset3D(), Offset3D() } } ) - : srcSubresource( srcSubresource_ ) - , dstSubresource( dstSubresource_ ) - { - memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); - memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); - } - - ImageBlit( VkImageBlit const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageBlit ) ); - } - - ImageBlit& operator=( VkImageBlit const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageBlit ) ); - return *this; - } - ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) - { - srcSubresource = srcSubresource_; - return *this; - } - - ImageBlit& setSrcOffsets( std::array srcOffsets_ ) - { - memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); - return *this; - } - - ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) - { - dstSubresource = dstSubresource_; - return *this; - } - - ImageBlit& setDstOffsets( std::array dstOffsets_ ) - { - memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); - return *this; - } - - operator const VkImageBlit&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageBlit const& rhs ) const - { - return ( srcSubresource == rhs.srcSubresource ) - && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 ) - && ( dstSubresource == rhs.dstSubresource ) - && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 ); - } - - bool operator!=( ImageBlit const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresourceLayers srcSubresource; - Offset3D srcOffsets[2]; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffsets[2]; - }; - static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); - - struct BufferImageCopy - { - BufferImageCopy( DeviceSize bufferOffset_ = 0, - uint32_t bufferRowLength_ = 0, - uint32_t bufferImageHeight_ = 0, - ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), - Offset3D imageOffset_ = Offset3D(), - Extent3D imageExtent_ = Extent3D() ) - : bufferOffset( bufferOffset_ ) - , bufferRowLength( bufferRowLength_ ) - , bufferImageHeight( bufferImageHeight_ ) - , imageSubresource( imageSubresource_ ) - , imageOffset( imageOffset_ ) - , imageExtent( imageExtent_ ) - { - } - - BufferImageCopy( VkBufferImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferImageCopy ) ); - } - - BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferImageCopy ) ); - return *this; - } - BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ ) - { - bufferOffset = bufferOffset_; - return *this; - } - - BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ ) - { - bufferRowLength = bufferRowLength_; - return *this; - } - - BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ ) - { - bufferImageHeight = bufferImageHeight_; - return *this; - } - - BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ ) - { - imageSubresource = imageSubresource_; - return *this; - } - - BufferImageCopy& setImageOffset( Offset3D imageOffset_ ) - { - imageOffset = imageOffset_; - return *this; - } - - BufferImageCopy& setImageExtent( Extent3D imageExtent_ ) - { - imageExtent = imageExtent_; - return *this; - } - - operator const VkBufferImageCopy&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BufferImageCopy const& rhs ) const - { - return ( bufferOffset == rhs.bufferOffset ) - && ( bufferRowLength == rhs.bufferRowLength ) - && ( bufferImageHeight == rhs.bufferImageHeight ) - && ( imageSubresource == rhs.imageSubresource ) - && ( imageOffset == rhs.imageOffset ) - && ( imageExtent == rhs.imageExtent ); - } - - bool operator!=( BufferImageCopy const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - ImageSubresourceLayers imageSubresource; - Offset3D imageOffset; - Extent3D imageExtent; - }; - static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); - - struct ImageResolve - { - ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), - Offset3D srcOffset_ = Offset3D(), - ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), - Offset3D dstOffset_ = Offset3D(), - Extent3D extent_ = Extent3D() ) - : srcSubresource( srcSubresource_ ) - , srcOffset( srcOffset_ ) - , dstSubresource( dstSubresource_ ) - , dstOffset( dstOffset_ ) - , extent( extent_ ) - { - } - - ImageResolve( VkImageResolve const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageResolve ) ); - } - - ImageResolve& operator=( VkImageResolve const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageResolve ) ); - return *this; - } - ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) - { - srcSubresource = srcSubresource_; - return *this; - } - - ImageResolve& setSrcOffset( Offset3D srcOffset_ ) - { - srcOffset = srcOffset_; - return *this; - } - - ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) - { - dstSubresource = dstSubresource_; - return *this; - } - - ImageResolve& setDstOffset( Offset3D dstOffset_ ) - { - dstOffset = dstOffset_; - return *this; - } - - ImageResolve& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - operator const VkImageResolve&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageResolve const& rhs ) const - { - return ( srcSubresource == rhs.srcSubresource ) - && ( srcOffset == rhs.srcOffset ) - && ( dstSubresource == rhs.dstSubresource ) - && ( dstOffset == rhs.dstOffset ) - && ( extent == rhs.extent ); - } - - bool operator!=( ImageResolve const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresourceLayers srcSubresource; - Offset3D srcOffset; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffset; - Extent3D extent; - }; - static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); - - struct ClearAttachment - { - ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), - uint32_t colorAttachment_ = 0, - ClearValue clearValue_ = ClearValue() ) - : aspectMask( aspectMask_ ) - , colorAttachment( colorAttachment_ ) - , clearValue( clearValue_ ) - { - } - - ClearAttachment( VkClearAttachment const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearAttachment ) ); - } - - ClearAttachment& operator=( VkClearAttachment const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearAttachment ) ); - return *this; - } - ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ClearAttachment& setColorAttachment( uint32_t colorAttachment_ ) - { - colorAttachment = colorAttachment_; - return *this; - } - - ClearAttachment& setClearValue( ClearValue clearValue_ ) - { - clearValue = clearValue_; - return *this; - } - - operator const VkClearAttachment&() const - { - return *reinterpret_cast(this); - } - - ImageAspectFlags aspectMask; - uint32_t colorAttachment; - ClearValue clearValue; - }; - static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); - - struct InputAttachmentAspectReference - { - InputAttachmentAspectReference( uint32_t subpass_ = 0, - uint32_t inputAttachmentIndex_ = 0, - ImageAspectFlags aspectMask_ = ImageAspectFlags() ) - : subpass( subpass_ ) - , inputAttachmentIndex( inputAttachmentIndex_ ) - , aspectMask( aspectMask_ ) - { - } - - InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) - { - memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) ); - } - - InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs ) - { - memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) ); - return *this; - } - InputAttachmentAspectReference& setSubpass( uint32_t subpass_ ) - { - subpass = subpass_; - return *this; - } - - InputAttachmentAspectReference& setInputAttachmentIndex( uint32_t inputAttachmentIndex_ ) - { - inputAttachmentIndex = inputAttachmentIndex_; - return *this; - } - - InputAttachmentAspectReference& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - operator const VkInputAttachmentAspectReference&() const - { - return *reinterpret_cast(this); - } - - bool operator==( InputAttachmentAspectReference const& rhs ) const - { - return ( subpass == rhs.subpass ) - && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) - && ( aspectMask == rhs.aspectMask ); - } - - bool operator!=( InputAttachmentAspectReference const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t subpass; - uint32_t inputAttachmentIndex; - ImageAspectFlags aspectMask; - }; - static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" ); - - using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; - - struct RenderPassInputAttachmentAspectCreateInfo - { - RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0, - const InputAttachmentAspectReference* pAspectReferences_ = nullptr ) - : aspectReferenceCount( aspectReferenceCount_ ) - , pAspectReferences( pAspectReferences_ ) - { - } - - RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) ); - } - - RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) ); - return *this; - } - RenderPassInputAttachmentAspectCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassInputAttachmentAspectCreateInfo& setAspectReferenceCount( uint32_t aspectReferenceCount_ ) - { - aspectReferenceCount = aspectReferenceCount_; - return *this; - } - - RenderPassInputAttachmentAspectCreateInfo& setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ ) - { - pAspectReferences = pAspectReferences_; - return *this; - } - - operator const VkRenderPassInputAttachmentAspectCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( aspectReferenceCount == rhs.aspectReferenceCount ) - && ( pAspectReferences == rhs.pAspectReferences ); - } - - bool operator!=( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; - - public: - const void* pNext = nullptr; - uint32_t aspectReferenceCount; - const InputAttachmentAspectReference* pAspectReferences; - }; - static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" ); - - using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; - - struct BindImagePlaneMemoryInfo - { - BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) - : planeAspect( planeAspect_ ) - { - } - - BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) ); - } - - BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) ); - return *this; - } - BindImagePlaneMemoryInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImagePlaneMemoryInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ ) - { - planeAspect = planeAspect_; - return *this; - } - - operator const VkBindImagePlaneMemoryInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BindImagePlaneMemoryInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( planeAspect == rhs.planeAspect ); - } - - bool operator!=( BindImagePlaneMemoryInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImagePlaneMemoryInfo; - - public: - const void* pNext = nullptr; - ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" ); - - using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; - - struct ImagePlaneMemoryRequirementsInfo - { - ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) - : planeAspect( planeAspect_ ) - { - } - - ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) ); - } - - ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) ); - return *this; - } - ImagePlaneMemoryRequirementsInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImagePlaneMemoryRequirementsInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ ) - { - planeAspect = planeAspect_; - return *this; - } - - operator const VkImagePlaneMemoryRequirementsInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImagePlaneMemoryRequirementsInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( planeAspect == rhs.planeAspect ); - } - - bool operator!=( ImagePlaneMemoryRequirementsInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; - - public: - const void* pNext = nullptr; - ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" ); - - using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; - - enum class SparseImageFormatFlagBits - { - eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, - eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, - eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT - }; - - using SparseImageFormatFlags = Flags; - - VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 ) - { - return SparseImageFormatFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits ) - { - return ~( SparseImageFormatFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize) - }; - }; - - struct SparseImageFormatProperties - { - operator const VkSparseImageFormatProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageFormatProperties const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( imageGranularity == rhs.imageGranularity ) - && ( flags == rhs.flags ); - } - - bool operator!=( SparseImageFormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - Extent3D imageGranularity; - SparseImageFormatFlags flags; - }; - static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryRequirements - { - operator const VkSparseImageMemoryRequirements&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageMemoryRequirements const& rhs ) const - { - return ( formatProperties == rhs.formatProperties ) - && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) - && ( imageMipTailSize == rhs.imageMipTailSize ) - && ( imageMipTailOffset == rhs.imageMipTailOffset ) - && ( imageMipTailStride == rhs.imageMipTailStride ); - } - - bool operator!=( SparseImageMemoryRequirements const& rhs ) const - { - return !operator==( rhs ); - } - - SparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - DeviceSize imageMipTailSize; - DeviceSize imageMipTailOffset; - DeviceSize imageMipTailStride; - }; - static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); - - struct SparseImageFormatProperties2 - { - operator const VkSparseImageFormatProperties2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageFormatProperties2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( properties == rhs.properties ); - } - - bool operator!=( SparseImageFormatProperties2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSparseImageFormatProperties2; - - public: - void* pNext = nullptr; - SparseImageFormatProperties properties; - }; - static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" ); - - using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; - - struct SparseImageMemoryRequirements2 - { - operator const VkSparseImageMemoryRequirements2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageMemoryRequirements2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryRequirements == rhs.memoryRequirements ); - } - - bool operator!=( SparseImageMemoryRequirements2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSparseImageMemoryRequirements2; - - public: - void* pNext = nullptr; - SparseImageMemoryRequirements memoryRequirements; - }; - static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" ); - - using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; - - enum class SparseMemoryBindFlagBits - { - eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT - }; - - using SparseMemoryBindFlags = Flags; - - VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 ) - { - return SparseMemoryBindFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits ) - { - return ~( SparseMemoryBindFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata) - }; - }; - - struct SparseMemoryBind - { - SparseMemoryBind( DeviceSize resourceOffset_ = 0, - DeviceSize size_ = 0, - DeviceMemory memory_ = DeviceMemory(), - DeviceSize memoryOffset_ = 0, - SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) - : resourceOffset( resourceOffset_ ) - , size( size_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , flags( flags_ ) - { - } - - SparseMemoryBind( VkSparseMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); - } - - SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); - return *this; - } - SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ ) - { - resourceOffset = resourceOffset_; - return *this; - } - - SparseMemoryBind& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - SparseMemoryBind& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkSparseMemoryBind&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseMemoryBind const& rhs ) const - { - return ( resourceOffset == rhs.resourceOffset ) - && ( size == rhs.size ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ) - && ( flags == rhs.flags ); - } - - bool operator!=( SparseMemoryBind const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize resourceOffset; - DeviceSize size; - DeviceMemory memory; - DeviceSize memoryOffset; - SparseMemoryBindFlags flags; - }; - static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryBind - { - SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), - Offset3D offset_ = Offset3D(), - Extent3D extent_ = Extent3D(), - DeviceMemory memory_ = DeviceMemory(), - DeviceSize memoryOffset_ = 0, - SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) - : subresource( subresource_ ) - , offset( offset_ ) - , extent( extent_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , flags( flags_ ) - { - } - - SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); - } - - SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); - return *this; - } - SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ ) - { - subresource = subresource_; - return *this; - } - - SparseImageMemoryBind& setOffset( Offset3D offset_ ) - { - offset = offset_; - return *this; - } - - SparseImageMemoryBind& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - SparseImageMemoryBind& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkSparseImageMemoryBind&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageMemoryBind const& rhs ) const - { - return ( subresource == rhs.subresource ) - && ( offset == rhs.offset ) - && ( extent == rhs.extent ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ) - && ( flags == rhs.flags ); - } - - bool operator!=( SparseImageMemoryBind const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresource subresource; - Offset3D offset; - Extent3D extent; - DeviceMemory memory; - DeviceSize memoryOffset; - SparseMemoryBindFlags flags; - }; - static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" ); - - struct SparseBufferMemoryBindInfo - { - SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), - uint32_t bindCount_ = 0, - const SparseMemoryBind* pBinds_ = nullptr ) - : buffer( buffer_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) - { - } - - SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); - } - - SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); - return *this; - } - SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ ) - { - bindCount = bindCount_; - return *this; - } - - SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) - { - pBinds = pBinds_; - return *this; - } - - operator const VkSparseBufferMemoryBindInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseBufferMemoryBindInfo const& rhs ) const - { - return ( buffer == rhs.buffer ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); - } - - bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Buffer buffer; - uint32_t bindCount; - const SparseMemoryBind* pBinds; - }; - static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" ); - - struct SparseImageOpaqueMemoryBindInfo - { - SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), - uint32_t bindCount_ = 0, - const SparseMemoryBind* pBinds_ = nullptr ) - : image( image_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) - { - } - - SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); - } - - SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); - return *this; - } - SparseImageOpaqueMemoryBindInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ ) - { - bindCount = bindCount_; - return *this; - } - - SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) - { - pBinds = pBinds_; - return *this; - } - - operator const VkSparseImageOpaqueMemoryBindInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const - { - return ( image == rhs.image ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); - } - - bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Image image; - uint32_t bindCount; - const SparseMemoryBind* pBinds; - }; - static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryBindInfo - { - SparseImageMemoryBindInfo( Image image_ = Image(), - uint32_t bindCount_ = 0, - const SparseImageMemoryBind* pBinds_ = nullptr ) - : image( image_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) - { - } - - SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); - } - - SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); - return *this; - } - SparseImageMemoryBindInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ ) - { - bindCount = bindCount_; - return *this; - } - - SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ ) - { - pBinds = pBinds_; - return *this; - } - - operator const VkSparseImageMemoryBindInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageMemoryBindInfo const& rhs ) const - { - return ( image == rhs.image ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); - } - - bool operator!=( SparseImageMemoryBindInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Image image; - uint32_t bindCount; - const SparseImageMemoryBind* pBinds; - }; - static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); - - struct BindSparseInfo - { - BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, - const Semaphore* pWaitSemaphores_ = nullptr, - uint32_t bufferBindCount_ = 0, - const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, - uint32_t imageOpaqueBindCount_ = 0, - const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, - uint32_t imageBindCount_ = 0, - const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const Semaphore* pSignalSemaphores_ = nullptr ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , bufferBindCount( bufferBindCount_ ) - , pBufferBinds( pBufferBinds_ ) - , imageOpaqueBindCount( imageOpaqueBindCount_ ) - , pImageOpaqueBinds( pImageOpaqueBinds_ ) - , imageBindCount( imageBindCount_ ) - , pImageBinds( pImageBinds_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - { - } - - BindSparseInfo( VkBindSparseInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindSparseInfo ) ); - } - - BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindSparseInfo ) ); - return *this; - } - BindSparseInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ ) - { - bufferBindCount = bufferBindCount_; - return *this; - } - - BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ ) - { - pBufferBinds = pBufferBinds_; - return *this; - } - - BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) - { - imageOpaqueBindCount = imageOpaqueBindCount_; - return *this; - } - - BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ ) - { - pImageOpaqueBinds = pImageOpaqueBinds_; - return *this; - } - - BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ ) - { - imageBindCount = imageBindCount_; - return *this; - } - - BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ ) - { - pImageBinds = pImageBinds_; - return *this; - } - - BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) - { - pSignalSemaphores = pSignalSemaphores_; - return *this; - } - - operator const VkBindSparseInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BindSparseInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( bufferBindCount == rhs.bufferBindCount ) - && ( pBufferBinds == rhs.pBufferBinds ) - && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) - && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) - && ( imageBindCount == rhs.imageBindCount ) - && ( pImageBinds == rhs.pImageBinds ) - && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) - && ( pSignalSemaphores == rhs.pSignalSemaphores ); - } - - bool operator!=( BindSparseInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindSparseInfo; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const SparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const SparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); - - enum class PipelineStageFlagBits - { - eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, - eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, - eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, - eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, - eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, - eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, - eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, - eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, - eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, - eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, - eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - eHost = VK_PIPELINE_STAGE_HOST_BIT, - eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, - eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX - }; - - using PipelineStageFlags = Flags; - - VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 ) - { - return PipelineStageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits ) - { - return ~( PipelineStageFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) - }; - }; - - enum class CommandPoolCreateFlagBits - { - eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, - eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, - eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT - }; - - using CommandPoolCreateFlags = Flags; - - VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 ) - { - return CommandPoolCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits ) - { - return ~( CommandPoolCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) | VkFlags(CommandPoolCreateFlagBits::eProtected) - }; - }; - - struct CommandPoolCreateInfo - { - CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), - uint32_t queueFamilyIndex_ = 0 ) - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - { - } - - CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); - } - - CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); - return *this; - } - CommandPoolCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - operator const VkCommandPoolCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( CommandPoolCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueFamilyIndex == rhs.queueFamilyIndex ); - } - - bool operator!=( CommandPoolCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandPoolCreateInfo; - - public: - const void* pNext = nullptr; - CommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; - }; - static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); - - enum class CommandPoolResetFlagBits - { - eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT - }; - - using CommandPoolResetFlags = Flags; - - VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 ) - { - return CommandPoolResetFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits ) - { - return ~( CommandPoolResetFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources) - }; - }; - - enum class CommandBufferResetFlagBits - { - eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT - }; - - using CommandBufferResetFlags = Flags; - - VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 ) - { - return CommandBufferResetFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits ) - { - return ~( CommandBufferResetFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources) - }; - }; - - enum class SampleCountFlagBits - { - e1 = VK_SAMPLE_COUNT_1_BIT, - e2 = VK_SAMPLE_COUNT_2_BIT, - e4 = VK_SAMPLE_COUNT_4_BIT, - e8 = VK_SAMPLE_COUNT_8_BIT, - e16 = VK_SAMPLE_COUNT_16_BIT, - e32 = VK_SAMPLE_COUNT_32_BIT, - e64 = VK_SAMPLE_COUNT_64_BIT - }; - - using SampleCountFlags = Flags; - - VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 ) - { - return SampleCountFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits ) - { - return ~( SampleCountFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64) - }; - }; - - struct ImageFormatProperties - { - operator const VkImageFormatProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageFormatProperties const& rhs ) const - { - return ( maxExtent == rhs.maxExtent ) - && ( maxMipLevels == rhs.maxMipLevels ) - && ( maxArrayLayers == rhs.maxArrayLayers ) - && ( sampleCounts == rhs.sampleCounts ) - && ( maxResourceSize == rhs.maxResourceSize ); - } - - bool operator!=( ImageFormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - Extent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - SampleCountFlags sampleCounts; - DeviceSize maxResourceSize; - }; - static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" ); - - struct ImageCreateInfo - { - ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), - ImageType imageType_ = ImageType::e1D, - Format format_ = Format::eUndefined, - Extent3D extent_ = Extent3D(), - uint32_t mipLevels_ = 0, - uint32_t arrayLayers_ = 0, - SampleCountFlagBits samples_ = SampleCountFlagBits::e1, - ImageTiling tiling_ = ImageTiling::eOptimal, - ImageUsageFlags usage_ = ImageUsageFlags(), - SharingMode sharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr, - ImageLayout initialLayout_ = ImageLayout::eUndefined ) - : flags( flags_ ) - , imageType( imageType_ ) - , format( format_ ) - , extent( extent_ ) - , mipLevels( mipLevels_ ) - , arrayLayers( arrayLayers_ ) - , samples( samples_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , initialLayout( initialLayout_ ) - { - } - - ImageCreateInfo( VkImageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); - } - - ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); - return *this; - } - ImageCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageCreateInfo& setFlags( ImageCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImageCreateInfo& setImageType( ImageType imageType_ ) - { - imageType = imageType_; - return *this; - } - - ImageCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - ImageCreateInfo& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - ImageCreateInfo& setMipLevels( uint32_t mipLevels_ ) - { - mipLevels = mipLevels_; - return *this; - } - - ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ ) - { - arrayLayers = arrayLayers_; - return *this; - } - - ImageCreateInfo& setSamples( SampleCountFlagBits samples_ ) - { - samples = samples_; - return *this; - } - - ImageCreateInfo& setTiling( ImageTiling tiling_ ) - { - tiling = tiling_; - return *this; - } - - ImageCreateInfo& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - ImageCreateInfo& setSharingMode( SharingMode sharingMode_ ) - { - sharingMode = sharingMode_; - return *this; - } - - ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ ) - { - initialLayout = initialLayout_; - return *this; - } - - operator const VkImageCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( imageType == rhs.imageType ) - && ( format == rhs.format ) - && ( extent == rhs.extent ) - && ( mipLevels == rhs.mipLevels ) - && ( arrayLayers == rhs.arrayLayers ) - && ( samples == rhs.samples ) - && ( tiling == rhs.tiling ) - && ( usage == rhs.usage ) - && ( sharingMode == rhs.sharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) - && ( initialLayout == rhs.initialLayout ); - } - - bool operator!=( ImageCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageCreateInfo; - - public: - const void* pNext = nullptr; - ImageCreateFlags flags; - ImageType imageType; - Format format; - Extent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - SampleCountFlagBits samples; - ImageTiling tiling; - ImageUsageFlags usage; - SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - ImageLayout initialLayout; - }; - static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineMultisampleStateCreateInfo - { - PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), - SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, - Bool32 sampleShadingEnable_ = 0, - float minSampleShading_ = 0, - const SampleMask* pSampleMask_ = nullptr, - Bool32 alphaToCoverageEnable_ = 0, - Bool32 alphaToOneEnable_ = 0 ) - : flags( flags_ ) - , rasterizationSamples( rasterizationSamples_ ) - , sampleShadingEnable( sampleShadingEnable_ ) - , minSampleShading( minSampleShading_ ) - , pSampleMask( pSampleMask_ ) - , alphaToCoverageEnable( alphaToCoverageEnable_ ) - , alphaToOneEnable( alphaToOneEnable_ ) - { - } - - PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); - } - - PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); - return *this; - } - PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) - { - rasterizationSamples = rasterizationSamples_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ ) - { - sampleShadingEnable = sampleShadingEnable_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ ) - { - minSampleShading = minSampleShading_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ ) - { - pSampleMask = pSampleMask_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) - { - alphaToCoverageEnable = alphaToCoverageEnable_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) - { - alphaToOneEnable = alphaToOneEnable_; - return *this; - } - - operator const VkPipelineMultisampleStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( rasterizationSamples == rhs.rasterizationSamples ) - && ( sampleShadingEnable == rhs.sampleShadingEnable ) - && ( minSampleShading == rhs.minSampleShading ) - && ( pSampleMask == rhs.pSampleMask ) - && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) - && ( alphaToOneEnable == rhs.alphaToOneEnable ); - } - - bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineMultisampleStateCreateFlags flags; - SampleCountFlagBits rasterizationSamples; - Bool32 sampleShadingEnable; - float minSampleShading; - const SampleMask* pSampleMask; - Bool32 alphaToCoverageEnable; - Bool32 alphaToOneEnable; - }; - static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); - - struct GraphicsPipelineCreateInfo - { - GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), - uint32_t stageCount_ = 0, - const PipelineShaderStageCreateInfo* pStages_ = nullptr, - const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, - const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, - const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, - const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, - const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, - const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, - const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, - const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, - const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, - PipelineLayout layout_ = PipelineLayout(), - RenderPass renderPass_ = RenderPass(), - uint32_t subpass_ = 0, - Pipeline basePipelineHandle_ = Pipeline(), - int32_t basePipelineIndex_ = 0 ) - : flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , pVertexInputState( pVertexInputState_ ) - , pInputAssemblyState( pInputAssemblyState_ ) - , pTessellationState( pTessellationState_ ) - , pViewportState( pViewportState_ ) - , pRasterizationState( pRasterizationState_ ) - , pMultisampleState( pMultisampleState_ ) - , pDepthStencilState( pDepthStencilState_ ) - , pColorBlendState( pColorBlendState_ ) - , pDynamicState( pDynamicState_ ) - , layout( layout_ ) - , renderPass( renderPass_ ) - , subpass( subpass_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } - - GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); - } - - GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); - return *this; - } - GraphicsPipelineCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ ) - { - stageCount = stageCount_; - return *this; - } - - GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ ) - { - pStages = pStages_; - return *this; - } - - GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ ) - { - pVertexInputState = pVertexInputState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ ) - { - pInputAssemblyState = pInputAssemblyState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ ) - { - pTessellationState = pTessellationState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ ) - { - pViewportState = pViewportState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ ) - { - pRasterizationState = pRasterizationState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ ) - { - pMultisampleState = pMultisampleState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ ) - { - pDepthStencilState = pDepthStencilState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ ) - { - pColorBlendState = pColorBlendState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ ) - { - pDynamicState = pDynamicState_; - return *this; - } - - GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ ) - { - layout = layout_; - return *this; - } - - GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ ) - { - subpass = subpass_; - return *this; - } - - GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - operator const VkGraphicsPipelineCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( GraphicsPipelineCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stageCount == rhs.stageCount ) - && ( pStages == rhs.pStages ) - && ( pVertexInputState == rhs.pVertexInputState ) - && ( pInputAssemblyState == rhs.pInputAssemblyState ) - && ( pTessellationState == rhs.pTessellationState ) - && ( pViewportState == rhs.pViewportState ) - && ( pRasterizationState == rhs.pRasterizationState ) - && ( pMultisampleState == rhs.pMultisampleState ) - && ( pDepthStencilState == rhs.pDepthStencilState ) - && ( pColorBlendState == rhs.pColorBlendState ) - && ( pDynamicState == rhs.pDynamicState ) - && ( layout == rhs.layout ) - && ( renderPass == rhs.renderPass ) - && ( subpass == rhs.subpass ) - && ( basePipelineHandle == rhs.basePipelineHandle ) - && ( basePipelineIndex == rhs.basePipelineIndex ); - } - - bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eGraphicsPipelineCreateInfo; - - public: - const void* pNext = nullptr; - PipelineCreateFlags flags; - uint32_t stageCount; - const PipelineShaderStageCreateInfo* pStages; - const PipelineVertexInputStateCreateInfo* pVertexInputState; - const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const PipelineTessellationStateCreateInfo* pTessellationState; - const PipelineViewportStateCreateInfo* pViewportState; - const PipelineRasterizationStateCreateInfo* pRasterizationState; - const PipelineMultisampleStateCreateInfo* pMultisampleState; - const PipelineDepthStencilStateCreateInfo* pDepthStencilState; - const PipelineColorBlendStateCreateInfo* pColorBlendState; - const PipelineDynamicStateCreateInfo* pDynamicState; - PipelineLayout layout; - RenderPass renderPass; - uint32_t subpass; - Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceLimits - { - operator const VkPhysicalDeviceLimits&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceLimits const& rhs ) const - { - return ( maxImageDimension1D == rhs.maxImageDimension1D ) - && ( maxImageDimension2D == rhs.maxImageDimension2D ) - && ( maxImageDimension3D == rhs.maxImageDimension3D ) - && ( maxImageDimensionCube == rhs.maxImageDimensionCube ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( maxTexelBufferElements == rhs.maxTexelBufferElements ) - && ( maxUniformBufferRange == rhs.maxUniformBufferRange ) - && ( maxStorageBufferRange == rhs.maxStorageBufferRange ) - && ( maxPushConstantsSize == rhs.maxPushConstantsSize ) - && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) - && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) - && ( bufferImageGranularity == rhs.bufferImageGranularity ) - && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) - && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) - && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) - && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) - && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) - && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) - && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) - && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) - && ( maxPerStageResources == rhs.maxPerStageResources ) - && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) - && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) - && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) - && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) - && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) - && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) - && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) - && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) - && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) - && ( maxVertexInputBindings == rhs.maxVertexInputBindings ) - && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) - && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) - && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) - && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) - && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) - && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) - && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents ) - && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) - && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) - && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) - && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) - && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) - && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) - && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) - && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) - && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) - && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) - && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) - && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) - && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) - && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) - && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 ) - && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) - && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ) - && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) - && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) - && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) - && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) - && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) - && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) - && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) - && ( maxViewports == rhs.maxViewports ) - && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 ) - && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 ) - && ( viewportSubPixelBits == rhs.viewportSubPixelBits ) - && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) - && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) - && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) - && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) - && ( minTexelOffset == rhs.minTexelOffset ) - && ( maxTexelOffset == rhs.maxTexelOffset ) - && ( minTexelGatherOffset == rhs.minTexelGatherOffset ) - && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) - && ( minInterpolationOffset == rhs.minInterpolationOffset ) - && ( maxInterpolationOffset == rhs.maxInterpolationOffset ) - && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) - && ( maxFramebufferWidth == rhs.maxFramebufferWidth ) - && ( maxFramebufferHeight == rhs.maxFramebufferHeight ) - && ( maxFramebufferLayers == rhs.maxFramebufferLayers ) - && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) - && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) - && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) - && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) - && ( maxColorAttachments == rhs.maxColorAttachments ) - && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) - && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) - && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) - && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) - && ( storageImageSampleCounts == rhs.storageImageSampleCounts ) - && ( maxSampleMaskWords == rhs.maxSampleMaskWords ) - && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) - && ( timestampPeriod == rhs.timestampPeriod ) - && ( maxClipDistances == rhs.maxClipDistances ) - && ( maxCullDistances == rhs.maxCullDistances ) - && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) - && ( discreteQueuePriorities == rhs.discreteQueuePriorities ) - && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 ) - && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 ) - && ( pointSizeGranularity == rhs.pointSizeGranularity ) - && ( lineWidthGranularity == rhs.lineWidthGranularity ) - && ( strictLines == rhs.strictLines ) - && ( standardSampleLocations == rhs.standardSampleLocations ) - && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) - && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) - && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); - } - - bool operator!=( PhysicalDeviceLimits const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - DeviceSize bufferImageGranularity; - DeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - DeviceSize minTexelBufferOffsetAlignment; - DeviceSize minUniformBufferOffsetAlignment; - DeviceSize minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - SampleCountFlags framebufferColorSampleCounts; - SampleCountFlags framebufferDepthSampleCounts; - SampleCountFlags framebufferStencilSampleCounts; - SampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - SampleCountFlags sampledImageColorSampleCounts; - SampleCountFlags sampledImageIntegerSampleCounts; - SampleCountFlags sampledImageDepthSampleCounts; - SampleCountFlags sampledImageStencilSampleCounts; - SampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - Bool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - Bool32 strictLines; - Bool32 standardSampleLocations; - DeviceSize optimalBufferCopyOffsetAlignment; - DeviceSize optimalBufferCopyRowPitchAlignment; - DeviceSize nonCoherentAtomSize; - }; - static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceProperties - { - operator const VkPhysicalDeviceProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceProperties const& rhs ) const - { - return ( apiVersion == rhs.apiVersion ) - && ( driverVersion == rhs.driverVersion ) - && ( vendorID == rhs.vendorID ) - && ( deviceID == rhs.deviceID ) - && ( deviceType == rhs.deviceType ) - && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 ) - && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( limits == rhs.limits ) - && ( sparseProperties == rhs.sparseProperties ); - } - - bool operator!=( PhysicalDeviceProperties const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - PhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - PhysicalDeviceLimits limits; - PhysicalDeviceSparseProperties sparseProperties; - }; - static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceProperties2 - { - operator const VkPhysicalDeviceProperties2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceProperties2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( properties == rhs.properties ); - } - - bool operator!=( PhysicalDeviceProperties2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceProperties2; - - public: - void* pNext = nullptr; - PhysicalDeviceProperties properties; - }; - static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" ); - - using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; - - struct ImageFormatProperties2 - { - operator const VkImageFormatProperties2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImageFormatProperties2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( imageFormatProperties == rhs.imageFormatProperties ); - } - - bool operator!=( ImageFormatProperties2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageFormatProperties2; - - public: - void* pNext = nullptr; - ImageFormatProperties imageFormatProperties; - }; - static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" ); - - using ImageFormatProperties2KHR = ImageFormatProperties2; - - struct PhysicalDeviceSparseImageFormatInfo2 - { - PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined, - ImageType type_ = ImageType::e1D, - SampleCountFlagBits samples_ = SampleCountFlagBits::e1, - ImageUsageFlags usage_ = ImageUsageFlags(), - ImageTiling tiling_ = ImageTiling::eOptimal ) - : format( format_ ) - , type( type_ ) - , samples( samples_ ) - , usage( usage_ ) - , tiling( tiling_ ) - { - } - - PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) ); - } - - PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) ); - return *this; - } - PhysicalDeviceSparseImageFormatInfo2& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2& setType( ImageType type_ ) - { - type = type_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2& setSamples( SampleCountFlagBits samples_ ) - { - samples = samples_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2& setTiling( ImageTiling tiling_ ) - { - tiling = tiling_; - return *this; - } - - operator const VkPhysicalDeviceSparseImageFormatInfo2&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( type == rhs.type ) - && ( samples == rhs.samples ) - && ( usage == rhs.usage ) - && ( tiling == rhs.tiling ); - } - - bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; - - public: - const void* pNext = nullptr; - Format format; - ImageType type; - SampleCountFlagBits samples; - ImageUsageFlags usage; - ImageTiling tiling; - }; - static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" ); - - using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; - - struct SampleLocationsInfoEXT - { - SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, - Extent2D sampleLocationGridSize_ = Extent2D(), - uint32_t sampleLocationsCount_ = 0, - const SampleLocationEXT* pSampleLocations_ = nullptr ) - : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) - , sampleLocationGridSize( sampleLocationGridSize_ ) - , sampleLocationsCount( sampleLocationsCount_ ) - , pSampleLocations( pSampleLocations_ ) - { - } - - SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) ); - } - - SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) ); - return *this; - } - SampleLocationsInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SampleLocationsInfoEXT& setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) - { - sampleLocationsPerPixel = sampleLocationsPerPixel_; - return *this; - } - - SampleLocationsInfoEXT& setSampleLocationGridSize( Extent2D sampleLocationGridSize_ ) - { - sampleLocationGridSize = sampleLocationGridSize_; - return *this; - } - - SampleLocationsInfoEXT& setSampleLocationsCount( uint32_t sampleLocationsCount_ ) - { - sampleLocationsCount = sampleLocationsCount_; - return *this; - } - - SampleLocationsInfoEXT& setPSampleLocations( const SampleLocationEXT* pSampleLocations_ ) - { - pSampleLocations = pSampleLocations_; - return *this; - } - - operator const VkSampleLocationsInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SampleLocationsInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) - && ( sampleLocationGridSize == rhs.sampleLocationGridSize ) - && ( sampleLocationsCount == rhs.sampleLocationsCount ) - && ( pSampleLocations == rhs.pSampleLocations ); - } - - bool operator!=( SampleLocationsInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSampleLocationsInfoEXT; - - public: - const void* pNext = nullptr; - SampleCountFlagBits sampleLocationsPerPixel; - Extent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const SampleLocationEXT* pSampleLocations; - }; - static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" ); - - struct AttachmentSampleLocationsEXT - { - AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0, - SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) - : attachmentIndex( attachmentIndex_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - { - } - - AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) ); - } - - AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) ); - return *this; - } - AttachmentSampleLocationsEXT& setAttachmentIndex( uint32_t attachmentIndex_ ) - { - attachmentIndex = attachmentIndex_; - return *this; - } - - AttachmentSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - operator const VkAttachmentSampleLocationsEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AttachmentSampleLocationsEXT const& rhs ) const - { - return ( attachmentIndex == rhs.attachmentIndex ) - && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); - } - - bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t attachmentIndex; - SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" ); - - struct SubpassSampleLocationsEXT - { - SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0, - SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) - : subpassIndex( subpassIndex_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - { - } - - SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) ); - } - - SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) ); - return *this; - } - SubpassSampleLocationsEXT& setSubpassIndex( uint32_t subpassIndex_ ) - { - subpassIndex = subpassIndex_; - return *this; - } - - SubpassSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - operator const VkSubpassSampleLocationsEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SubpassSampleLocationsEXT const& rhs ) const - { - return ( subpassIndex == rhs.subpassIndex ) - && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); - } - - bool operator!=( SubpassSampleLocationsEXT const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t subpassIndex; - SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" ); - - struct RenderPassSampleLocationsBeginInfoEXT - { - RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, - const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, - uint32_t postSubpassSampleLocationsCount_ = 0, - const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) - : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) - , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) - , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) - , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) - { - } - - RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) ); - } - - RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) ); - return *this; - } - RenderPassSampleLocationsBeginInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) - { - attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ ) - { - pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) - { - postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ ) - { - pPostSubpassSampleLocations = pPostSubpassSampleLocations_; - return *this; - } - - operator const VkRenderPassSampleLocationsBeginInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) - && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) - && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) - && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); - } - - bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; - - public: - const void* pNext = nullptr; - uint32_t attachmentInitialSampleLocationsCount; - const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const SubpassSampleLocationsEXT* pPostSubpassSampleLocations; - }; - static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" ); - - struct PipelineSampleLocationsStateCreateInfoEXT - { - PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0, - SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) - : sampleLocationsEnable( sampleLocationsEnable_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - { - } - - PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) ); - } - - PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) ); - return *this; - } - PipelineSampleLocationsStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsEnable( Bool32 sampleLocationsEnable_ ) - { - sampleLocationsEnable = sampleLocationsEnable_; - return *this; - } - - PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - operator const VkPipelineSampleLocationsStateCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sampleLocationsEnable == rhs.sampleLocationsEnable ) - && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); - } - - bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - Bool32 sampleLocationsEnable; - SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSampleLocationsPropertiesEXT - { - operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) - && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) - && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 ) - && ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) - && ( variableSampleLocations == rhs.variableSampleLocations ); - } - - bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; - - public: - void* pNext = nullptr; - SampleCountFlags sampleLocationSampleCounts; - Extent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - Bool32 variableSampleLocations; - }; - static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" ); - - enum class AttachmentDescriptionFlagBits - { - eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT - }; - - using AttachmentDescriptionFlags = Flags; - - VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 ) - { - return AttachmentDescriptionFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits ) - { - return ~( AttachmentDescriptionFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias) - }; - }; - - struct AttachmentDescription - { - AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), - Format format_ = Format::eUndefined, - SampleCountFlagBits samples_ = SampleCountFlagBits::e1, - AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, - AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, - AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, - AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, - ImageLayout initialLayout_ = ImageLayout::eUndefined, - ImageLayout finalLayout_ = ImageLayout::eUndefined ) - : flags( flags_ ) - , format( format_ ) - , samples( samples_ ) - , loadOp( loadOp_ ) - , storeOp( storeOp_ ) - , stencilLoadOp( stencilLoadOp_ ) - , stencilStoreOp( stencilStoreOp_ ) - , initialLayout( initialLayout_ ) - , finalLayout( finalLayout_ ) - { - } - - AttachmentDescription( VkAttachmentDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentDescription ) ); - } - - AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentDescription ) ); - return *this; - } - AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ ) - { - flags = flags_; - return *this; - } - - AttachmentDescription& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - AttachmentDescription& setSamples( SampleCountFlagBits samples_ ) - { - samples = samples_; - return *this; - } - - AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ ) - { - loadOp = loadOp_; - return *this; - } - - AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ ) - { - storeOp = storeOp_; - return *this; - } - - AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) - { - stencilLoadOp = stencilLoadOp_; - return *this; - } - - AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) - { - stencilStoreOp = stencilStoreOp_; - return *this; - } - - AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ ) - { - initialLayout = initialLayout_; - return *this; - } - - AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ ) - { - finalLayout = finalLayout_; - return *this; - } - - operator const VkAttachmentDescription&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AttachmentDescription const& rhs ) const - { - return ( flags == rhs.flags ) - && ( format == rhs.format ) - && ( samples == rhs.samples ) - && ( loadOp == rhs.loadOp ) - && ( storeOp == rhs.storeOp ) - && ( stencilLoadOp == rhs.stencilLoadOp ) - && ( stencilStoreOp == rhs.stencilStoreOp ) - && ( initialLayout == rhs.initialLayout ) - && ( finalLayout == rhs.finalLayout ); - } - - bool operator!=( AttachmentDescription const& rhs ) const - { - return !operator==( rhs ); - } - - AttachmentDescriptionFlags flags; - Format format; - SampleCountFlagBits samples; - AttachmentLoadOp loadOp; - AttachmentStoreOp storeOp; - AttachmentLoadOp stencilLoadOp; - AttachmentStoreOp stencilStoreOp; - ImageLayout initialLayout; - ImageLayout finalLayout; - }; - static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); - - enum class StencilFaceFlagBits - { - eFront = VK_STENCIL_FACE_FRONT_BIT, - eBack = VK_STENCIL_FACE_BACK_BIT, - eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK - }; - - using StencilFaceFlags = Flags; - - VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 ) - { - return StencilFaceFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits ) - { - return ~( StencilFaceFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack) - }; - }; - - enum class DescriptorPoolCreateFlagBits - { - eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, - eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT - }; - - using DescriptorPoolCreateFlags = Flags; - - VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 ) - { - return DescriptorPoolCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits ) - { - return ~( DescriptorPoolCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT) - }; - }; - - struct DescriptorPoolCreateInfo - { - DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), - uint32_t maxSets_ = 0, - uint32_t poolSizeCount_ = 0, - const DescriptorPoolSize* pPoolSizes_ = nullptr ) - : flags( flags_ ) - , maxSets( maxSets_ ) - , poolSizeCount( poolSizeCount_ ) - , pPoolSizes( pPoolSizes_ ) - { - } - - DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); - } - - DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); - return *this; - } - DescriptorPoolCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ ) - { - maxSets = maxSets_; - return *this; - } - - DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ ) - { - poolSizeCount = poolSizeCount_; - return *this; - } - - DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ ) - { - pPoolSizes = pPoolSizes_; - return *this; - } - - operator const VkDescriptorPoolCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorPoolCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( maxSets == rhs.maxSets ) - && ( poolSizeCount == rhs.poolSizeCount ) - && ( pPoolSizes == rhs.pPoolSizes ); - } - - bool operator!=( DescriptorPoolCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorPoolCreateInfo; - - public: - const void* pNext = nullptr; - DescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const DescriptorPoolSize* pPoolSizes; - }; - static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); - - enum class DependencyFlagBits - { - eByRegion = VK_DEPENDENCY_BY_REGION_BIT, - eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, - eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, - eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT, - eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT - }; - - using DependencyFlags = Flags; - - VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 ) - { - return DependencyFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits ) - { - return ~( DependencyFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eDeviceGroup) | VkFlags(DependencyFlagBits::eViewLocal) - }; - }; - - struct SubpassDependency - { - SubpassDependency( uint32_t srcSubpass_ = 0, - uint32_t dstSubpass_ = 0, - PipelineStageFlags srcStageMask_ = PipelineStageFlags(), - PipelineStageFlags dstStageMask_ = PipelineStageFlags(), - AccessFlags srcAccessMask_ = AccessFlags(), - AccessFlags dstAccessMask_ = AccessFlags(), - DependencyFlags dependencyFlags_ = DependencyFlags() ) - : srcSubpass( srcSubpass_ ) - , dstSubpass( dstSubpass_ ) - , srcStageMask( srcStageMask_ ) - , dstStageMask( dstStageMask_ ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , dependencyFlags( dependencyFlags_ ) - { - } - - SubpassDependency( VkSubpassDependency const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDependency ) ); - } - - SubpassDependency& operator=( VkSubpassDependency const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDependency ) ); - return *this; - } - SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ ) - { - srcSubpass = srcSubpass_; - return *this; - } - - SubpassDependency& setDstSubpass( uint32_t dstSubpass_ ) - { - dstSubpass = dstSubpass_; - return *this; - } - - SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ ) - { - srcStageMask = srcStageMask_; - return *this; - } - - SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ ) - { - dstStageMask = dstStageMask_; - return *this; - } - - SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ ) - { - dependencyFlags = dependencyFlags_; - return *this; - } - - operator const VkSubpassDependency&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SubpassDependency const& rhs ) const - { - return ( srcSubpass == rhs.srcSubpass ) - && ( dstSubpass == rhs.dstSubpass ) - && ( srcStageMask == rhs.srcStageMask ) - && ( dstStageMask == rhs.dstStageMask ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( dependencyFlags == rhs.dependencyFlags ); - } - - bool operator!=( SubpassDependency const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t srcSubpass; - uint32_t dstSubpass; - PipelineStageFlags srcStageMask; - PipelineStageFlags dstStageMask; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - DependencyFlags dependencyFlags; - }; - static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); - - enum class PresentModeKHR - { - eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, - eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, - eFifo = VK_PRESENT_MODE_FIFO_KHR, - eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, - eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, - eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR - }; - - enum class ColorSpaceKHR - { - eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, - eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, - eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, - eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, - eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, - eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, - eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, - eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, - eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT, - eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, - eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, - eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, - ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, - eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT - }; - - struct SurfaceFormatKHR - { - operator const VkSurfaceFormatKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SurfaceFormatKHR const& rhs ) const - { - return ( format == rhs.format ) - && ( colorSpace == rhs.colorSpace ); - } - - bool operator!=( SurfaceFormatKHR const& rhs ) const - { - return !operator==( rhs ); - } - - Format format; - ColorSpaceKHR colorSpace; - }; - static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); - - struct SurfaceFormat2KHR - { - operator const VkSurfaceFormat2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SurfaceFormat2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surfaceFormat == rhs.surfaceFormat ); - } - - bool operator!=( SurfaceFormat2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSurfaceFormat2KHR; - - public: - void* pNext = nullptr; - SurfaceFormatKHR surfaceFormat; - }; - static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); - - enum class DisplayPlaneAlphaFlagBitsKHR - { - eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, - eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, - ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, - ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR - }; - - using DisplayPlaneAlphaFlagsKHR = Flags; - - VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 ) - { - return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits ) - { - return ~( DisplayPlaneAlphaFlagsKHR( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) - }; - }; - - struct DisplayPlaneCapabilitiesKHR - { - operator const VkDisplayPlaneCapabilitiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const - { - return ( supportedAlpha == rhs.supportedAlpha ) - && ( minSrcPosition == rhs.minSrcPosition ) - && ( maxSrcPosition == rhs.maxSrcPosition ) - && ( minSrcExtent == rhs.minSrcExtent ) - && ( maxSrcExtent == rhs.maxSrcExtent ) - && ( minDstPosition == rhs.minDstPosition ) - && ( maxDstPosition == rhs.maxDstPosition ) - && ( minDstExtent == rhs.minDstExtent ) - && ( maxDstExtent == rhs.maxDstExtent ); - } - - bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayPlaneAlphaFlagsKHR supportedAlpha; - Offset2D minSrcPosition; - Offset2D maxSrcPosition; - Extent2D minSrcExtent; - Extent2D maxSrcExtent; - Offset2D minDstPosition; - Offset2D maxDstPosition; - Extent2D minDstExtent; - Extent2D maxDstExtent; - }; - static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); - - struct DisplayPlaneCapabilities2KHR - { - operator const VkDisplayPlaneCapabilities2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( capabilities == rhs.capabilities ); - } - - bool operator!=( DisplayPlaneCapabilities2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; - - public: - void* pNext = nullptr; - DisplayPlaneCapabilitiesKHR capabilities; - }; - static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" ); - - enum class CompositeAlphaFlagBitsKHR - { - eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, - ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, - ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, - eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR - }; - - using CompositeAlphaFlagsKHR = Flags; - - VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 ) - { - return CompositeAlphaFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits ) - { - return ~( CompositeAlphaFlagsKHR( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit) - }; - }; - - enum class SurfaceTransformFlagBitsKHR - { - eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, - eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, - eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, - eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, - eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, - eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, - eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, - eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, - eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR - }; - - using SurfaceTransformFlagsKHR = Flags; - - VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 ) - { - return SurfaceTransformFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits ) - { - return ~( SurfaceTransformFlagsKHR( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit) - }; - }; - - struct DisplayPropertiesKHR - { - operator const VkDisplayPropertiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPropertiesKHR const& rhs ) const - { - return ( display == rhs.display ) - && ( displayName == rhs.displayName ) - && ( physicalDimensions == rhs.physicalDimensions ) - && ( physicalResolution == rhs.physicalResolution ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( planeReorderPossible == rhs.planeReorderPossible ) - && ( persistentContent == rhs.persistentContent ); - } - - bool operator!=( DisplayPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayKHR display; - const char* displayName; - Extent2D physicalDimensions; - Extent2D physicalResolution; - SurfaceTransformFlagsKHR supportedTransforms; - Bool32 planeReorderPossible; - Bool32 persistentContent; - }; - static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); - - struct DisplaySurfaceCreateInfoKHR - { - DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), - DisplayModeKHR displayMode_ = DisplayModeKHR(), - uint32_t planeIndex_ = 0, - uint32_t planeStackIndex_ = 0, - SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, - float globalAlpha_ = 0, - DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, - Extent2D imageExtent_ = Extent2D() ) - : flags( flags_ ) - , displayMode( displayMode_ ) - , planeIndex( planeIndex_ ) - , planeStackIndex( planeStackIndex_ ) - , transform( transform_ ) - , globalAlpha( globalAlpha_ ) - , alphaMode( alphaMode_ ) - , imageExtent( imageExtent_ ) - { - } - - DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); - } - - DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); - return *this; - } - DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ ) - { - displayMode = displayMode_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ ) - { - planeIndex = planeIndex_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ ) - { - planeStackIndex = planeStackIndex_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ ) - { - transform = transform_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ ) - { - globalAlpha = globalAlpha_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) - { - alphaMode = alphaMode_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) - { - imageExtent = imageExtent_; - return *this; - } - - operator const VkDisplaySurfaceCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( displayMode == rhs.displayMode ) - && ( planeIndex == rhs.planeIndex ) - && ( planeStackIndex == rhs.planeStackIndex ) - && ( transform == rhs.transform ) - && ( globalAlpha == rhs.globalAlpha ) - && ( alphaMode == rhs.alphaMode ) - && ( imageExtent == rhs.imageExtent ); - } - - bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - DisplaySurfaceCreateFlagsKHR flags; - DisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - SurfaceTransformFlagBitsKHR transform; - float globalAlpha; - DisplayPlaneAlphaFlagBitsKHR alphaMode; - Extent2D imageExtent; - }; - static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct SurfaceCapabilitiesKHR - { - operator const VkSurfaceCapabilitiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SurfaceCapabilitiesKHR const& rhs ) const - { - return ( minImageCount == rhs.minImageCount ) - && ( maxImageCount == rhs.maxImageCount ) - && ( currentExtent == rhs.currentExtent ) - && ( minImageExtent == rhs.minImageExtent ) - && ( maxImageExtent == rhs.maxImageExtent ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( currentTransform == rhs.currentTransform ) - && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) - && ( supportedUsageFlags == rhs.supportedUsageFlags ); - } - - bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t minImageCount; - uint32_t maxImageCount; - Extent2D currentExtent; - Extent2D minImageExtent; - Extent2D maxImageExtent; - uint32_t maxImageArrayLayers; - SurfaceTransformFlagsKHR supportedTransforms; - SurfaceTransformFlagBitsKHR currentTransform; - CompositeAlphaFlagsKHR supportedCompositeAlpha; - ImageUsageFlags supportedUsageFlags; - }; - static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); - - struct SurfaceCapabilities2KHR - { - operator const VkSurfaceCapabilities2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SurfaceCapabilities2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surfaceCapabilities == rhs.surfaceCapabilities ); - } - - bool operator!=( SurfaceCapabilities2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSurfaceCapabilities2KHR; - - public: - void* pNext = nullptr; - SurfaceCapabilitiesKHR surfaceCapabilities; - }; - static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); - - struct DisplayProperties2KHR - { - operator const VkDisplayProperties2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( displayProperties == rhs.displayProperties ); - } - - bool operator!=( DisplayProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayProperties2KHR; - - public: - void* pNext = nullptr; - DisplayPropertiesKHR displayProperties; - }; - static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" ); - - enum class DebugReportFlagBitsEXT - { - eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, - eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT, - ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - eError = VK_DEBUG_REPORT_ERROR_BIT_EXT, - eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT - }; - - using DebugReportFlagsEXT = Flags; - - VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 ) - { - return DebugReportFlagsEXT( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits ) - { - return ~( DebugReportFlagsEXT( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug) - }; - }; - - struct DebugReportCallbackCreateInfoEXT - { - DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), - PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, - void* pUserData_ = nullptr ) - : flags( flags_ ) - , pfnCallback( pfnCallback_ ) - , pUserData( pUserData_ ) - { - } - - DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); - } - - DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); - return *this; - } - DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) - { - pfnCallback = pfnCallback_; - return *this; - } - - DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ ) - { - pUserData = pUserData_; - return *this; - } - - operator const VkDebugReportCallbackCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pfnCallback == rhs.pfnCallback ) - && ( pUserData == rhs.pUserData ); - } - - bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; - - public: - const void* pNext = nullptr; - DebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; - }; - static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class DebugReportObjectTypeEXT - { - eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, - eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, - eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, - eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, - eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, - ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, - ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, - eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, - eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, - eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, - eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, - eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, - eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, - eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, - eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, - eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, - eValidationCacheExt = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, - eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, - eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, - eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, - eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT - }; - - struct DebugMarkerObjectNameInfoEXT - { - DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = 0, - const char* pObjectName_ = nullptr ) - : objectType( objectType_ ) - , object( object_ ) - , pObjectName( pObjectName_ ) - { - } - - DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); - } - - DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); - return *this; - } - DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) - { - objectType = objectType_; - return *this; - } - - DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ ) - { - object = object_; - return *this; - } - - DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ ) - { - pObjectName = pObjectName_; - return *this; - } - - operator const VkDebugMarkerObjectNameInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( object == rhs.object ) - && ( pObjectName == rhs.pObjectName ); - } - - bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; - - public: - const void* pNext = nullptr; - DebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; - }; - static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); - - struct DebugMarkerObjectTagInfoEXT - { - DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = 0, - uint64_t tagName_ = 0, - size_t tagSize_ = 0, - const void* pTag_ = nullptr ) - : objectType( objectType_ ) - , object( object_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - { - } - - DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); - } - - DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); - return *this; - } - DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) - { - objectType = objectType_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ ) - { - object = object_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ ) - { - tagName = tagName_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ ) - { - tagSize = tagSize_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ ) - { - pTag = pTag_; - return *this; - } - - operator const VkDebugMarkerObjectTagInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( object == rhs.object ) - && ( tagName == rhs.tagName ) - && ( tagSize == rhs.tagSize ) - && ( pTag == rhs.pTag ); - } - - bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; - - public: - const void* pNext = nullptr; - DebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); - - enum class RasterizationOrderAMD - { - eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, - eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD - }; - - struct PipelineRasterizationStateRasterizationOrderAMD - { - PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict ) - : rasterizationOrder( rasterizationOrder_ ) - { - } - - PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); - } - - PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); - return *this; - } - PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) - { - rasterizationOrder = rasterizationOrder_; - return *this; - } - - operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( rasterizationOrder == rhs.rasterizationOrder ); - } - - bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; - - public: - const void* pNext = nullptr; - RasterizationOrderAMD rasterizationOrder; - }; - static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); - - enum class ExternalMemoryHandleTypeFlagBitsNV - { - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, - eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, - eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV - }; - - using ExternalMemoryHandleTypeFlagsNV = Flags; - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 ) - { - return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits ) - { - return ~( ExternalMemoryHandleTypeFlagsNV( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) - }; - }; - - struct ExternalMemoryImageCreateInfoNV - { - ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : handleTypes( handleTypes_ ) - { - } - - ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); - } - - ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); - return *this; - } - ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExternalMemoryImageCreateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); - - struct ExportMemoryAllocateInfoNV - { - ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : handleTypes( handleTypes_ ) - { - } - - ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); - } - - ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); - return *this; - } - ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportMemoryAllocateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryAllocateInfoNV; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_NV - struct ImportMemoryWin32HandleInfoNV - { - ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), - HANDLE handle_ = 0 ) - : handleType( handleType_ ) - , handle( handle_ ) - { - } - - ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); - } - - ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); - return *this; - } - ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - operator const VkImportMemoryWin32HandleInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ); - } - - bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsNV handleType; - HANDLE handle; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_NV*/ - - enum class ExternalMemoryFeatureFlagBitsNV - { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV - }; - - using ExternalMemoryFeatureFlagsNV = Flags; - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 ) - { - return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits ) - { - return ~( ExternalMemoryFeatureFlagsNV( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable) - }; - }; - - struct ExternalImageFormatPropertiesNV - { - operator const VkExternalImageFormatPropertiesNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const - { - return ( imageFormatProperties == rhs.imageFormatProperties ) - && ( externalMemoryFeatures == rhs.externalMemoryFeatures ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); - } - - bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const - { - return !operator==( rhs ); - } - - ImageFormatProperties imageFormatProperties; - ExternalMemoryFeatureFlagsNV externalMemoryFeatures; - ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; - ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; - }; - static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); - - enum class ValidationCheckEXT - { - eAll = VK_VALIDATION_CHECK_ALL_EXT, - eShaders = VK_VALIDATION_CHECK_SHADERS_EXT - }; - - struct ValidationFlagsEXT - { - ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, - ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) - : disabledValidationCheckCount( disabledValidationCheckCount_ ) - , pDisabledValidationChecks( pDisabledValidationChecks_ ) - { - } - - ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); - } - - ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); - return *this; - } - ValidationFlagsEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) - { - disabledValidationCheckCount = disabledValidationCheckCount_; - return *this; - } - - ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ ) - { - pDisabledValidationChecks = pDisabledValidationChecks_; - return *this; - } - - operator const VkValidationFlagsEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ValidationFlagsEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) - && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); - } - - bool operator!=( ValidationFlagsEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eValidationFlagsEXT; - - public: - const void* pNext = nullptr; - uint32_t disabledValidationCheckCount; - ValidationCheckEXT* pDisabledValidationChecks; - }; - static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); - - enum class SubgroupFeatureFlagBits - { - eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, - eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, - eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, - eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, - eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, - eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, - eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, - eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, - ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV - }; - - using SubgroupFeatureFlags = Flags; - - VULKAN_HPP_INLINE SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 ) - { - return SubgroupFeatureFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits ) - { - return ~( SubgroupFeatureFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) | VkFlags(SubgroupFeatureFlagBits::eVote) | VkFlags(SubgroupFeatureFlagBits::eArithmetic) | VkFlags(SubgroupFeatureFlagBits::eBallot) | VkFlags(SubgroupFeatureFlagBits::eShuffle) | VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) | VkFlags(SubgroupFeatureFlagBits::eClustered) | VkFlags(SubgroupFeatureFlagBits::eQuad) | VkFlags(SubgroupFeatureFlagBits::ePartitionedNV) - }; - }; - - struct PhysicalDeviceSubgroupProperties - { - operator const VkPhysicalDeviceSubgroupProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceSubgroupProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( subgroupSize == rhs.subgroupSize ) - && ( supportedStages == rhs.supportedStages ) - && ( supportedOperations == rhs.supportedOperations ) - && ( quadOperationsInAllStages == rhs.quadOperationsInAllStages ); - } - - bool operator!=( PhysicalDeviceSubgroupProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; - - public: - void* pNext = nullptr; - uint32_t subgroupSize; - ShaderStageFlags supportedStages; - SubgroupFeatureFlags supportedOperations; - Bool32 quadOperationsInAllStages; - }; - static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" ); - - enum class IndirectCommandsLayoutUsageFlagBitsNVX - { - eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX, - eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX, - eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX, - eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX - }; - - using IndirectCommandsLayoutUsageFlagsNVX = Flags; - - VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 ) - { - return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits ) - { - return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) - }; - }; - - enum class ObjectEntryUsageFlagBitsNVX - { - eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, - eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX - }; - - using ObjectEntryUsageFlagsNVX = Flags; - - VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 ) - { - return ObjectEntryUsageFlagsNVX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits ) - { - return ~( ObjectEntryUsageFlagsNVX( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute) - }; - }; - - enum class IndirectCommandsTokenTypeNVX - { - ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, - eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, - eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, - eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, - ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, - eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, - eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, - eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - }; - - struct IndirectCommandsTokenNVX - { - IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, - Buffer buffer_ = Buffer(), - DeviceSize offset_ = 0 ) - : tokenType( tokenType_ ) - , buffer( buffer_ ) - , offset( offset_ ) - { - } - - IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); - } - - IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); - return *this; - } - IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) - { - tokenType = tokenType_; - return *this; - } - - IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - operator const VkIndirectCommandsTokenNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( IndirectCommandsTokenNVX const& rhs ) const - { - return ( tokenType == rhs.tokenType ) - && ( buffer == rhs.buffer ) - && ( offset == rhs.offset ); - } - - bool operator!=( IndirectCommandsTokenNVX const& rhs ) const - { - return !operator==( rhs ); - } - - IndirectCommandsTokenTypeNVX tokenType; - Buffer buffer; - DeviceSize offset; - }; - static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" ); - - struct IndirectCommandsLayoutTokenNVX - { - IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, - uint32_t bindingUnit_ = 0, - uint32_t dynamicCount_ = 0, - uint32_t divisor_ = 0 ) - : tokenType( tokenType_ ) - , bindingUnit( bindingUnit_ ) - , dynamicCount( dynamicCount_ ) - , divisor( divisor_ ) - { - } - - IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); - } - - IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); - return *this; - } - IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) - { - tokenType = tokenType_; - return *this; - } - - IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ ) - { - bindingUnit = bindingUnit_; - return *this; - } - - IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ ) - { - dynamicCount = dynamicCount_; - return *this; - } - - IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ ) - { - divisor = divisor_; - return *this; - } - - operator const VkIndirectCommandsLayoutTokenNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const - { - return ( tokenType == rhs.tokenType ) - && ( bindingUnit == rhs.bindingUnit ) - && ( dynamicCount == rhs.dynamicCount ) - && ( divisor == rhs.divisor ); - } - - bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const - { - return !operator==( rhs ); - } - - IndirectCommandsTokenTypeNVX tokenType; - uint32_t bindingUnit; - uint32_t dynamicCount; - uint32_t divisor; - }; - static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" ); - - struct IndirectCommandsLayoutCreateInfoNVX - { - IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), - uint32_t tokenCount_ = 0, - const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) - : pipelineBindPoint( pipelineBindPoint_ ) - , flags( flags_ ) - , tokenCount( tokenCount_ ) - , pTokens( pTokens_ ) - { - } - - IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); - } - - IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); - return *this; - } - IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ ) - { - tokenCount = tokenCount_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ ) - { - pTokens = pTokens_; - return *this; - } - - operator const VkIndirectCommandsLayoutCreateInfoNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( flags == rhs.flags ) - && ( tokenCount == rhs.tokenCount ) - && ( pTokens == rhs.pTokens ); - } - - bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; - - public: - const void* pNext = nullptr; - PipelineBindPoint pipelineBindPoint; - IndirectCommandsLayoutUsageFlagsNVX flags; - uint32_t tokenCount; - const IndirectCommandsLayoutTokenNVX* pTokens; - }; - static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); - - enum class ObjectEntryTypeNVX - { - eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, - ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, - eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, - eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, - ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - }; - - struct ObjectTableCreateInfoNVX - { - ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, - const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, - const uint32_t* pObjectEntryCounts_ = nullptr, - const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, - uint32_t maxUniformBuffersPerDescriptor_ = 0, - uint32_t maxStorageBuffersPerDescriptor_ = 0, - uint32_t maxStorageImagesPerDescriptor_ = 0, - uint32_t maxSampledImagesPerDescriptor_ = 0, - uint32_t maxPipelineLayouts_ = 0 ) - : objectCount( objectCount_ ) - , pObjectEntryTypes( pObjectEntryTypes_ ) - , pObjectEntryCounts( pObjectEntryCounts_ ) - , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) - , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) - , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) - , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) - , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) - , maxPipelineLayouts( maxPipelineLayouts_ ) - { - } - - ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); - } - - ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); - return *this; - } - ObjectTableCreateInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ ) - { - objectCount = objectCount_; - return *this; - } - - ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ ) - { - pObjectEntryTypes = pObjectEntryTypes_; - return *this; - } - - ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ ) - { - pObjectEntryCounts = pObjectEntryCounts_; - return *this; - } - - ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ ) - { - pObjectEntryUsageFlags = pObjectEntryUsageFlags_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ ) - { - maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ ) - { - maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ ) - { - maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ ) - { - maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ ) - { - maxPipelineLayouts = maxPipelineLayouts_; - return *this; - } - - operator const VkObjectTableCreateInfoNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ObjectTableCreateInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectCount == rhs.objectCount ) - && ( pObjectEntryTypes == rhs.pObjectEntryTypes ) - && ( pObjectEntryCounts == rhs.pObjectEntryCounts ) - && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags ) - && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor ) - && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor ) - && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor ) - && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor ) - && ( maxPipelineLayouts == rhs.maxPipelineLayouts ); - } - - bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eObjectTableCreateInfoNVX; - - public: - const void* pNext = nullptr; - uint32_t objectCount; - const ObjectEntryTypeNVX* pObjectEntryTypes; - const uint32_t* pObjectEntryCounts; - const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; - uint32_t maxUniformBuffersPerDescriptor; - uint32_t maxStorageBuffersPerDescriptor; - uint32_t maxStorageImagesPerDescriptor; - uint32_t maxSampledImagesPerDescriptor; - uint32_t maxPipelineLayouts; - }; - static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableEntryNVX - { - ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, - ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() ) - : type( type_ ) - , flags( flags_ ) - { - } - - ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); - } - - ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); - return *this; - } - ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkObjectTableEntryNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ObjectTableEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ); - } - - bool operator!=( ObjectTableEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - }; - static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTablePipelineEntryNVX - { - ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, - ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), - Pipeline pipeline_ = Pipeline() ) - : type( type_ ) - , flags( flags_ ) - , pipeline( pipeline_ ) - { - } - - explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, - Pipeline pipeline_ = Pipeline() ) - : type( objectTableEntryNVX.type ) - , flags( objectTableEntryNVX.flags ) - , pipeline( pipeline_ ) - {} - - ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); - } - - ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); - return *this; - } - ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ ) - { - pipeline = pipeline_; - return *this; - } - - operator const VkObjectTablePipelineEntryNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipeline == rhs.pipeline ); - } - - bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Pipeline pipeline; - }; - static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableDescriptorSetEntryNVX - { - ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, - ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), - PipelineLayout pipelineLayout_ = PipelineLayout(), - DescriptorSet descriptorSet_ = DescriptorSet() ) - : type( type_ ) - , flags( flags_ ) - , pipelineLayout( pipelineLayout_ ) - , descriptorSet( descriptorSet_ ) - { - } - - explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, - PipelineLayout pipelineLayout_ = PipelineLayout(), - DescriptorSet descriptorSet_ = DescriptorSet() ) - : type( objectTableEntryNVX.type ) - , flags( objectTableEntryNVX.flags ) - , pipelineLayout( pipelineLayout_ ) - , descriptorSet( descriptorSet_ ) - {} - - ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); - } - - ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); - return *this; - } - ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) - { - pipelineLayout = pipelineLayout_; - return *this; - } - - ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ ) - { - descriptorSet = descriptorSet_; - return *this; - } - - operator const VkObjectTableDescriptorSetEntryNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( descriptorSet == rhs.descriptorSet ); - } - - bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - PipelineLayout pipelineLayout; - DescriptorSet descriptorSet; - }; - static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableVertexBufferEntryNVX - { - ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, - ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), - Buffer buffer_ = Buffer() ) - : type( type_ ) - , flags( flags_ ) - , buffer( buffer_ ) - { - } - - explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, - Buffer buffer_ = Buffer() ) - : type( objectTableEntryNVX.type ) - , flags( objectTableEntryNVX.flags ) - , buffer( buffer_ ) - {} - - ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); - } - - ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); - return *this; - } - ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkObjectTableVertexBufferEntryNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Buffer buffer; - }; - static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableIndexBufferEntryNVX - { - ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, - ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), - Buffer buffer_ = Buffer(), - IndexType indexType_ = IndexType::eUint16 ) - : type( type_ ) - , flags( flags_ ) - , buffer( buffer_ ) - , indexType( indexType_ ) - { - } - - explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, - Buffer buffer_ = Buffer(), - IndexType indexType_ = IndexType::eUint16 ) - : type( objectTableEntryNVX.type ) - , flags( objectTableEntryNVX.flags ) - , buffer( buffer_ ) - , indexType( indexType_ ) - {} - - ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); - } - - ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); - return *this; - } - ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ ) - { - indexType = indexType_; - return *this; - } - - operator const VkObjectTableIndexBufferEntryNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ) - && ( indexType == rhs.indexType ); - } - - bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Buffer buffer; - IndexType indexType; - }; - static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTablePushConstantEntryNVX - { - ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, - ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), - PipelineLayout pipelineLayout_ = PipelineLayout(), - ShaderStageFlags stageFlags_ = ShaderStageFlags() ) - : type( type_ ) - , flags( flags_ ) - , pipelineLayout( pipelineLayout_ ) - , stageFlags( stageFlags_ ) - { - } - - explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, - PipelineLayout pipelineLayout_ = PipelineLayout(), - ShaderStageFlags stageFlags_ = ShaderStageFlags() ) - : type( objectTableEntryNVX.type ) - , flags( objectTableEntryNVX.flags ) - , pipelineLayout( pipelineLayout_ ) - , stageFlags( stageFlags_ ) - {} - - ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); - } - - ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); - return *this; - } - ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) - { - pipelineLayout = pipelineLayout_; - return *this; - } - - ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ ) - { - stageFlags = stageFlags_; - return *this; - } - - operator const VkObjectTablePushConstantEntryNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( stageFlags == rhs.stageFlags ); - } - - bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - PipelineLayout pipelineLayout; - ShaderStageFlags stageFlags; - }; - static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" ); - - enum class DescriptorSetLayoutCreateFlagBits - { - ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, - eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT - }; - - using DescriptorSetLayoutCreateFlags = Flags; - - VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 ) - { - return DescriptorSetLayoutCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits ) - { - return ~( DescriptorSetLayoutCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT) - }; - }; - - struct DescriptorSetLayoutCreateInfo - { - DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), - uint32_t bindingCount_ = 0, - const DescriptorSetLayoutBinding* pBindings_ = nullptr ) - : flags( flags_ ) - , bindingCount( bindingCount_ ) - , pBindings( pBindings_ ) - { - } - - DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); - } - - DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); - return *this; - } - DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ ) - { - bindingCount = bindingCount_; - return *this; - } - - DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ ) - { - pBindings = pBindings_; - return *this; - } - - operator const VkDescriptorSetLayoutCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( bindingCount == rhs.bindingCount ) - && ( pBindings == rhs.pBindings ); - } - - bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; - - public: - const void* pNext = nullptr; - DescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const DescriptorSetLayoutBinding* pBindings; - }; - static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); - - enum class ExternalMemoryHandleTypeFlagBits - { - eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueFdKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eOpaqueWin32KmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, - eD3D11TextureKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, - eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, - eD3D11TextureKmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, - eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, - eD3D12HeapKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, - eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, - eD3D12ResourceKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, - eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, - eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, - eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, - eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT - }; - - using ExternalMemoryHandleTypeFlags = Flags; - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 ) - { - return ExternalMemoryHandleTypeFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits ) - { - return ~( ExternalMemoryHandleTypeFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT) - }; - }; - - using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; - - struct PhysicalDeviceExternalImageFormatInfo - { - PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) - : handleType( handleType_ ) - { - } - - PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) ); - } - - PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) ); - return *this; - } - PhysicalDeviceExternalImageFormatInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalImageFormatInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalImageFormatInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceExternalImageFormatInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalImageFormatInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" ); - - using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; - - struct PhysicalDeviceExternalBufferInfo - { - PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(), - BufferUsageFlags usage_ = BufferUsageFlags(), - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) - : flags( flags_ ) - , usage( usage_ ) - , handleType( handleType_ ) - { - } - - PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) ); - } - - PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) ); - return *this; - } - PhysicalDeviceExternalBufferInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalBufferInfo& setFlags( BufferCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PhysicalDeviceExternalBufferInfo& setUsage( BufferUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - PhysicalDeviceExternalBufferInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalBufferInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceExternalBufferInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( usage == rhs.usage ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalBufferInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; - - public: - const void* pNext = nullptr; - BufferCreateFlags flags; - BufferUsageFlags usage; - ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" ); - - using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; - - struct ExternalMemoryImageCreateInfo - { - ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() ) - : handleTypes( handleTypes_ ) - { - } - - ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) ); - } - - ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) ); - return *this; - } - ExternalMemoryImageCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExternalMemoryImageCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExternalMemoryImageCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalMemoryImageCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExternalMemoryImageCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalMemoryImageCreateInfo; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" ); - - using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; - - struct ExternalMemoryBufferCreateInfo - { - ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() ) - : handleTypes( handleTypes_ ) - { - } - - ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) ); - } - - ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) ); - return *this; - } - ExternalMemoryBufferCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExternalMemoryBufferCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExternalMemoryBufferCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalMemoryBufferCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExternalMemoryBufferCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" ); - - using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; - - struct ExportMemoryAllocateInfo - { - ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() ) - : handleTypes( handleTypes_ ) - { - } - - ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) ); - } - - ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) ); - return *this; - } - ExportMemoryAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryAllocateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportMemoryAllocateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportMemoryAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportMemoryAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryAllocateInfo; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" ); - - using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportMemoryWin32HandleInfoKHR - { - ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = 0 ) - : handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - { - } - - ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); - } - - ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); - return *this; - } - ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkImportMemoryWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ) - && ( name == rhs.name ); - } - - bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct MemoryGetWin32HandleInfoKHR - { - MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) - : memory( memory_ ) - , handleType( handleType_ ) - { - } - - MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); - } - - MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); - return *this; - } - MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkMemoryGetWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memory == rhs.memory ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - DeviceMemory memory; - ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct ImportMemoryFdInfoKHR - { - ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) - : handleType( handleType_ ) - , fd( fd_ ) - { - } - - ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); - } - - ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); - return *this; - } - ImportMemoryFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryFdInfoKHR& setFd( int fd_ ) - { - fd = fd_; - return *this; - } - - operator const VkImportMemoryFdInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportMemoryFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( fd == rhs.fd ); - } - - bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryFdInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); - - struct MemoryGetFdInfoKHR - { - MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) - : memory( memory_ ) - , handleType( handleType_ ) - { - } - - MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); - } - - MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); - return *this; - } - MemoryGetFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkMemoryGetFdInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryGetFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memory == rhs.memory ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( MemoryGetFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryGetFdInfoKHR; - - public: - const void* pNext = nullptr; - DeviceMemory memory; - ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); - - struct ImportMemoryHostPointerInfoEXT - { - ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - void* pHostPointer_ = nullptr ) - : handleType( handleType_ ) - , pHostPointer( pHostPointer_ ) - { - } - - ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) ); - } - - ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) ); - return *this; - } - ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ ) - { - pHostPointer = pHostPointer_; - return *this; - } - - operator const VkImportMemoryHostPointerInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( pHostPointer == rhs.pHostPointer ); - } - - bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBits handleType; - void* pHostPointer; - }; - static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" ); - - enum class ExternalMemoryFeatureFlagBits - { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, - eDedicatedOnlyKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, - eExportableKHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, - eImportableKHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT - }; - - using ExternalMemoryFeatureFlags = Flags; - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 ) - { - return ExternalMemoryFeatureFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits ) - { - return ~( ExternalMemoryFeatureFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBits::eExportable) | VkFlags(ExternalMemoryFeatureFlagBits::eImportable) - }; - }; - - using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; - - struct ExternalMemoryProperties - { - operator const VkExternalMemoryProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalMemoryProperties const& rhs ) const - { - return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); - } - - bool operator!=( ExternalMemoryProperties const& rhs ) const - { - return !operator==( rhs ); - } - - ExternalMemoryFeatureFlags externalMemoryFeatures; - ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; - ExternalMemoryHandleTypeFlags compatibleHandleTypes; - }; - static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" ); - - using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; - - struct ExternalImageFormatProperties - { - operator const VkExternalImageFormatProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalImageFormatProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( externalMemoryProperties == rhs.externalMemoryProperties ); - } - - bool operator!=( ExternalImageFormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalImageFormatProperties; - - public: - void* pNext = nullptr; - ExternalMemoryProperties externalMemoryProperties; - }; - static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" ); - - using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; - - struct ExternalBufferProperties - { - operator const VkExternalBufferProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalBufferProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( externalMemoryProperties == rhs.externalMemoryProperties ); - } - - bool operator!=( ExternalBufferProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalBufferProperties; - - public: - void* pNext = nullptr; - ExternalMemoryProperties externalMemoryProperties; - }; - static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" ); - - using ExternalBufferPropertiesKHR = ExternalBufferProperties; - - enum class ExternalSemaphoreHandleTypeFlagBits - { - eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eOpaqueWin32KmtKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - eD3D12FenceKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, - eSyncFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT - }; - - using ExternalSemaphoreHandleTypeFlags = Flags; - - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 ) - { - return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits ) - { - return ~( ExternalSemaphoreHandleTypeFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd) - }; - }; - - using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; - - struct PhysicalDeviceExternalSemaphoreInfo - { - PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) - : handleType( handleType_ ) - { - } - - PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) ); - } - - PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) ); - return *this; - } - PhysicalDeviceExternalSemaphoreInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalSemaphoreInfo& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalSemaphoreInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; - - public: - const void* pNext = nullptr; - ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" ); - - using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; - - struct ExportSemaphoreCreateInfo - { - ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() ) - : handleTypes( handleTypes_ ) - { - } - - ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) ); - } - - ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) ); - return *this; - } - ExportSemaphoreCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportSemaphoreCreateInfo& setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportSemaphoreCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportSemaphoreCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportSemaphoreCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportSemaphoreCreateInfo; - - public: - const void* pNext = nullptr; - ExternalSemaphoreHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" ); - - using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct SemaphoreGetWin32HandleInfoKHR - { - SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) - : semaphore( semaphore_ ) - , handleType( handleType_ ) - { - } - - SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); - } - - SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); - return *this; - } - SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkSemaphoreGetWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct SemaphoreGetFdInfoKHR - { - SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) - : semaphore( semaphore_ ) - , handleType( handleType_ ) - { - } - - SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); - } - - SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); - return *this; - } - SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkSemaphoreGetFdInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class ExternalSemaphoreFeatureFlagBits - { - eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, - eExportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, - eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, - eImportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT - }; - - using ExternalSemaphoreFeatureFlags = Flags; - - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 ) - { - return ExternalSemaphoreFeatureFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits ) - { - return ~( ExternalSemaphoreFeatureFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable) - }; - }; - - using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; - - struct ExternalSemaphoreProperties - { - operator const VkExternalSemaphoreProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalSemaphoreProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) - && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); - } - - bool operator!=( ExternalSemaphoreProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalSemaphoreProperties; - - public: - void* pNext = nullptr; - ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - ExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - ExternalSemaphoreFeatureFlags externalSemaphoreFeatures; - }; - static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" ); - - using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; - - enum class SemaphoreImportFlagBits - { - eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, - eTemporaryKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT - }; - - using SemaphoreImportFlags = Flags; - - VULKAN_HPP_INLINE SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 ) - { - return SemaphoreImportFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits ) - { - return ~( SemaphoreImportFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary) - }; - }; - - using SemaphoreImportFlagsKHR = SemaphoreImportFlags; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportSemaphoreWin32HandleInfoKHR - { - ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), - SemaphoreImportFlags flags_ = SemaphoreImportFlags(), - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = 0 ) - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - { - } - - ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); - } - - ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); - return *this; - } - ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkImportSemaphoreWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ) - && ( name == rhs.name ); - } - - bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - SemaphoreImportFlags flags; - ExternalSemaphoreHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct ImportSemaphoreFdInfoKHR - { - ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), - SemaphoreImportFlags flags_ = SemaphoreImportFlags(), - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - { - } - - ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); - } - - ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); - return *this; - } - ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setFd( int fd_ ) - { - fd = fd_; - return *this; - } - - operator const VkImportSemaphoreFdInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( fd == rhs.fd ); - } - - bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - SemaphoreImportFlags flags; - ExternalSemaphoreHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class ExternalFenceHandleTypeFlagBits - { - eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eOpaqueWin32KmtKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, - eSyncFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT - }; - - using ExternalFenceHandleTypeFlags = Flags; - - VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 ) - { - return ExternalFenceHandleTypeFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits ) - { - return ~( ExternalFenceHandleTypeFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd) - }; - }; - - using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; - - struct PhysicalDeviceExternalFenceInfo - { - PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd ) - : handleType( handleType_ ) - { - } - - PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) ); - } - - PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) ); - return *this; - } - PhysicalDeviceExternalFenceInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalFenceInfo& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalFenceInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceExternalFenceInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalFenceInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; - - public: - const void* pNext = nullptr; - ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" ); - - using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; - - struct ExportFenceCreateInfo - { - ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() ) - : handleTypes( handleTypes_ ) - { - } - - ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) ); - } - - ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) ); - return *this; - } - ExportFenceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportFenceCreateInfo& setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportFenceCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExportFenceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportFenceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportFenceCreateInfo; - - public: - const void* pNext = nullptr; - ExternalFenceHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" ); - - using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct FenceGetWin32HandleInfoKHR - { - FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd ) - : fence( fence_ ) - , handleType( handleType_ ) - { - } - - FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); - } - - FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); - return *this; - } - FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FenceGetWin32HandleInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkFenceGetWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct FenceGetFdInfoKHR - { - FenceGetFdInfoKHR( Fence fence_ = Fence(), - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd ) - : fence( fence_ ) - , handleType( handleType_ ) - { - } - - FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); - } - - FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); - return *this; - } - FenceGetFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FenceGetFdInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkFenceGetFdInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( FenceGetFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( FenceGetFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFenceGetFdInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class ExternalFenceFeatureFlagBits - { - eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, - eExportableKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, - eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, - eImportableKHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT - }; - - using ExternalFenceFeatureFlags = Flags; - - VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 ) - { - return ExternalFenceFeatureFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits ) - { - return ~( ExternalFenceFeatureFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) | VkFlags(ExternalFenceFeatureFlagBits::eImportable) - }; - }; - - using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; - - struct ExternalFenceProperties - { - operator const VkExternalFenceProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalFenceProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) - && ( externalFenceFeatures == rhs.externalFenceFeatures ); - } - - bool operator!=( ExternalFenceProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalFenceProperties; - - public: - void* pNext = nullptr; - ExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - ExternalFenceHandleTypeFlags compatibleHandleTypes; - ExternalFenceFeatureFlags externalFenceFeatures; - }; - static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" ); - - using ExternalFencePropertiesKHR = ExternalFenceProperties; - - enum class FenceImportFlagBits - { - eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT, - eTemporaryKHR = VK_FENCE_IMPORT_TEMPORARY_BIT - }; - - using FenceImportFlags = Flags; - - VULKAN_HPP_INLINE FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 ) - { - return FenceImportFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE FenceImportFlags operator~( FenceImportFlagBits bits ) - { - return ~( FenceImportFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(FenceImportFlagBits::eTemporary) - }; - }; - - using FenceImportFlagsKHR = FenceImportFlags; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportFenceWin32HandleInfoKHR - { - ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), - FenceImportFlags flags_ = FenceImportFlags(), - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = 0 ) - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - { - } - - ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); - } - - ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); - return *this; - } - ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkImportFenceWin32HandleInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ) - && ( name == rhs.name ); - } - - bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - FenceImportFlags flags; - ExternalFenceHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct ImportFenceFdInfoKHR - { - ImportFenceFdInfoKHR( Fence fence_ = Fence(), - FenceImportFlags flags_ = FenceImportFlags(), - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - { - } - - ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); - } - - ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); - return *this; - } - ImportFenceFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportFenceFdInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - ImportFenceFdInfoKHR& setFlags( FenceImportFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportFenceFdInfoKHR& setFd( int fd_ ) - { - fd = fd_; - return *this; - } - - operator const VkImportFenceFdInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportFenceFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( fd == rhs.fd ); - } - - bool operator!=( ImportFenceFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportFenceFdInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - FenceImportFlags flags; - ExternalFenceHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class SurfaceCounterFlagBitsEXT - { - eVblank = VK_SURFACE_COUNTER_VBLANK_EXT - }; - - using SurfaceCounterFlagsEXT = Flags; - - VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 ) - { - return SurfaceCounterFlagsEXT( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits ) - { - return ~( SurfaceCounterFlagsEXT( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank) - }; - }; - - struct SurfaceCapabilities2EXT - { - operator const VkSurfaceCapabilities2EXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SurfaceCapabilities2EXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( minImageCount == rhs.minImageCount ) - && ( maxImageCount == rhs.maxImageCount ) - && ( currentExtent == rhs.currentExtent ) - && ( minImageExtent == rhs.minImageExtent ) - && ( maxImageExtent == rhs.maxImageExtent ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( currentTransform == rhs.currentTransform ) - && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) - && ( supportedUsageFlags == rhs.supportedUsageFlags ) - && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters ); - } - - bool operator!=( SurfaceCapabilities2EXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSurfaceCapabilities2EXT; - - public: - void* pNext = nullptr; - uint32_t minImageCount; - uint32_t maxImageCount; - Extent2D currentExtent; - Extent2D minImageExtent; - Extent2D maxImageExtent; - uint32_t maxImageArrayLayers; - SurfaceTransformFlagsKHR supportedTransforms; - SurfaceTransformFlagBitsKHR currentTransform; - CompositeAlphaFlagsKHR supportedCompositeAlpha; - ImageUsageFlags supportedUsageFlags; - SurfaceCounterFlagsEXT supportedSurfaceCounters; - }; - static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" ); - - struct SwapchainCounterCreateInfoEXT - { - SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() ) - : surfaceCounters( surfaceCounters_ ) - { - } - - SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); - } - - SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); - return *this; - } - SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ ) - { - surfaceCounters = surfaceCounters_; - return *this; - } - - operator const VkSwapchainCounterCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surfaceCounters == rhs.surfaceCounters ); - } - - bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; - - public: - const void* pNext = nullptr; - SurfaceCounterFlagsEXT surfaceCounters; - }; - static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class DisplayPowerStateEXT - { - eOff = VK_DISPLAY_POWER_STATE_OFF_EXT, - eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT, - eOn = VK_DISPLAY_POWER_STATE_ON_EXT - }; - - struct DisplayPowerInfoEXT - { - DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff ) - : powerState( powerState_ ) - { - } - - DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); - } - - DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); - return *this; - } - DisplayPowerInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ ) - { - powerState = powerState_; - return *this; - } - - operator const VkDisplayPowerInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPowerInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( powerState == rhs.powerState ); - } - - bool operator!=( DisplayPowerInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayPowerInfoEXT; - - public: - const void* pNext = nullptr; - DisplayPowerStateEXT powerState; - }; - static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); - - enum class DeviceEventTypeEXT - { - eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - }; - - struct DeviceEventInfoEXT - { - DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug ) - : deviceEvent( deviceEvent_ ) - { - } - - DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); - } - - DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); - return *this; - } - DeviceEventInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ ) - { - deviceEvent = deviceEvent_; - return *this; - } - - operator const VkDeviceEventInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceEventInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceEvent == rhs.deviceEvent ); - } - - bool operator!=( DeviceEventInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceEventInfoEXT; - - public: - const void* pNext = nullptr; - DeviceEventTypeEXT deviceEvent; - }; - static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); - - enum class DisplayEventTypeEXT - { - eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - }; - - struct DisplayEventInfoEXT - { - DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut ) - : displayEvent( displayEvent_ ) - { - } - - DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); - } - - DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); - return *this; - } - DisplayEventInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ ) - { - displayEvent = displayEvent_; - return *this; - } - - operator const VkDisplayEventInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayEventInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( displayEvent == rhs.displayEvent ); - } - - bool operator!=( DisplayEventInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayEventInfoEXT; - - public: - const void* pNext = nullptr; - DisplayEventTypeEXT displayEvent; - }; - static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); - - enum class PeerMemoryFeatureFlagBits - { - eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, - eCopySrcKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, - eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, - eCopyDstKHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, - eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, - eGenericSrcKHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, - eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, - eGenericDstKHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT - }; - - using PeerMemoryFeatureFlags = Flags; - - VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 ) - { - return PeerMemoryFeatureFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits ) - { - return ~( PeerMemoryFeatureFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBits::eGenericDst) - }; - }; - - using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; - - enum class MemoryAllocateFlagBits - { - eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, - eDeviceMaskKHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT - }; - - using MemoryAllocateFlags = Flags; - - VULKAN_HPP_INLINE MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 ) - { - return MemoryAllocateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits ) - { - return ~( MemoryAllocateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask) - }; - }; - - using MemoryAllocateFlagsKHR = MemoryAllocateFlags; - - struct MemoryAllocateFlagsInfo - { - MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(), - uint32_t deviceMask_ = 0 ) - : flags( flags_ ) - , deviceMask( deviceMask_ ) - { - } - - MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) ); - } - - MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) ); - return *this; - } - MemoryAllocateFlagsInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryAllocateFlagsInfo& setFlags( MemoryAllocateFlags flags_ ) - { - flags = flags_; - return *this; - } - - MemoryAllocateFlagsInfo& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - operator const VkMemoryAllocateFlagsInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryAllocateFlagsInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( deviceMask == rhs.deviceMask ); - } - - bool operator!=( MemoryAllocateFlagsInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryAllocateFlagsInfo; - - public: - const void* pNext = nullptr; - MemoryAllocateFlags flags; - uint32_t deviceMask; - }; - static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" ); - - using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; - - enum class DeviceGroupPresentModeFlagBitsKHR - { - eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, - eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, - eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, - eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR - }; - - using DeviceGroupPresentModeFlagsKHR = Flags; - - VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 ) - { - return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits ) - { - return ~( DeviceGroupPresentModeFlagsKHR( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice) - }; - }; - - struct DeviceGroupPresentCapabilitiesKHR - { - operator const VkDeviceGroupPresentCapabilitiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupPresentCapabilitiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 ) - && ( modes == rhs.modes ); - } - - bool operator!=( DeviceGroupPresentCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; - - public: - const void* pNext = nullptr; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; - DeviceGroupPresentModeFlagsKHR modes; - }; - static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" ); - - struct DeviceGroupPresentInfoKHR - { - DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0, - const uint32_t* pDeviceMasks_ = nullptr, - DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal ) - : swapchainCount( swapchainCount_ ) - , pDeviceMasks( pDeviceMasks_ ) - , mode( mode_ ) - { - } - - DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) ); - } - - DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) ); - return *this; - } - DeviceGroupPresentInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupPresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - DeviceGroupPresentInfoKHR& setPDeviceMasks( const uint32_t* pDeviceMasks_ ) - { - pDeviceMasks = pDeviceMasks_; - return *this; - } - - DeviceGroupPresentInfoKHR& setMode( DeviceGroupPresentModeFlagBitsKHR mode_ ) - { - mode = mode_; - return *this; - } - - operator const VkDeviceGroupPresentInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pDeviceMasks == rhs.pDeviceMasks ) - && ( mode == rhs.mode ); - } - - bool operator!=( DeviceGroupPresentInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - DeviceGroupPresentModeFlagBitsKHR mode; - }; - static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" ); - - struct DeviceGroupSwapchainCreateInfoKHR - { - DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() ) - : modes( modes_ ) - { - } - - DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) ); - } - - DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) ); - return *this; - } - DeviceGroupSwapchainCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupSwapchainCreateInfoKHR& setModes( DeviceGroupPresentModeFlagsKHR modes_ ) - { - modes = modes_; - return *this; - } - - operator const VkDeviceGroupSwapchainCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( modes == rhs.modes ); - } - - bool operator!=( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; - - public: - const void* pNext = nullptr; - DeviceGroupPresentModeFlagsKHR modes; - }; - static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); - - enum class SwapchainCreateFlagBitsKHR - { - eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, - eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR - }; - - using SwapchainCreateFlagsKHR = Flags; - - VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 ) - { - return SwapchainCreateFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits ) - { - return ~( SwapchainCreateFlagsKHR( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected) - }; - }; - - struct SwapchainCreateInfoKHR - { - SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(), - SurfaceKHR surface_ = SurfaceKHR(), - uint32_t minImageCount_ = 0, - Format imageFormat_ = Format::eUndefined, - ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, - Extent2D imageExtent_ = Extent2D(), - uint32_t imageArrayLayers_ = 0, - ImageUsageFlags imageUsage_ = ImageUsageFlags(), - SharingMode imageSharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr, - SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, - CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, - PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, - Bool32 clipped_ = 0, - SwapchainKHR oldSwapchain_ = SwapchainKHR() ) - : flags( flags_ ) - , surface( surface_ ) - , minImageCount( minImageCount_ ) - , imageFormat( imageFormat_ ) - , imageColorSpace( imageColorSpace_ ) - , imageExtent( imageExtent_ ) - , imageArrayLayers( imageArrayLayers_ ) - , imageUsage( imageUsage_ ) - , imageSharingMode( imageSharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , preTransform( preTransform_ ) - , compositeAlpha( compositeAlpha_ ) - , presentMode( presentMode_ ) - , clipped( clipped_ ) - , oldSwapchain( oldSwapchain_ ) - { - } - - SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); - } - - SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); - return *this; - } - SwapchainCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ ) - { - surface = surface_; - return *this; - } - - SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ ) - { - minImageCount = minImageCount_; - return *this; - } - - SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ ) - { - imageFormat = imageFormat_; - return *this; - } - - SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ ) - { - imageColorSpace = imageColorSpace_; - return *this; - } - - SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) - { - imageExtent = imageExtent_; - return *this; - } - - SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ ) - { - imageArrayLayers = imageArrayLayers_; - return *this; - } - - SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ ) - { - imageUsage = imageUsage_; - return *this; - } - - SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ ) - { - imageSharingMode = imageSharingMode_; - return *this; - } - - SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ ) - { - preTransform = preTransform_; - return *this; - } - - SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ ) - { - compositeAlpha = compositeAlpha_; - return *this; - } - - SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ ) - { - presentMode = presentMode_; - return *this; - } - - SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ ) - { - clipped = clipped_; - return *this; - } - - SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ ) - { - oldSwapchain = oldSwapchain_; - return *this; - } - - operator const VkSwapchainCreateInfoKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SwapchainCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( surface == rhs.surface ) - && ( minImageCount == rhs.minImageCount ) - && ( imageFormat == rhs.imageFormat ) - && ( imageColorSpace == rhs.imageColorSpace ) - && ( imageExtent == rhs.imageExtent ) - && ( imageArrayLayers == rhs.imageArrayLayers ) - && ( imageUsage == rhs.imageUsage ) - && ( imageSharingMode == rhs.imageSharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) - && ( preTransform == rhs.preTransform ) - && ( compositeAlpha == rhs.compositeAlpha ) - && ( presentMode == rhs.presentMode ) - && ( clipped == rhs.clipped ) - && ( oldSwapchain == rhs.oldSwapchain ); - } - - bool operator!=( SwapchainCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSwapchainCreateInfoKHR; - - public: - const void* pNext = nullptr; - SwapchainCreateFlagsKHR flags; - SurfaceKHR surface; - uint32_t minImageCount; - Format imageFormat; - ColorSpaceKHR imageColorSpace; - Extent2D imageExtent; - uint32_t imageArrayLayers; - ImageUsageFlags imageUsage; - SharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - SurfaceTransformFlagBitsKHR preTransform; - CompositeAlphaFlagBitsKHR compositeAlpha; - PresentModeKHR presentMode; - Bool32 clipped; - SwapchainKHR oldSwapchain; - }; - static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); - - enum class ViewportCoordinateSwizzleNV - { - ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, - eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, - ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, - eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, - ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, - eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, - ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, - eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - }; - - struct ViewportSwizzleNV - { - ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX, - ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX, - ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX, - ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX ) - : x( x_ ) - , y( y_ ) - , z( z_ ) - , w( w_ ) - { - } - - ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); - } - - ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); - return *this; - } - ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ ) - { - x = x_; - return *this; - } - - ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ ) - { - y = y_; - return *this; - } - - ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ ) - { - z = z_; - return *this; - } - - ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ ) - { - w = w_; - return *this; - } - - operator const VkViewportSwizzleNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ViewportSwizzleNV const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( z == rhs.z ) - && ( w == rhs.w ); - } - - bool operator!=( ViewportSwizzleNV const& rhs ) const - { - return !operator==( rhs ); - } - - ViewportCoordinateSwizzleNV x; - ViewportCoordinateSwizzleNV y; - ViewportCoordinateSwizzleNV z; - ViewportCoordinateSwizzleNV w; - }; - static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); - - struct PipelineViewportSwizzleStateCreateInfoNV - { - PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), - uint32_t viewportCount_ = 0, - const ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewportSwizzles( pViewportSwizzles_ ) - { - } - - PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); - } - - PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); - return *this; - } - PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ ) - { - flags = flags_; - return *this; - } - - PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ ) - { - viewportCount = viewportCount_; - return *this; - } - - PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ ) - { - pViewportSwizzles = pViewportSwizzles_; - return *this; - } - - operator const VkPipelineViewportSwizzleStateCreateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( viewportCount == rhs.viewportCount ) - && ( pViewportSwizzles == rhs.pViewportSwizzles ); - } - - bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; - - public: - const void* pNext = nullptr; - PipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const ViewportSwizzleNV* pViewportSwizzles; - }; - static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" ); - - enum class DiscardRectangleModeEXT - { - eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, - eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - }; - - struct PipelineDiscardRectangleStateCreateInfoEXT - { - PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), - DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, - uint32_t discardRectangleCount_ = 0, - const Rect2D* pDiscardRectangles_ = nullptr ) - : flags( flags_ ) - , discardRectangleMode( discardRectangleMode_ ) - , discardRectangleCount( discardRectangleCount_ ) - , pDiscardRectangles( pDiscardRectangles_ ) - { - } - - PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); - } - - PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); - return *this; - } - PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ ) - { - discardRectangleMode = discardRectangleMode_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ ) - { - discardRectangleCount = discardRectangleCount_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ ) - { - pDiscardRectangles = pDiscardRectangles_; - return *this; - } - - operator const VkPipelineDiscardRectangleStateCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( discardRectangleMode == rhs.discardRectangleMode ) - && ( discardRectangleCount == rhs.discardRectangleCount ) - && ( pDiscardRectangles == rhs.pDiscardRectangles ); - } - - bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - PipelineDiscardRectangleStateCreateFlagsEXT flags; - DiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const Rect2D* pDiscardRectangles; - }; - static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class SubpassDescriptionFlagBits - { - ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, - ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX - }; - - using SubpassDescriptionFlags = Flags; - - VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 ) - { - return SubpassDescriptionFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits ) - { - return ~( SubpassDescriptionFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) - }; - }; - - struct SubpassDescription - { - SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(), - PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - uint32_t inputAttachmentCount_ = 0, - const AttachmentReference* pInputAttachments_ = nullptr, - uint32_t colorAttachmentCount_ = 0, - const AttachmentReference* pColorAttachments_ = nullptr, - const AttachmentReference* pResolveAttachments_ = nullptr, - const AttachmentReference* pDepthStencilAttachment_ = nullptr, - uint32_t preserveAttachmentCount_ = 0, - const uint32_t* pPreserveAttachments_ = nullptr ) - : flags( flags_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , inputAttachmentCount( inputAttachmentCount_ ) - , pInputAttachments( pInputAttachments_ ) - , colorAttachmentCount( colorAttachmentCount_ ) - , pColorAttachments( pColorAttachments_ ) - , pResolveAttachments( pResolveAttachments_ ) - , pDepthStencilAttachment( pDepthStencilAttachment_ ) - , preserveAttachmentCount( preserveAttachmentCount_ ) - , pPreserveAttachments( pPreserveAttachments_ ) - { - } - - SubpassDescription( VkSubpassDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDescription ) ); - } - - SubpassDescription& operator=( VkSubpassDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDescription ) ); - return *this; - } - SubpassDescription& setFlags( SubpassDescriptionFlags flags_ ) - { - flags = flags_; - return *this; - } - - SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ ) - { - inputAttachmentCount = inputAttachmentCount_; - return *this; - } - - SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ ) - { - pInputAttachments = pInputAttachments_; - return *this; - } - - SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ ) - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ ) - { - pColorAttachments = pColorAttachments_; - return *this; - } - - SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ ) - { - pResolveAttachments = pResolveAttachments_; - return *this; - } - - SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ ) - { - pDepthStencilAttachment = pDepthStencilAttachment_; - return *this; - } - - SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) - { - preserveAttachmentCount = preserveAttachmentCount_; - return *this; - } - - SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ ) - { - pPreserveAttachments = pPreserveAttachments_; - return *this; - } - - operator const VkSubpassDescription&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SubpassDescription const& rhs ) const - { - return ( flags == rhs.flags ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( inputAttachmentCount == rhs.inputAttachmentCount ) - && ( pInputAttachments == rhs.pInputAttachments ) - && ( colorAttachmentCount == rhs.colorAttachmentCount ) - && ( pColorAttachments == rhs.pColorAttachments ) - && ( pResolveAttachments == rhs.pResolveAttachments ) - && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) - && ( preserveAttachmentCount == rhs.preserveAttachmentCount ) - && ( pPreserveAttachments == rhs.pPreserveAttachments ); - } - - bool operator!=( SubpassDescription const& rhs ) const - { - return !operator==( rhs ); - } - - SubpassDescriptionFlags flags; - PipelineBindPoint pipelineBindPoint; - uint32_t inputAttachmentCount; - const AttachmentReference* pInputAttachments; - uint32_t colorAttachmentCount; - const AttachmentReference* pColorAttachments; - const AttachmentReference* pResolveAttachments; - const AttachmentReference* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; - }; - static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" ); - - struct RenderPassCreateInfo - { - RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), - uint32_t attachmentCount_ = 0, - const AttachmentDescription* pAttachments_ = nullptr, - uint32_t subpassCount_ = 0, - const SubpassDescription* pSubpasses_ = nullptr, - uint32_t dependencyCount_ = 0, - const SubpassDependency* pDependencies_ = nullptr ) - : flags( flags_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , subpassCount( subpassCount_ ) - , pSubpasses( pSubpasses_ ) - , dependencyCount( dependencyCount_ ) - , pDependencies( pDependencies_ ) - { - } - - RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); - } - - RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); - return *this; - } - RenderPassCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) - { - attachmentCount = attachmentCount_; - return *this; - } - - RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ ) - { - pAttachments = pAttachments_; - return *this; - } - - RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ ) - { - subpassCount = subpassCount_; - return *this; - } - - RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ ) - { - pSubpasses = pSubpasses_; - return *this; - } - - RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ ) - { - dependencyCount = dependencyCount_; - return *this; - } - - RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ ) - { - pDependencies = pDependencies_; - return *this; - } - - operator const VkRenderPassCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( RenderPassCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( attachmentCount == rhs.attachmentCount ) - && ( pAttachments == rhs.pAttachments ) - && ( subpassCount == rhs.subpassCount ) - && ( pSubpasses == rhs.pSubpasses ) - && ( dependencyCount == rhs.dependencyCount ) - && ( pDependencies == rhs.pDependencies ); - } - - bool operator!=( RenderPassCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassCreateInfo; - - public: - const void* pNext = nullptr; - RenderPassCreateFlags flags; - uint32_t attachmentCount; - const AttachmentDescription* pAttachments; - uint32_t subpassCount; - const SubpassDescription* pSubpasses; - uint32_t dependencyCount; - const SubpassDependency* pDependencies; - }; - static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); - - enum class PointClippingBehavior - { - eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, - eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - }; - - struct PhysicalDevicePointClippingProperties - { - operator const VkPhysicalDevicePointClippingProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDevicePointClippingProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pointClippingBehavior == rhs.pointClippingBehavior ); - } - - bool operator!=( PhysicalDevicePointClippingProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; - - public: - void* pNext = nullptr; - PointClippingBehavior pointClippingBehavior; - }; - static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" ); - - using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; - - enum class SamplerReductionModeEXT - { - eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, - eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT, - eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT - }; - - struct SamplerReductionModeCreateInfoEXT - { - SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage ) - : reductionMode( reductionMode_ ) - { - } - - SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); - } - - SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); - return *this; - } - SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ ) - { - reductionMode = reductionMode_; - return *this; - } - - operator const VkSamplerReductionModeCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( reductionMode == rhs.reductionMode ); - } - - bool operator!=( SamplerReductionModeCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; - - public: - const void* pNext = nullptr; - SamplerReductionModeEXT reductionMode; - }; - static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class TessellationDomainOrigin - { - eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, - eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - }; - - struct PipelineTessellationDomainOriginStateCreateInfo - { - PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft ) - : domainOrigin( domainOrigin_ ) - { - } - - PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) ); - } - - PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) ); - return *this; - } - PipelineTessellationDomainOriginStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineTessellationDomainOriginStateCreateInfo& setDomainOrigin( TessellationDomainOrigin domainOrigin_ ) - { - domainOrigin = domainOrigin_; - return *this; - } - - operator const VkPipelineTessellationDomainOriginStateCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( domainOrigin == rhs.domainOrigin ); - } - - bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; - - public: - const void* pNext = nullptr; - TessellationDomainOrigin domainOrigin; - }; - static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" ); - - using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; - - enum class SamplerYcbcrModelConversion - { - eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, - eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, - eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, - eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, - eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, - eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - }; - - enum class SamplerYcbcrRange - { - eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, - eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - }; - - enum class ChromaLocation - { - eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN, - eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN, - eMidpoint = VK_CHROMA_LOCATION_MIDPOINT, - eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT - }; - - struct SamplerYcbcrConversionCreateInfo - { - SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined, - SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, - SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull, - ComponentMapping components_ = ComponentMapping(), - ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven, - ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven, - Filter chromaFilter_ = Filter::eNearest, - Bool32 forceExplicitReconstruction_ = 0 ) - : format( format_ ) - , ycbcrModel( ycbcrModel_ ) - , ycbcrRange( ycbcrRange_ ) - , components( components_ ) - , xChromaOffset( xChromaOffset_ ) - , yChromaOffset( yChromaOffset_ ) - , chromaFilter( chromaFilter_ ) - , forceExplicitReconstruction( forceExplicitReconstruction_ ) - { - } - - SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) ); - } - - SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) ); - return *this; - } - SamplerYcbcrConversionCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ ) - { - ycbcrModel = ycbcrModel_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setYcbcrRange( SamplerYcbcrRange ycbcrRange_ ) - { - ycbcrRange = ycbcrRange_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setComponents( ComponentMapping components_ ) - { - components = components_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setXChromaOffset( ChromaLocation xChromaOffset_ ) - { - xChromaOffset = xChromaOffset_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setYChromaOffset( ChromaLocation yChromaOffset_ ) - { - yChromaOffset = yChromaOffset_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setChromaFilter( Filter chromaFilter_ ) - { - chromaFilter = chromaFilter_; - return *this; - } - - SamplerYcbcrConversionCreateInfo& setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ ) - { - forceExplicitReconstruction = forceExplicitReconstruction_; - return *this; - } - - operator const VkSamplerYcbcrConversionCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SamplerYcbcrConversionCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( ycbcrModel == rhs.ycbcrModel ) - && ( ycbcrRange == rhs.ycbcrRange ) - && ( components == rhs.components ) - && ( xChromaOffset == rhs.xChromaOffset ) - && ( yChromaOffset == rhs.yChromaOffset ) - && ( chromaFilter == rhs.chromaFilter ) - && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction ); - } - - bool operator!=( SamplerYcbcrConversionCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; - - public: - const void* pNext = nullptr; - Format format; - SamplerYcbcrModelConversion ycbcrModel; - SamplerYcbcrRange ycbcrRange; - ComponentMapping components; - ChromaLocation xChromaOffset; - ChromaLocation yChromaOffset; - Filter chromaFilter; - Bool32 forceExplicitReconstruction; - }; - static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" ); - - using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - struct AndroidHardwareBufferFormatPropertiesANDROID - { - operator const VkAndroidHardwareBufferFormatPropertiesANDROID&() const - { - return *reinterpret_cast(this); - } - - bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( externalFormat == rhs.externalFormat ) - && ( formatFeatures == rhs.formatFeatures ) - && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) - && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) - && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) - && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) - && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); - } - - bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; - - public: - void* pNext = nullptr; - Format format; - uint64_t externalFormat; - FormatFeatureFlags formatFeatures; - ComponentMapping samplerYcbcrConversionComponents; - SamplerYcbcrModelConversion suggestedYcbcrModel; - SamplerYcbcrRange suggestedYcbcrRange; - ChromaLocation suggestedXChromaOffset; - ChromaLocation suggestedYChromaOffset; - }; - static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - - enum class BlendOverlapEXT - { - eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, - eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, - eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT - }; - - struct PipelineColorBlendAdvancedStateCreateInfoEXT - { - PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, - Bool32 dstPremultiplied_ = 0, - BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated ) - : srcPremultiplied( srcPremultiplied_ ) - , dstPremultiplied( dstPremultiplied_ ) - , blendOverlap( blendOverlap_ ) - { - } - - PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); - return *this; - } - PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ ) - { - srcPremultiplied = srcPremultiplied_; - return *this; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ ) - { - dstPremultiplied = dstPremultiplied_; - return *this; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ ) - { - blendOverlap = blendOverlap_; - return *this; - } - - operator const VkPipelineColorBlendAdvancedStateCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcPremultiplied == rhs.srcPremultiplied ) - && ( dstPremultiplied == rhs.dstPremultiplied ) - && ( blendOverlap == rhs.blendOverlap ); - } - - bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - Bool32 srcPremultiplied; - Bool32 dstPremultiplied; - BlendOverlapEXT blendOverlap; - }; - static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class CoverageModulationModeNV - { - eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV, - eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV, - eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV, - eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV - }; - - struct PipelineCoverageModulationStateCreateInfoNV - { - PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), - CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, - Bool32 coverageModulationTableEnable_ = 0, - uint32_t coverageModulationTableCount_ = 0, - const float* pCoverageModulationTable_ = nullptr ) - : flags( flags_ ) - , coverageModulationMode( coverageModulationMode_ ) - , coverageModulationTableEnable( coverageModulationTableEnable_ ) - , coverageModulationTableCount( coverageModulationTableCount_ ) - , pCoverageModulationTable( pCoverageModulationTable_ ) - { - } - - PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); - } - - PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); - return *this; - } - PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) - { - flags = flags_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) - { - coverageModulationMode = coverageModulationMode_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) - { - coverageModulationTableEnable = coverageModulationTableEnable_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) - { - coverageModulationTableCount = coverageModulationTableCount_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ ) - { - pCoverageModulationTable = pCoverageModulationTable_; - return *this; - } - - operator const VkPipelineCoverageModulationStateCreateInfoNV&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( coverageModulationMode == rhs.coverageModulationMode ) - && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) - && ( coverageModulationTableCount == rhs.coverageModulationTableCount ) - && ( pCoverageModulationTable == rhs.pCoverageModulationTable ); - } - - bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; - - public: - const void* pNext = nullptr; - PipelineCoverageModulationStateCreateFlagsNV flags; - CoverageModulationModeNV coverageModulationMode; - Bool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; - }; - static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" ); - - enum class ValidationCacheHeaderVersionEXT - { - eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - }; - - enum class ShaderInfoTypeAMD - { - eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD, - eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD, - eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - }; - - enum class QueueGlobalPriorityEXT - { - eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, - eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT, - eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT, - eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - }; - - struct DeviceQueueGlobalPriorityCreateInfoEXT - { - DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow ) - : globalPriority( globalPriority_ ) - { - } - - DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); - } - - DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); - return *this; - } - DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ ) - { - globalPriority = globalPriority_; - return *this; - } - - operator const VkDeviceQueueGlobalPriorityCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( globalPriority == rhs.globalPriority ); - } - - bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; - - public: - const void* pNext = nullptr; - QueueGlobalPriorityEXT globalPriority; - }; - static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class DebugUtilsMessageSeverityFlagBitsEXT - { - eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, - eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, - eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, - eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT - }; - - using DebugUtilsMessageSeverityFlagsEXT = Flags; - - VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 ) - { - return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits ) - { - return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError) - }; - }; - - enum class DebugUtilsMessageTypeFlagBitsEXT - { - eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, - eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, - ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT - }; - - using DebugUtilsMessageTypeFlagsEXT = Flags; - - VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 ) - { - return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits ) - { - return ~( DebugUtilsMessageTypeFlagsEXT( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance) - }; - }; - - struct DebugUtilsMessengerCreateInfoEXT - { - DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(), - DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(), - DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(), - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr, - void* pUserData_ = nullptr ) - : flags( flags_ ) - , messageSeverity( messageSeverity_ ) - , messageType( messageType_ ) - , pfnUserCallback( pfnUserCallback_ ) - , pUserData( pUserData_ ) - { - } - - DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) ); - } - - DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) ); - return *this; - } - DebugUtilsMessengerCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugUtilsMessengerCreateInfoEXT& setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - DebugUtilsMessengerCreateInfoEXT& setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) - { - messageSeverity = messageSeverity_; - return *this; - } - - DebugUtilsMessengerCreateInfoEXT& setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) - { - messageType = messageType_; - return *this; - } - - DebugUtilsMessengerCreateInfoEXT& setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) - { - pfnUserCallback = pfnUserCallback_; - return *this; - } - - DebugUtilsMessengerCreateInfoEXT& setPUserData( void* pUserData_ ) - { - pUserData = pUserData_; - return *this; - } - - operator const VkDebugUtilsMessengerCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DebugUtilsMessengerCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( messageSeverity == rhs.messageSeverity ) - && ( messageType == rhs.messageType ) - && ( pfnUserCallback == rhs.pfnUserCallback ) - && ( pUserData == rhs.pUserData ); - } - - bool operator!=( DebugUtilsMessengerCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; - - public: - const void* pNext = nullptr; - DebugUtilsMessengerCreateFlagsEXT flags; - DebugUtilsMessageSeverityFlagsEXT messageSeverity; - DebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; - void* pUserData; - }; - static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class ConservativeRasterizationModeEXT - { - eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, - eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, - eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - }; - - struct PipelineRasterizationConservativeStateCreateInfoEXT - { - PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(), - ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled, - float extraPrimitiveOverestimationSize_ = 0 ) - : flags( flags_ ) - , conservativeRasterizationMode( conservativeRasterizationMode_ ) - , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ ) - { - } - - PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) ); - } - - PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) ); - return *this; - } - PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ ) - { - conservativeRasterizationMode = conservativeRasterizationMode_; - return *this; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ ) - { - extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_; - return *this; - } - - operator const VkPipelineRasterizationConservativeStateCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) - && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); - } - - bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - PipelineRasterizationConservativeStateCreateFlagsEXT flags; - ConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; - }; - static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class DescriptorBindingFlagBitsEXT - { - eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT, - eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT, - ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT, - eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT - }; - - using DescriptorBindingFlagsEXT = Flags; - - VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 ) - { - return DescriptorBindingFlagsEXT( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits ) - { - return ~( DescriptorBindingFlagsEXT( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(DescriptorBindingFlagBitsEXT::eUpdateAfterBind) | VkFlags(DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) | VkFlags(DescriptorBindingFlagBitsEXT::ePartiallyBound) | VkFlags(DescriptorBindingFlagBitsEXT::eVariableDescriptorCount) - }; - }; - - struct DescriptorSetLayoutBindingFlagsCreateInfoEXT - { - DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0, - const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) - : bindingCount( bindingCount_ ) - , pBindingFlags( pBindingFlags_ ) - { - } - - DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) ); - } - - DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) ); - return *this; - } - DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorSetLayoutBindingFlagsCreateInfoEXT& setBindingCount( uint32_t bindingCount_ ) - { - bindingCount = bindingCount_; - return *this; - } - - DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ ) - { - pBindingFlags = pBindingFlags_; - return *this; - } - - operator const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( bindingCount == rhs.bindingCount ) - && ( pBindingFlags == rhs.pBindingFlags ); - } - - bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT; - - public: - const void* pNext = nullptr; - uint32_t bindingCount; - const DescriptorBindingFlagsEXT* pBindingFlags; - }; - static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class VendorId - { - eViv = VK_VENDOR_ID_VIV, - eVsi = VK_VENDOR_ID_VSI, - eKazan = VK_VENDOR_ID_KAZAN - }; - - template - Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() ); -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type enumerateInstanceVersion(Dispatch const &d = Dispatch() ); -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d) - { - return static_cast( d.vkEnumerateInstanceVersion( pApiVersion ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type enumerateInstanceVersion(Dispatch const &d ) - { - uint32_t apiVersion; - Result result = static_cast( d.vkEnumerateInstanceVersion( &apiVersion ) ); - return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceVersion" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - template - Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ); -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() ); -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) - { - return static_cast( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceLayerProperties(Dispatch const &d ) - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - template - Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ); -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName = nullptr, Dispatch const &d = Dispatch() ); -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) - { - return static_cast( d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName, Dispatch const &d ) - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - // forward declarations - struct CmdProcessCommandsInfoNVX; - - class CommandBuffer - { - public: - VULKAN_HPP_CONSTEXPR CommandBuffer() - : m_commandBuffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) - : m_commandBuffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) - : m_commandBuffer( commandBuffer ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandBuffer & operator=(VkCommandBuffer commandBuffer) - { - m_commandBuffer = commandBuffer; - return *this; - } -#endif - - CommandBuffer & operator=( std::nullptr_t ) - { - m_commandBuffer = VK_NULL_HANDLE; - return *this; - } - - bool operator==( CommandBuffer const & rhs ) const - { - return m_commandBuffer == rhs.m_commandBuffer; - } - - bool operator!=(CommandBuffer const & rhs ) const - { - return m_commandBuffer != rhs.m_commandBuffer; - } - - bool operator<(CommandBuffer const & rhs ) const - { - return m_commandBuffer < rhs.m_commandBuffer; - } - - template - Result begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result end(Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type end(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const; - - template - void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void setViewport( uint32_t firstViewport, ArrayProxy viewports, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void setScissor( uint32_t firstScissor, ArrayProxy scissors, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const; - - template - void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = Dispatch() ) const; - - template - void setBlendConstants( const float blendConstants[4], Dispatch const &d = Dispatch() ) const; - - template - void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = Dispatch() ) const; - - template - void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const; - - template - void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const; - - template - void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const; - - template - void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy descriptorSets, ArrayProxy dynamicOffsets, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d = Dispatch() ) const; - - template - void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void bindVertexBuffers( uint32_t firstBinding, ArrayProxy buffers, ArrayProxy offsets, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const; - - template - void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const; - - template - void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; - - template - void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; - - template - void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const; - - template - void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const; - - template - void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Filter filter, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy data, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const; - - template - void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy ranges, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy ranges, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void clearAttachments( ArrayProxy attachments, ArrayProxy rects, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const; - - template - void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const; - - template - void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void waitEvents( ArrayProxy events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const; - - template - void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const; - - template - void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const; - - template - void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const; - - template - void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; - - template - void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy values, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const; - - template - void endRenderPass(Dispatch const &d = Dispatch() ) const; - - template - void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void executeCommands( ArrayProxy commandBuffers, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void debugMarkerEndEXT(Dispatch const &d = Dispatch() ) const; - - template - void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; - - template - void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; - - template - void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy descriptorWrites, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void setDeviceMask( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const; - - template - void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const; - - template - void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const; - - template - void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const; - - template - void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const; - - template - void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy viewportWScalings, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy discardRectangles, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const; - - template - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const; - - template - void drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; - - template - void drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const - { - return m_commandBuffer; - } - - explicit operator bool() const - { - return m_commandBuffer != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_commandBuffer == VK_NULL_HANDLE; - } - - private: - VkCommandBuffer m_commandBuffer; - }; - - static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); - - template - VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const - { - return static_cast( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( pBeginInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( &beginInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::begin" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result CommandBuffer::end(Dispatch const &d) const - { - return static_cast( d.vkEndCommandBuffer( m_commandBuffer ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::end(Dispatch const &d ) const - { - Result result = static_cast( d.vkEndCommandBuffer( m_commandBuffer ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::end" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d) const - { - return static_cast( d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d ) const - { - Result result = static_cast( d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::reset" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d) const - { - d.vkCmdBindPipeline( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( pipeline ) ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d ) const - { - d.vkCmdBindPipeline( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( pipeline ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d) const - { - d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast( pViewports ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy viewports, Dispatch const &d ) const - { - d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast( viewports.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d) const - { - d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast( pScissors ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy scissors, Dispatch const &d ) const - { - d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast( scissors.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const - { - d.vkCmdSetLineWidth( m_commandBuffer, lineWidth ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d ) const - { - d.vkCmdSetLineWidth( m_commandBuffer, lineWidth ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d) const - { - d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d ) const - { - d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d) const - { - d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d ) const - { - d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d) const - { - d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d ) const - { - d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const - { - d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast( faceMask ), compareMask ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const - { - d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast( faceMask ), compareMask ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const - { - d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast( faceMask ), writeMask ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const - { - d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast( faceMask ), writeMask ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const - { - d.vkCmdSetStencilReference( m_commandBuffer, static_cast( faceMask ), reference ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const - { - d.vkCmdSetStencilReference( m_commandBuffer, static_cast( faceMask ), reference ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d) const - { - d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), firstSet, descriptorSetCount, reinterpret_cast( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy descriptorSets, ArrayProxy dynamicOffsets, Dispatch const &d ) const - { - d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), firstSet, descriptorSets.size() , reinterpret_cast( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d) const - { - d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast( buffer ), offset, static_cast( indexType ) ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d ) const - { - d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast( buffer ), offset, static_cast( indexType ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d) const - { - d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast( pBuffers ), pOffsets ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy buffers, ArrayProxy offsets, Dispatch const &d ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); -#else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast( buffers.data() ), offsets.data() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d) const - { - d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d ) const - { - d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d) const - { - d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d ) const - { - d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const - { - d.vkCmdDrawIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const - { - d.vkCmdDrawIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const - { - d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const - { - d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast( buffer ), offset, drawCount, stride ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const - { - d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const - { - d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d) const - { - d.vkCmdDispatchIndirect( m_commandBuffer, static_cast( buffer ), offset ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d ) const - { - d.vkCmdDispatchIndirect( m_commandBuffer, static_cast( buffer ), offset ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d) const - { - d.vkCmdCopyBuffer( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstBuffer ), regionCount, reinterpret_cast( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d ) const - { - d.vkCmdCopyBuffer( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstBuffer ), regions.size() , reinterpret_cast( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d) const - { - d.vkCmdCopyImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d ) const - { - d.vkCmdCopyImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d) const - { - d.vkCmdBlitImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ), static_cast( filter ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Filter filter, Dispatch const &d ) const - { - d.vkCmdBlitImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ), static_cast( filter ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const - { - d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d ) const - { - d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast( srcBuffer ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const - { - d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstBuffer ), regionCount, reinterpret_cast( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy regions, Dispatch const &d ) const - { - d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstBuffer ), regions.size() , reinterpret_cast( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d) const - { - d.vkCmdUpdateBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, dataSize, pData ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy data, Dispatch const &d ) const - { - d.vkCmdUpdateBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d) const - { - d.vkCmdFillBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, size, data ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d ) const - { - d.vkCmdFillBuffer( m_commandBuffer, static_cast( dstBuffer ), dstOffset, size, data ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const - { - d.vkCmdClearColorImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( pColor ), rangeCount, reinterpret_cast( pRanges ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy ranges, Dispatch const &d ) const - { - d.vkCmdClearColorImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( &color ), ranges.size() , reinterpret_cast( ranges.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const - { - d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( pDepthStencil ), rangeCount, reinterpret_cast( pRanges ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy ranges, Dispatch const &d ) const - { - d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast( image ), static_cast( imageLayout ), reinterpret_cast( &depthStencil ), ranges.size() , reinterpret_cast( ranges.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d) const - { - d.vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast( pAttachments ), rectCount, reinterpret_cast( pRects ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy attachments, ArrayProxy rects, Dispatch const &d ) const - { - d.vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast( attachments.data() ), rects.size() , reinterpret_cast( rects.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d) const - { - d.vkCmdResolveImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy regions, Dispatch const &d ) const - { - d.vkCmdResolveImage( m_commandBuffer, static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regions.size() , reinterpret_cast( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const - { - d.vkCmdSetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const - { - d.vkCmdSetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const - { - d.vkCmdResetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const - { - d.vkCmdResetEvent( m_commandBuffer, static_cast( event ), static_cast( stageMask ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const - { - d.vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast( pEvents ), static_cast( srcStageMask ), static_cast( dstStageMask ), memoryBarrierCount, reinterpret_cast( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d ) const - { - d.vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast( events.data() ), static_cast( srcStageMask ), static_cast( dstStageMask ), memoryBarriers.size() , reinterpret_cast( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast( imageMemoryBarriers.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const - { - d.vkCmdPipelineBarrier( m_commandBuffer, static_cast( srcStageMask ), static_cast( dstStageMask ), static_cast( dependencyFlags ), memoryBarrierCount, reinterpret_cast( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy memoryBarriers, ArrayProxy bufferMemoryBarriers, ArrayProxy imageMemoryBarriers, Dispatch const &d ) const - { - d.vkCmdPipelineBarrier( m_commandBuffer, static_cast( srcStageMask ), static_cast( dstStageMask ), static_cast( dependencyFlags ), memoryBarriers.size() , reinterpret_cast( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast( imageMemoryBarriers.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d) const - { - d.vkCmdBeginQuery( m_commandBuffer, static_cast( queryPool ), query, static_cast( flags ) ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d ) const - { - d.vkCmdBeginQuery( m_commandBuffer, static_cast( queryPool ), query, static_cast( flags ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d) const - { - d.vkCmdEndQuery( m_commandBuffer, static_cast( queryPool ), query ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d ) const - { - d.vkCmdEndQuery( m_commandBuffer, static_cast( queryPool ), query ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const - { - d.vkCmdResetQueryPool( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const - { - d.vkCmdResetQueryPool( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d) const - { - d.vkCmdWriteTimestamp( m_commandBuffer, static_cast( pipelineStage ), static_cast( queryPool ), query ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d ) const - { - d.vkCmdWriteTimestamp( m_commandBuffer, static_cast( pipelineStage ), static_cast( queryPool ), query ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const - { - d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount, static_cast( dstBuffer ), dstOffset, stride, static_cast( flags ) ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const - { - d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast( queryPool ), firstQuery, queryCount, static_cast( dstBuffer ), dstOffset, stride, static_cast( flags ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const - { - d.vkCmdPushConstants( m_commandBuffer, static_cast( layout ), static_cast( stageFlags ), offset, size, pValues ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy values, Dispatch const &d ) const - { - d.vkCmdPushConstants( m_commandBuffer, static_cast( layout ), static_cast( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast( values.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d) const - { - d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast( pRenderPassBegin ), static_cast( contents ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d ) const - { - d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast( &renderPassBegin ), static_cast( contents ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d) const - { - d.vkCmdNextSubpass( m_commandBuffer, static_cast( contents ) ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d ) const - { - d.vkCmdNextSubpass( m_commandBuffer, static_cast( contents ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d) const - { - d.vkCmdEndRenderPass( m_commandBuffer ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d ) const - { - d.vkCmdEndRenderPass( m_commandBuffer ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const - { - d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast( pCommandBuffers ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy commandBuffers, Dispatch const &d ) const - { - d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast( commandBuffers.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const - { - d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast( pMarkerInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d ) const - { - d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT(Dispatch const &d) const - { - d.vkCmdDebugMarkerEndEXT( m_commandBuffer ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT(Dispatch const &d ) const - { - d.vkCmdDebugMarkerEndEXT( m_commandBuffer ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const - { - d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast( pMarkerInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d ) const - { - d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const - { - d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const - { - d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const - { - d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const - { - d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const - { - d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast( pProcessCommandsInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d ) const - { - d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast( &processCommandsInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const - { - d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast( pReserveSpaceInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d ) const - { - d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast( &reserveSpaceInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const - { - d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), set, descriptorWriteCount, reinterpret_cast( pDescriptorWrites ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy descriptorWrites, Dispatch const &d ) const - { - d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast( pipelineBindPoint ), static_cast( layout ), set, descriptorWrites.size() , reinterpret_cast( descriptorWrites.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d) const - { - d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d ) const - { - d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d) const - { - d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d ) const - { - d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const - { - d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const - { - d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const - { - d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const - { - d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const - { - d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast( descriptorUpdateTemplate ), static_cast( layout ), set, pData ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const - { - d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast( descriptorUpdateTemplate ), static_cast( layout ), set, pData ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const - { - d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast( pViewportWScalings ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy viewportWScalings, Dispatch const &d ) const - { - d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast( viewportWScalings.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d) const - { - d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast( pDiscardRectangles ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy discardRectangles, Dispatch const &d ) const - { - d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast( discardRectangles.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const - { - d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast( pSampleLocationsInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d ) const - { - d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast( &sampleLocationsInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const - { - d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( pLabelInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const - { - d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d) const - { - d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d ) const - { - d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const - { - d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( pLabelInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const - { - d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const - { - d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast( pipelineStage ), static_cast( dstBuffer ), dstOffset, marker ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const - { - d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast( pipelineStage ), static_cast( dstBuffer ), dstOffset, marker ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const - { - d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const - { - d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const - { - d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const - { - d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast( buffer ), offset, static_cast( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - struct SubmitInfo - { - SubmitInfo( uint32_t waitSemaphoreCount_ = 0, - const Semaphore* pWaitSemaphores_ = nullptr, - const PipelineStageFlags* pWaitDstStageMask_ = nullptr, - uint32_t commandBufferCount_ = 0, - const CommandBuffer* pCommandBuffers_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const Semaphore* pSignalSemaphores_ = nullptr ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , pWaitDstStageMask( pWaitDstStageMask_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBuffers( pCommandBuffers_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - { - } - - SubmitInfo( VkSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SubmitInfo ) ); - } - - SubmitInfo& operator=( VkSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SubmitInfo ) ); - return *this; - } - SubmitInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - SubmitInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - SubmitInfo& setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ ) - { - pWaitDstStageMask = pWaitDstStageMask_; - return *this; - } - - SubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) - { - commandBufferCount = commandBufferCount_; - return *this; - } - - SubmitInfo& setPCommandBuffers( const CommandBuffer* pCommandBuffers_ ) - { - pCommandBuffers = pCommandBuffers_; - return *this; - } - - SubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - SubmitInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) - { - pSignalSemaphores = pSignalSemaphores_; - return *this; - } - - operator const VkSubmitInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SubmitInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) - && ( commandBufferCount == rhs.commandBufferCount ) - && ( pCommandBuffers == rhs.pCommandBuffers ) - && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) - && ( pSignalSemaphores == rhs.pSignalSemaphores ); - } - - bool operator!=( SubmitInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSubmitInfo; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - const PipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const CommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); - - class Queue - { - public: - VULKAN_HPP_CONSTEXPR Queue() - : m_queue(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) - : m_queue(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) - : m_queue( queue ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Queue & operator=(VkQueue queue) - { - m_queue = queue; - return *this; - } -#endif - - Queue & operator=( std::nullptr_t ) - { - m_queue = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Queue const & rhs ) const - { - return m_queue == rhs.m_queue; - } - - bool operator!=(Queue const & rhs ) const - { - return m_queue != rhs.m_queue; - } - - bool operator<(Queue const & rhs ) const - { - return m_queue < rhs.m_queue; - } - - template - Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type submit( ArrayProxy submits, Fence fence, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result waitIdle(Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type waitIdle(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type bindSparse( ArrayProxy bindInfo, Fence fence, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const; - - template - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const - { - return m_queue; - } - - explicit operator bool() const - { - return m_queue != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_queue == VK_NULL_HANDLE; - } - - private: - VkQueue m_queue; - }; - - static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); - - template - VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const - { - return static_cast( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Queue::submit( ArrayProxy submits, Fence fence, Dispatch const &d ) const - { - Result result = static_cast( d.vkQueueSubmit( m_queue, submits.size() , reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::submit" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Queue::waitIdle(Dispatch const &d) const - { - return static_cast( d.vkQueueWaitIdle( m_queue ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Queue::waitIdle(Dispatch const &d ) const - { - Result result = static_cast( d.vkQueueWaitIdle( m_queue ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::waitIdle" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d) const - { - return static_cast( d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast( pBindInfo ), static_cast( fence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Queue::bindSparse( ArrayProxy bindInfo, Fence fence, Dispatch const &d ) const - { - Result result = static_cast( d.vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast( bindInfo.data() ), static_cast( fence ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::bindSparse" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d) const - { - return static_cast( d.vkQueuePresentKHR( m_queue, reinterpret_cast( pPresentInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkQueuePresentKHR( m_queue, reinterpret_cast( &presentInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const - { - d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast( pLabelInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const - { - d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d) const - { - d.vkQueueEndDebugUtilsLabelEXT( m_queue ); - } -#else - template - VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d ) const - { - d.vkQueueEndDebugUtilsLabelEXT( m_queue ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const - { - d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast( pLabelInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const - { - d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class Device; - - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueBuffer = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueBufferView = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = PoolFree; }; - using UniqueCommandBuffer = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueCommandPool = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueDescriptorPool = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = PoolFree; }; - using UniqueDescriptorSet = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueDescriptorSetLayout = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueDescriptorUpdateTemplate = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectFree; }; - using UniqueDeviceMemory = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueEvent = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueFence = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueFramebuffer = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueImage = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueImageView = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueIndirectCommandsLayoutNVX = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueObjectTableNVX = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniquePipeline = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniquePipelineCache = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniquePipelineLayout = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueQueryPool = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueRenderPass = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueSampler = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueSamplerYcbcrConversion = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueSemaphore = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueShaderModule = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueSwapchainKHR = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueValidationCacheEXT = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - class Device - { - public: - VULKAN_HPP_CONSTEXPR Device() - : m_device(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) - : m_device(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) - : m_device( device ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Device & operator=(VkDevice device) - { - m_device = device; - return *this; - } -#endif - - Device & operator=( std::nullptr_t ) - { - m_device = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Device const & rhs ) const - { - return m_device == rhs.m_device; - } - - bool operator!=(Device const & rhs ) const - { - return m_device != rhs.m_device; - } - - bool operator<(Device const & rhs ) const - { - return m_device < rhs.m_device; - } - - template - PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result waitIdle(Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type waitIdle(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void freeMemory( DeviceMemory memory, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void free( DeviceMemory memory, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const; - - template - Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type flushMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type invalidateMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - DeviceSize getMemoryCommitment( DeviceMemory memory, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - MemoryRequirements getBufferMemoryRequirements( Buffer buffer, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - MemoryRequirements getImageMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createFence( const FenceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createFenceUnique( const FenceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyFence( Fence fence, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Fence fence, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type resetFences( ArrayProxy fences, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const; - - template - Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result waitForFences( ArrayProxy fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroySemaphore( Semaphore semaphore, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Semaphore semaphore, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createEvent( const EventCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createEventUnique( const EventCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyEvent( Event event, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Event event, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getEventStatus( Event event, Dispatch const &d = Dispatch() ) const; - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result setEvent( Event event, Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type setEvent( Event event, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result resetEvent( Event event, Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type resetEvent( Event event, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyQueryPool( QueryPool queryPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( QueryPool queryPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createBuffer( const BufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createBufferUnique( const BufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyBuffer( Buffer buffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Buffer buffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createBufferView( const BufferViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyBufferView( BufferView bufferView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( BufferView bufferView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createImage( const ImageCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createImageUnique( const ImageCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyImage( Image image, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Image image, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createImageView( const ImageViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyImageView( ImageView imageView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( ImageView imageView, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyShaderModule( ShaderModule shaderModule, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( ShaderModule shaderModule, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyPipelineCache( PipelineCache pipelineCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( PipelineCache pipelineCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy srcCaches, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; - template , typename Dispatch = DispatchLoaderStatic> - ResultValueType::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; - template , typename Dispatch = DispatchLoaderStatic> - ResultValueType::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; - template , typename Dispatch = DispatchLoaderStatic> - ResultValueType::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; - template , typename Dispatch = DispatchLoaderStatic> - ResultValueType::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyPipeline( Pipeline pipeline, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Pipeline pipeline, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( PipelineLayout pipelineLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createSampler( const SamplerCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroySampler( Sampler sampler, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Sampler sampler, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( DescriptorSetLayout descriptorSetLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyDescriptorPool( DescriptorPool descriptorPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( DescriptorPool descriptorPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type free( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void updateDescriptorSets( ArrayProxy descriptorWrites, ArrayProxy descriptorCopies, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyFramebuffer( Framebuffer framebuffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Framebuffer framebuffer, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyRenderPass( RenderPass renderPass, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( RenderPass renderPass, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Extent2D getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyCommandPool( CommandPool commandPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( CommandPool commandPool, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void freeCommandBuffers( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void free( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; - template , typename Dispatch = DispatchLoaderStatic> - ResultValueType::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; - template , typename Dispatch = DispatchLoaderStatic> - ResultValueType::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroySwapchainKHR( SwapchainKHR swapchain, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( SwapchainKHR swapchain, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValue acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_NV - template - Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_NV*/ - - template - Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( ObjectTableNVX objectTable, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy pObjectTableEntries, ArrayProxy objectIndices, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy objectEntryTypes, ArrayProxy objectIndices, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const; - - template - void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template - Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template - Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template - Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type bindBufferMemory2( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type bindBufferMemory2KHR( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type bindImageMemory2( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type bindImageMemory2KHR( ArrayProxy bindInfos, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValue acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const; - - template - void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const; - - template - void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void setHdrMetadataEXT( ArrayProxy swapchains, ArrayProxy metadata, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; - - template - Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; - template - StructureChain getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; - template - StructureChain getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; - template - StructureChain getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; - template - StructureChain getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( SamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( ValidationCacheEXT validationCache, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy srcCaches, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; - template - StructureChain getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; - template - StructureChain getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template - Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const; - template - typename ResultValueType>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template - Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const - { - return m_device; - } - - explicit operator bool() const - { - return m_device != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_device == VK_NULL_HANDLE; - } - - private: - VkDevice m_device; - }; - - static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); - - template - VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char* pName, Dispatch const &d) const - { - return d.vkGetDeviceProcAddr( m_device, pName ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name, Dispatch const &d ) const - { - return d.vkGetDeviceProcAddr( m_device, name.c_str() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDevice( m_device, reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDevice( m_device, reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d) const - { - d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast( pQueue ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const - { - Queue queue; - d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast( &queue ) ); - return queue; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::waitIdle(Dispatch const &d) const - { - return static_cast( d.vkDeviceWaitIdle( m_device ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Device::waitIdle(Dispatch const &d ) const - { - Result result = static_cast( d.vkDeviceWaitIdle( m_device ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitIdle" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d) const - { - return static_cast( d.vkAllocateMemory( m_device, reinterpret_cast( pAllocateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMemory ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const &d ) const - { - DeviceMemory memory; - Result result = static_cast( d.vkAllocateMemory( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &memory ) ) ); - return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemory" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const &d ) const - { - DeviceMemory memory; - Result result = static_cast( d.vkAllocateMemory( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &memory ) ) ); - - ObjectFree deleter( *this, allocator ); - return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemoryUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional allocator, Dispatch const &d ) const - { - d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, Optional allocator, Dispatch const &d ) const - { - d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d) const - { - return static_cast( d.vkMapMemory( m_device, static_cast( memory ), offset, size, static_cast( flags ), ppData ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const &d ) const - { - void* pData; - Result result = static_cast( d.vkMapMemory( m_device, static_cast( memory ), offset, size, static_cast( flags ), &pData ) ); - return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING"::Device::mapMemory" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const - { - d.vkUnmapMemory( m_device, static_cast( memory ) ); - } -#else - template - VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d ) const - { - d.vkUnmapMemory( m_device, static_cast( memory ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const - { - return static_cast( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::flushMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d ) const - { - Result result = static_cast( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast( memoryRanges.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::flushMappedMemoryRanges" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const - { - return static_cast( d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::invalidateMappedMemoryRanges( ArrayProxy memoryRanges, Dispatch const &d ) const - { - Result result = static_cast( d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast( memoryRanges.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::invalidateMappedMemoryRanges" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const - { - d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), pCommittedMemoryInBytes ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const &d ) const - { - DeviceSize committedMemoryInBytes; - d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), &committedMemoryInBytes ); - return committedMemoryInBytes; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const - { - d.vkGetBufferMemoryRequirements( m_device, static_cast( buffer ), reinterpret_cast( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const &d ) const - { - MemoryRequirements memoryRequirements; - d.vkGetBufferMemoryRequirements( m_device, static_cast( buffer ), reinterpret_cast( &memoryRequirements ) ); - return memoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const - { - return static_cast( d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), memoryOffset ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const - { - Result result = static_cast( d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), memoryOffset ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const - { - d.vkGetImageMemoryRequirements( m_device, static_cast( image ), reinterpret_cast( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const &d ) const - { - MemoryRequirements memoryRequirements; - d.vkGetImageMemoryRequirements( m_device, static_cast( image ), reinterpret_cast( &memoryRequirements ) ); - return memoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const - { - return static_cast( d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), memoryOffset ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const - { - Result result = static_cast( d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), memoryOffset ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const - { - d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements( Image image, Dispatch const &d ) const - { - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); - return sparseMemoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const - { - return static_cast( d.vkCreateFence( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createFence( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Fence fence; - Result result = static_cast( d.vkCreateFence( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); - return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFence" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Fence fence; - Result result = static_cast( d.vkCreateFence( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFenceUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d) const - { - return static_cast( d.vkResetFences( m_device, fenceCount, reinterpret_cast( pFences ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::resetFences( ArrayProxy fences, Dispatch const &d ) const - { - Result result = static_cast( d.vkResetFences( m_device, fences.size() , reinterpret_cast( fences.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetFences" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d) const - { - return static_cast( d.vkGetFenceStatus( m_device, static_cast( fence ) ) ); - } -#else - template - VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d ) const - { - Result result = static_cast( d.vkGetFenceStatus( m_device, static_cast( fence ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d) const - { - return static_cast( d.vkWaitForFences( m_device, fenceCount, reinterpret_cast( pFences ), waitAll, timeout ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const - { - Result result = static_cast( d.vkWaitForFences( m_device, fences.size() , reinterpret_cast( fences.data() ), waitAll, timeout ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d) const - { - return static_cast( d.vkCreateSemaphore( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSemaphore ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Semaphore semaphore; - Result result = static_cast( d.vkCreateSemaphore( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &semaphore ) ) ); - return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphore" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Semaphore semaphore; - Result result = static_cast( d.vkCreateSemaphore( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &semaphore ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphoreUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d) const - { - return static_cast( d.vkCreateEvent( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pEvent ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createEvent( const EventCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Event event; - Result result = static_cast( d.vkCreateEvent( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &event ) ) ); - return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEvent" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Event event; - Result result = static_cast( d.vkCreateEvent( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &event ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEventUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Event event, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d) const - { - return static_cast( d.vkGetEventStatus( m_device, static_cast( event ) ) ); - } -#else - template - VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d ) const - { - Result result = static_cast( d.vkGetEventStatus( m_device, static_cast( event ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const &d) const - { - return static_cast( d.vkSetEvent( m_device, static_cast( event ) ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Device::setEvent( Event event, Dispatch const &d ) const - { - Result result = static_cast( d.vkSetEvent( m_device, static_cast( event ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setEvent" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const &d) const - { - return static_cast( d.vkResetEvent( m_device, static_cast( event ) ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Device::resetEvent( Event event, Dispatch const &d ) const - { - Result result = static_cast( d.vkResetEvent( m_device, static_cast( event ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetEvent" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d) const - { - return static_cast( d.vkCreateQueryPool( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pQueryPool ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - QueryPool queryPool; - Result result = static_cast( d.vkCreateQueryPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &queryPool ) ) ); - return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPool" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - QueryPool queryPool; - Result result = static_cast( d.vkCreateQueryPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &queryPool ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPoolUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const - { - return static_cast( d.vkGetQueryPoolResults( m_device, static_cast( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast( flags ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const - { - Result result = static_cast( d.vkGetQueryPoolResults( m_device, static_cast( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast( data.data() ), stride, static_cast( flags ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d) const - { - return static_cast( d.vkCreateBuffer( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pBuffer ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Buffer buffer; - Result result = static_cast( d.vkCreateBuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &buffer ) ) ); - return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBuffer" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Buffer buffer; - Result result = static_cast( d.vkCreateBuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &buffer ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d) const - { - return static_cast( d.vkCreateBufferView( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pView ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - BufferView view; - Result result = static_cast( d.vkCreateBufferView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); - return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferView" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - BufferView view; - Result result = static_cast( d.vkCreateBufferView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferViewUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d) const - { - return static_cast( d.vkCreateImage( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pImage ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createImage( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Image image; - Result result = static_cast( d.vkCreateImage( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &image ) ) ); - return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImage" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Image image; - Result result = static_cast( d.vkCreateImage( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &image ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Image image, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d) const - { - d.vkGetImageSubresourceLayout( m_device, static_cast( image ), reinterpret_cast( pSubresource ), reinterpret_cast( pLayout ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d ) const - { - SubresourceLayout layout; - d.vkGetImageSubresourceLayout( m_device, static_cast( image ), reinterpret_cast( &subresource ), reinterpret_cast( &layout ) ); - return layout; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d) const - { - return static_cast( d.vkCreateImageView( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pView ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - ImageView view; - Result result = static_cast( d.vkCreateImageView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); - return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageView" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - ImageView view; - Result result = static_cast( d.vkCreateImageView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageViewUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d) const - { - return static_cast( d.vkCreateShaderModule( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pShaderModule ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - ShaderModule shaderModule; - Result result = static_cast( d.vkCreateShaderModule( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shaderModule ) ) ); - return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModule" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - ShaderModule shaderModule; - Result result = static_cast( d.vkCreateShaderModule( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shaderModule ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModuleUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d) const - { - return static_cast( d.vkCreatePipelineCache( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelineCache ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - PipelineCache pipelineCache; - Result result = static_cast( d.vkCreatePipelineCache( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineCache ) ) ); - return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCache" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - PipelineCache pipelineCache; - Result result = static_cast( d.vkCreatePipelineCache( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineCache ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCacheUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const - { - return static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), pDataSize, pData ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d ) const - { - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - data.resize( dataSize ); - return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d) const - { - return static_cast( d.vkMergePipelineCaches( m_device, static_cast( dstCache ), srcCacheCount, reinterpret_cast( pSrcCaches ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy srcCaches, Dispatch const &d ) const - { - Result result = static_cast( d.vkMergePipelineCaches( m_device, static_cast( dstCache ), srcCaches.size() , reinterpret_cast( srcCaches.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergePipelineCaches" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const - { - return static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const - { - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); - return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" ); - } - template - VULKAN_HPP_INLINE ResultValueType::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Pipeline pipeline; - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); - return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipeline" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const - { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector pipelines; - pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); - Result result = static_cast(d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); - - ObjectDestroy deleter( *this, allocator ); - for ( size_t i=0 ; i - VULKAN_HPP_INLINE ResultValueType::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Pipeline pipeline; - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelineUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const - { - return static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const - { - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( pipelines.data() ) ) ); - return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" ); - } - template - VULKAN_HPP_INLINE ResultValueType::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Pipeline pipeline; - Result result = static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); - return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipeline" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const - { - static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" ); - std::vector pipelines; - pipelines.reserve( createInfos.size() ); - Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) ); - Result result = static_cast(d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); - - ObjectDestroy deleter( *this, allocator ); - for ( size_t i=0 ; i - VULKAN_HPP_INLINE ResultValueType::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Pipeline pipeline; - Result result = static_cast( d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelineUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d) const - { - return static_cast( d.vkCreatePipelineLayout( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelineLayout ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - PipelineLayout pipelineLayout; - Result result = static_cast( d.vkCreatePipelineLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineLayout ) ) ); - return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayout" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - PipelineLayout pipelineLayout; - Result result = static_cast( d.vkCreatePipelineLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineLayout ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayoutUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d) const - { - return static_cast( d.vkCreateSampler( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSampler ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Sampler sampler; - Result result = static_cast( d.vkCreateSampler( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &sampler ) ) ); - return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSampler" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Sampler sampler; - Result result = static_cast( d.vkCreateSampler( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &sampler ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d) const - { - return static_cast( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSetLayout ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorSetLayout setLayout; - Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &setLayout ) ) ); - return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayout" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorSetLayout setLayout; - Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &setLayout ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayoutUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDescriptorSetLayout( m_device, static_cast( descriptorSetLayout ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d) const - { - return static_cast( d.vkCreateDescriptorPool( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDescriptorPool ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorPool descriptorPool; - Result result = static_cast( d.vkCreateDescriptorPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorPool ) ) ); - return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPool" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorPool descriptorPool; - Result result = static_cast( d.vkCreateDescriptorPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorPool ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPoolUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d) const - { - return static_cast( d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d ) const - { - Result result = static_cast( d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetDescriptorPool" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d) const - { - return static_cast( d.vkAllocateDescriptorSets( m_device, reinterpret_cast( pAllocateInfo ), reinterpret_cast( pDescriptorSets ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const - { - std::vector descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast( d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); - return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const - { - static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueDescriptorSet ), "DescriptorSet is greater than UniqueDescriptorSet!" ); - std::vector descriptorSets; - descriptorSets.reserve( allocateInfo.descriptorSetCount ); - DescriptorSet* buffer = reinterpret_cast( reinterpret_cast( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueDescriptorSet ) - sizeof( DescriptorSet ) ) ); - Result result = static_cast(d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); - - PoolFree deleter( *this, allocateInfo.descriptorPool ); - for ( size_t i=0 ; i - VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const - { - return static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSetCount, reinterpret_cast( pDescriptorSets ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d ) const - { - Result result = static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSets.size() , reinterpret_cast( descriptorSets.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::freeDescriptorSets" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const - { - return static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSetCount, reinterpret_cast( pDescriptorSets ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::free( DescriptorPool descriptorPool, ArrayProxy descriptorSets, Dispatch const &d ) const - { - Result result = static_cast( d.vkFreeDescriptorSets( m_device, static_cast( descriptorPool ), descriptorSets.size() , reinterpret_cast( descriptorSets.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::free" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const - { - d.vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast( pDescriptorCopies ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy descriptorWrites, ArrayProxy descriptorCopies, Dispatch const &d ) const - { - d.vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast( descriptorCopies.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d) const - { - return static_cast( d.vkCreateFramebuffer( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFramebuffer ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Framebuffer framebuffer; - Result result = static_cast( d.vkCreateFramebuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &framebuffer ) ) ); - return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebuffer" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Framebuffer framebuffer; - Result result = static_cast( d.vkCreateFramebuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &framebuffer ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebufferUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const - { - return static_cast( d.vkCreateRenderPass( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pRenderPass ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ) ); - return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPassUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d) const - { - d.vkGetRenderAreaGranularity( m_device, static_cast( renderPass ), reinterpret_cast( pGranularity ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d ) const - { - Extent2D granularity; - d.vkGetRenderAreaGranularity( m_device, static_cast( renderPass ), reinterpret_cast( &granularity ) ); - return granularity; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d) const - { - return static_cast( d.vkCreateCommandPool( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pCommandPool ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - CommandPool commandPool; - Result result = static_cast( d.vkCreateCommandPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &commandPool ) ) ); - return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPool" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - CommandPool commandPool; - Result result = static_cast( d.vkCreateCommandPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &commandPool ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPoolUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const - { - return static_cast( d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d ) const - { - Result result = static_cast( d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetCommandPool" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const - { - return static_cast( d.vkAllocateCommandBuffers( m_device, reinterpret_cast( pAllocateInfo ), reinterpret_cast( pCommandBuffers ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const - { - std::vector commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast( d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); - return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const - { - static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueCommandBuffer ), "CommandBuffer is greater than UniqueCommandBuffer!" ); - std::vector commandBuffers; - commandBuffers.reserve( allocateInfo.commandBufferCount ); - CommandBuffer* buffer = reinterpret_cast( reinterpret_cast( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueCommandBuffer ) - sizeof( CommandBuffer ) ) ); - Result result = static_cast(d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); - - PoolFree deleter( *this, allocateInfo.commandPool ); - for ( size_t i=0 ; i - VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const - { - d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d ) const - { - d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBuffers.size() , reinterpret_cast( commandBuffers.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const - { - d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, ArrayProxy commandBuffers, Dispatch const &d ) const - { - d.vkFreeCommandBuffers( m_device, static_cast( commandPool ), commandBuffers.size() , reinterpret_cast( commandBuffers.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d) const - { - return static_cast( d.vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pSwapchains ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const - { - std::vector swapchains( createInfos.size() ); - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( swapchains.data() ) ) ); - return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" ); - } - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); - return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const - { - static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueSwapchainKHR ), "SwapchainKHR is greater than UniqueSwapchainKHR!" ); - std::vector swapchainKHRs; - swapchainKHRs.reserve( createInfos.size() ); - SwapchainKHR* buffer = reinterpret_cast( reinterpret_cast( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueSwapchainKHR ) - sizeof( SwapchainKHR ) ) ); - Result result = static_cast(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); - - ObjectDestroy deleter( *this, allocator ); - for ( size_t i=0 ; i - VULKAN_HPP_INLINE ResultValueType::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d) const - { - return static_cast( d.vkCreateSwapchainKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSwapchain ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSwapchainKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); - return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSwapchainKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d) const - { - return static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), pSwapchainImageCount, reinterpret_cast( pSwapchainImages ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d ) const - { - std::vector swapchainImages; - uint32_t swapchainImageCount; - Result result; - do - { - result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && swapchainImageCount ) - { - swapchainImages.resize( swapchainImageCount ); - result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); - swapchainImages.resize( swapchainImageCount ); - return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d) const - { - return static_cast( d.vkAcquireNextImageKHR( m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), pImageIndex ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValue Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d ) const - { - uint32_t imageIndex; - Result result = static_cast( d.vkAcquireNextImageKHR( m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), &imageIndex ) ); - return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const - { - return static_cast( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( pNameInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectNameEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const - { - return static_cast( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( pTagInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectTagEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_NV - template - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const - { - return static_cast( d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const - { - HANDLE handle; - Result result = static_cast( d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleNV" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_NV*/ - - template - VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const - { - return static_cast( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pIndirectCommandsLayout ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const - { - IndirectCommandsLayoutNVX indirectCommandsLayout; - Result result = static_cast( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &indirectCommandsLayout ) ) ); - return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVX" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const - { - IndirectCommandsLayoutNVX indirectCommandsLayout; - Result result = static_cast( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &indirectCommandsLayout ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVXUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d) const - { - return static_cast( d.vkCreateObjectTableNVX( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pObjectTable ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const - { - ObjectTableNVX objectTable; - Result result = static_cast( d.vkCreateObjectTableNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &objectTable ) ) ); - return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVX" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional allocator, Dispatch const &d ) const - { - ObjectTableNVX objectTable; - Result result = static_cast( d.vkCreateObjectTableNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &objectTable ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVXUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyObjectTableNVX( m_device, static_cast( objectTable ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const - { - return static_cast( d.vkRegisterObjectsNVX( m_device, static_cast( objectTable ), objectCount, reinterpret_cast( ppObjectTableEntries ), pObjectIndices ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy pObjectTableEntries, ArrayProxy objectIndices, Dispatch const &d ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( pObjectTableEntries.size() == objectIndices.size() ); -#else - if ( pObjectTableEntries.size() != objectIndices.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - Result result = static_cast( d.vkRegisterObjectsNVX( m_device, static_cast( objectTable ), pObjectTableEntries.size() , reinterpret_cast( pObjectTableEntries.data() ), objectIndices.data() ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::registerObjectsNVX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const - { - return static_cast( d.vkUnregisterObjectsNVX( m_device, static_cast( objectTable ), objectCount, reinterpret_cast( pObjectEntryTypes ), pObjectIndices ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy objectEntryTypes, ArrayProxy objectIndices, Dispatch const &d ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( objectEntryTypes.size() == objectIndices.size() ); -#else - if ( objectEntryTypes.size() != objectIndices.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - Result result = static_cast( d.vkUnregisterObjectsNVX( m_device, static_cast( objectTable ), objectEntryTypes.size() , reinterpret_cast( objectEntryTypes.data() ), objectIndices.data() ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::unregisterObjectsNVX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const - { - d.vkTrimCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ); - } -#else - template - VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const - { - d.vkTrimCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const - { - d.vkTrimCommandPoolKHR( m_device, static_cast( commandPool ), static_cast( flags ) ); - } -#else - template - VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const - { - d.vkTrimCommandPoolKHR( m_device, static_cast( commandPool ), static_cast( flags ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const - { - return static_cast( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const - { - HANDLE handle; - Result result = static_cast( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const - { - return static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( pMemoryWin32HandleProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const - { - MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; - Result result = static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( &memoryWin32HandleProperties ) ) ); - return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandlePropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template - VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const - { - return static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d ) const - { - int fd; - Result result = static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const - { - return static_cast( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( pMemoryFdProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const - { - MemoryFdPropertiesKHR memoryFdProperties; - Result result = static_cast( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); - return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdPropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const - { - return static_cast( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const - { - HANDLE handle; - Result result = static_cast( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const - { - return static_cast( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template - VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const - { - return static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d ) const - { - int fd; - Result result = static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const - { - return static_cast( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( pImportSemaphoreFdInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const - { - return static_cast( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const - { - HANDLE handle; - Result result = static_cast( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const - { - return static_cast( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( pImportFenceWin32HandleInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template - VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const - { - return static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d ) const - { - int fd; - Result result = static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const - { - return static_cast( d.vkImportFenceFdKHR( m_device, reinterpret_cast( pImportFenceFdInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const - { - return static_cast( d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( pDisplayPowerInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( &displayPowerInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::displayPowerControlEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const - { - return static_cast( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast( pDeviceEventInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator, Dispatch const &d ) const - { - Fence fence; - Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast( &deviceEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); - return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const - { - return static_cast( d.vkRegisterDisplayEventEXT( m_device, static_cast( display ), reinterpret_cast( pDisplayEventInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator, Dispatch const &d ) const - { - Fence fence; - Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, static_cast( display ), reinterpret_cast( &displayEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); - return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const - { - return static_cast( d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), pCounterValue ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const - { - uint64_t counterValue; - Result result = static_cast( d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), &counterValue ) ); - return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainCounterEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const - { - d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const - { - PeerMemoryFeatureFlags peerMemoryFeatures; - d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); - return peerMemoryFeatures; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const - { - d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const - { - PeerMemoryFeatureFlags peerMemoryFeatures; - d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); - return peerMemoryFeatures; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const - { - return static_cast( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::bindBufferMemory2( ArrayProxy bindInfos, Dispatch const &d ) const - { - Result result = static_cast( d.vkBindBufferMemory2( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const - { - return static_cast( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::bindBufferMemory2KHR( ArrayProxy bindInfos, Dispatch const &d ) const - { - Result result = static_cast( d.vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const - { - return static_cast( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::bindImageMemory2( ArrayProxy bindInfos, Dispatch const &d ) const - { - Result result = static_cast( d.vkBindImageMemory2( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const - { - return static_cast( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::bindImageMemory2KHR( ArrayProxy bindInfos, Dispatch const &d ) const - { - Result result = static_cast( d.vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const - { - return static_cast( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( pDeviceGroupPresentCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const - { - DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; - Result result = static_cast( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); - return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupPresentCapabilitiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const - { - return static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast( surface ), reinterpret_cast( pModes ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const - { - DeviceGroupPresentModeFlagsKHR modes; - Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast( surface ), reinterpret_cast( &modes ) ) ); - return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const - { - return static_cast( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( pAcquireInfo ), pImageIndex ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValue Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d ) const - { - uint32_t imageIndex; - Result result = static_cast( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( &acquireInfo ), &imageIndex ) ); - return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImage2KHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const - { - return static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDescriptorUpdateTemplate ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); - return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplate" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const - { - return static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDescriptorUpdateTemplate ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); - return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const - { - d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); - } -#else - template - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const - { - d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const - { - d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); - } -#else - template - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const - { - d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast( descriptorSet ), static_cast( descriptorUpdateTemplate ), pData ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d) const - { - d.vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast( pSwapchains ), reinterpret_cast( pMetadata ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy swapchains, ArrayProxy metadata, Dispatch const &d ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); -#else - if ( swapchains.size() != metadata.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - d.vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast( swapchains.data() ), reinterpret_cast( metadata.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d) const - { - return static_cast( d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); - } -#else - template - VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d ) const - { - Result result = static_cast( d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const - { - return static_cast( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast( swapchain ), reinterpret_cast( pDisplayTimingProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const - { - RefreshCycleDurationGOOGLE displayTimingProperties; - Result result = static_cast( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast( swapchain ), reinterpret_cast( &displayTimingProperties ) ) ); - return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getRefreshCycleDurationGOOGLE" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const - { - return static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), pPresentationTimingCount, reinterpret_cast( pPresentationTimings ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const - { - std::vector presentationTimings; - uint32_t presentationTimingCount; - Result result; - do - { - result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentationTimingCount ) - { - presentationTimings.resize( presentationTimingCount ); - result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, reinterpret_cast( presentationTimings.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); - presentationTimings.resize( presentationTimingCount ); - return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const - { - d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - MemoryRequirements2 memoryRequirements; - d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return memoryRequirements; - } - template - VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - StructureChain structureChain; - MemoryRequirements2& memoryRequirements = structureChain.template get(); - d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const - { - d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - MemoryRequirements2 memoryRequirements; - d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return memoryRequirements; - } - template - VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - StructureChain structureChain; - MemoryRequirements2& memoryRequirements = structureChain.template get(); - d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const - { - d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - MemoryRequirements2 memoryRequirements; - d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return memoryRequirements; - } - template - VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - StructureChain structureChain; - MemoryRequirements2& memoryRequirements = structureChain.template get(); - d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const - { - d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - MemoryRequirements2 memoryRequirements; - d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return memoryRequirements; - } - template - VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - StructureChain structureChain; - MemoryRequirements2& memoryRequirements = structureChain.template get(); - d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const - { - d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); - return sparseMemoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const - { - d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const - { - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); - return sparseMemoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const - { - return static_cast( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pYcbcrConversion ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); - return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversion" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const - { - return static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pYcbcrConversion ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); - return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySamplerYcbcrConversion( m_device, static_cast( ycbcrConversion ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast( ycbcrConversion ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast( ycbcrConversion ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d) const - { - d.vkGetDeviceQueue2( m_device, reinterpret_cast( pQueueInfo ), reinterpret_cast( pQueue ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const - { - Queue queue; - d.vkGetDeviceQueue2( m_device, reinterpret_cast( &queueInfo ), reinterpret_cast( &queue ) ); - return queue; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d) const - { - return static_cast( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pValidationCache ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const - { - ValidationCacheEXT validationCache; - Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &validationCache ) ) ); - return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXT" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const - { - ValidationCacheEXT validationCache; - Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &validationCache ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXTUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyValidationCacheEXT( m_device, static_cast( validationCache ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const - { - return static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), pDataSize, pData ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d ) const - { - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - data.resize( dataSize ); - return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d) const - { - return static_cast( d.vkMergeValidationCachesEXT( m_device, static_cast( dstCache ), srcCacheCount, reinterpret_cast( pSrcCaches ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy srcCaches, Dispatch const &d ) const - { - Result result = static_cast( d.vkMergeValidationCachesEXT( m_device, static_cast( dstCache ), srcCaches.size() , reinterpret_cast( srcCaches.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergeValidationCachesEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const - { - d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pSupport ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const - { - DescriptorSetLayoutSupport support; - d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - return support; - } - template - VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const - { - StructureChain structureChain; - DescriptorSetLayoutSupport& support = structureChain.template get(); - d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const - { - d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pSupport ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const - { - DescriptorSetLayoutSupport support; - d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - return support; - } - template - VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const - { - StructureChain structureChain; - DescriptorSetLayoutSupport& support = structureChain.template get(); - d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const - { - return static_cast( d.vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), pInfoSize, pInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d ) const - { - std::vector info; - size_t infoSize; - Result result; - do - { - result = static_cast( d.vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), &infoSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && infoSize ) - { - info.resize( infoSize ); - result = static_cast( d.vkGetShaderInfoAMD( m_device, static_cast( pipeline ), static_cast( shaderStage ), static_cast( infoType ), &infoSize, reinterpret_cast( info.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( infoSize <= info.size() ); - info.resize( infoSize ); - return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const - { - return static_cast( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( pNameInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setDebugUtilsObjectNameEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d) const - { - return static_cast( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( pTagInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d ) const - { - Result result = static_cast( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setDebugUtilsObjectTagEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const - { - return static_cast( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast( handleType ), pHostPointer, reinterpret_cast( pMemoryHostPointerProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const - { - MemoryHostPointerPropertiesEXT memoryHostPointerProperties; - Result result = static_cast( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast( handleType ), pHostPointer, reinterpret_cast( &memoryHostPointerProperties ) ) ); - return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryHostPointerPropertiesEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template - VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const - { - return static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const - { - AndroidHardwareBufferPropertiesANDROID properties; - Result result = static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast( &properties ) ) ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" ); - } - template - VULKAN_HPP_INLINE typename ResultValueType>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const - { - StructureChain structureChain; - AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get(); - Result result = static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast( &properties ) ) ); - return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template - VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const - { - return static_cast( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( pInfo ), pBuffer ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d ) const - { - struct AHardwareBuffer* buffer; - Result result = static_cast( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( &info ), &buffer ) ); - return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryAndroidHardwareBufferANDROID" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueDevice = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - class PhysicalDevice - { - public: - VULKAN_HPP_CONSTEXPR PhysicalDevice() - : m_physicalDevice(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) - : m_physicalDevice(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) - : m_physicalDevice( physicalDevice ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) - { - m_physicalDevice = physicalDevice; - return *this; - } -#endif - - PhysicalDevice & operator=( std::nullptr_t ) - { - m_physicalDevice = VK_NULL_HANDLE; - return *this; - } - - bool operator==( PhysicalDevice const & rhs ) const - { - return m_physicalDevice == rhs.m_physicalDevice; - } - - bool operator!=(PhysicalDevice const & rhs ) const - { - return m_physicalDevice != rhs.m_physicalDevice; - } - - bool operator<(PhysicalDevice const & rhs ) const - { - return m_physicalDevice < rhs.m_physicalDevice; - } - - template - void getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - FormatProperties getFormatProperties( Format format, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDevice( const DeviceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type enumerateDeviceLayerProperties(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type enumerateDeviceExtensionProperties( Optional layerName = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getDisplayPropertiesKHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getDisplayPlanePropertiesKHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - template - Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - template - Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - template - Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d = Dispatch() ) const; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - template - Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - template - Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - template - Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const; - template - StructureChain getFeatures2(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const; - template - StructureChain getFeatures2KHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const; - template - StructureChain getProperties2(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const; - template - StructureChain getProperties2KHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; - template - typename ResultValueType>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; - template - typename ResultValueType>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - Result releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const; -#else - template - ResultValueType::type releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - template - Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - template - Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - - template - Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; - template - typename ResultValueType>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getDisplayProperties2KHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getDisplayPlaneProperties2KHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const - { - return m_physicalDevice; - } - - explicit operator bool() const - { - return m_physicalDevice != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_physicalDevice == VK_NULL_HANDLE; - } - - private: - VkPhysicalDevice m_physicalDevice; - }; - - static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); - - template - VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const - { - PhysicalDeviceProperties properties; - d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast( &properties ) ); - return properties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties(Dispatch const &d ) const - { - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - return queueFamilyProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast( pMemoryProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const - { - PhysicalDeviceMemoryProperties memoryProperties; - d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - return memoryProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const - { - d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast( pFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const - { - PhysicalDeviceFeatures features; - d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast( &features ) ); - return features; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast( format ), reinterpret_cast( pFormatProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const &d ) const - { - FormatProperties formatProperties; - d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - return formatProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), reinterpret_cast( pImageFormatProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d ) const - { - ImageFormatProperties imageFormatProperties; - Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d) const - { - return static_cast( d.vkCreateDevice( m_physicalDevice, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDevice ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Device device; - Result result = static_cast( d.vkCreateDevice( m_physicalDevice, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &device ) ) ); - return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDevice" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) const - { - Device device; - Result result = static_cast( d.vkCreateDevice( m_physicalDevice, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &device ) ) ); - - ObjectDestroy deleter( allocator ); - return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDeviceUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) const - { - return static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceLayerProperties(Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) const - { - return static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), pPropertyCount, reinterpret_cast( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), &propertyCount, reinterpret_cast( properties.data() ) ); - return properties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPropertiesKHR(Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d) const - { - return static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast( pDisplays ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d ) const - { - std::vector displays; - uint32_t displayCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && displayCount ) - { - displays.resize( displayCount ); - result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( displayCount <= displays.size() ); - displays.resize( displayCount ); - return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d) const - { - return static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d) const - { - return static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast( display ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMode ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - DisplayModeKHR mode; - Result result = static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast( display ), reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &mode ) ) ); - return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDisplayModeKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const - { - return static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( pCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const - { - DisplayPlaneCapabilitiesKHR capabilities; - Result result = static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( &capabilities ) ) ); - return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d) const - { - return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d ) const - { - return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast( surface ), pSupported ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d ) const - { - Bool32 supported; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast( surface ), &supported ) ); - return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast( surface ), reinterpret_cast( pSurfaceCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d ) const - { - SurfaceCapabilitiesKHR surfaceCapabilities; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilitiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d ) const - { - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - surfaceFormats.resize( surfaceFormatCount ); - return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), pPresentModeCount, reinterpret_cast( pPresentModes ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const - { - std::vector presentModes; - uint32_t presentModeCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); - presentModes.resize( presentModeCount ); - return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d) const - { - return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d ) const - { - return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d) const - { - return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ); - } -#else - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d ) const - { - return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d) const - { - return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d ) const - { - return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d) const - { - return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d ) const - { - return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), static_cast( externalHandleType ), reinterpret_cast( pExternalImageFormatProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const - { - ExternalImageFormatPropertiesNV externalImageFormatProperties; - Result result = static_cast( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), static_cast( externalHandleType ), reinterpret_cast( &externalImageFormatProperties ) ) ); - return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getExternalImageFormatPropertiesNV" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const - { - d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast( pFeatures ), reinterpret_cast( pLimits ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const - { - DeviceGeneratedCommandsLimitsNVX limits; - d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast( &features ), reinterpret_cast( &limits ) ); - return limits; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const - { - d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( pFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const - { - PhysicalDeviceFeatures2 features; - d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); - return features; - } - template - VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2(Dispatch const &d ) const - { - StructureChain structureChain; - PhysicalDeviceFeatures2& features = structureChain.template get(); - d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const - { - d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( pFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const - { - PhysicalDeviceFeatures2 features; - d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); - return features; - } - template - VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const - { - StructureChain structureChain; - PhysicalDeviceFeatures2& features = structureChain.template get(); - d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const - { - PhysicalDeviceProperties2 properties; - d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); - return properties; - } - template - VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2(Dispatch const &d ) const - { - StructureChain structureChain; - PhysicalDeviceProperties2& properties = structureChain.template get(); - d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const - { - PhysicalDeviceProperties2 properties; - d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); - return properties; - } - template - VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2KHR(Dispatch const &d ) const - { - StructureChain structureChain; - PhysicalDeviceProperties2& properties = structureChain.template get(); - d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( pFormatProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const - { - FormatProperties2 formatProperties; - d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - return formatProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast( format ), reinterpret_cast( pFormatProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const - { - FormatProperties2 formatProperties; - d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - return formatProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast( pImageFormatInfo ), reinterpret_cast( pImageFormatProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const - { - ImageFormatProperties2 imageFormatProperties; - Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" ); - } - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const - { - StructureChain structureChain; - ImageFormatProperties2& imageFormatProperties = structureChain.template get(); - Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( pImageFormatInfo ), reinterpret_cast( pImageFormatProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const - { - ImageFormatProperties2 imageFormatProperties; - Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" ); - } - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const - { - StructureChain structureChain; - ImageFormatProperties2& imageFormatProperties = structureChain.template get(); - Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d ) const - { - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - return queueFamilyProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d ) const - { - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - return queueFamilyProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( pMemoryProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const - { - PhysicalDeviceMemoryProperties2 memoryProperties; - d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - return memoryProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( pMemoryProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const - { - PhysicalDeviceMemoryProperties2 memoryProperties; - d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - return memoryProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast( pFormatInfo ), pPropertyCount, reinterpret_cast( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, reinterpret_cast( properties.data() ) ); - return properties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( pFormatInfo ), pPropertyCount, reinterpret_cast( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, reinterpret_cast( properties.data() ) ); - return properties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const - { - ExternalBufferProperties externalBufferProperties; - d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); - return externalBufferProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const - { - ExternalBufferProperties externalBufferProperties; - d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); - return externalBufferProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const - { - ExternalSemaphoreProperties externalSemaphoreProperties; - d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); - return externalSemaphoreProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const - { - ExternalSemaphoreProperties externalSemaphoreProperties; - d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); - return externalSemaphoreProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast( pExternalFenceInfo ), reinterpret_cast( pExternalFenceProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const - { - ExternalFenceProperties externalFenceProperties; - d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); - return externalFenceProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalFenceInfo ), reinterpret_cast( pExternalFenceProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const - { - ExternalFenceProperties externalFenceProperties; - d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); - return externalFenceProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d) const - { - return static_cast( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ) ); - } -#else - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d ) const - { - Result result = static_cast( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::releaseDisplayEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - template - VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d) const - { - return static_cast( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast( display ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d ) const - { - Display dpy; - Result result = static_cast( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast( display ) ) ); - return createResultValue( result, dpy, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::acquireXlibDisplayEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - template - VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d) const - { - return static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast( pDisplay ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const - { - DisplayKHR display; - Result result = static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); - return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getRandROutputDisplayEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast( surface ), reinterpret_cast( pSurfaceCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d ) const - { - SurfaceCapabilities2EXT surfaceCapabilities; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2EXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), pRectCount, reinterpret_cast( pRects ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d ) const - { - std::vector rects; - uint32_t rectCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && rectCount ) - { - rects.resize( rectCount ); - result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( rectCount <= rects.size() ); - rects.resize( rectCount ); - return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const - { - d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast( samples ), reinterpret_cast( pMultisampleProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d ) const - { - MultisamplePropertiesEXT multisampleProperties; - d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast( samples ), reinterpret_cast( &multisampleProperties ) ); - return multisampleProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( pSurfaceInfo ), reinterpret_cast( pSurfaceCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const - { - SurfaceCapabilities2KHR surfaceCapabilities; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" ); - } - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const - { - StructureChain structureChain; - SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get(); - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &surfaceCapabilities ) ) ); - return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const - { - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - surfaceFormats.resize( surfaceFormatCount ); - return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayProperties2KHR(Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const - { - return static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d) const - { - return static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d ) const - { - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const - { - return static_cast( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast( pDisplayPlaneInfo ), reinterpret_cast( pCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const - { - DisplayPlaneCapabilities2KHR capabilities; - Result result = static_cast( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast( &displayPlaneInfo ), reinterpret_cast( &capabilities ) ) ); - return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - struct CmdProcessCommandsInfoNVX - { - CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), - IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), - uint32_t indirectCommandsTokenCount_ = 0, - const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, - uint32_t maxSequencesCount_ = 0, - CommandBuffer targetCommandBuffer_ = CommandBuffer(), - Buffer sequencesCountBuffer_ = Buffer(), - DeviceSize sequencesCountOffset_ = 0, - Buffer sequencesIndexBuffer_ = Buffer(), - DeviceSize sequencesIndexOffset_ = 0 ) - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) - , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) - , maxSequencesCount( maxSequencesCount_ ) - , targetCommandBuffer( targetCommandBuffer_ ) - , sequencesCountBuffer( sequencesCountBuffer_ ) - , sequencesCountOffset( sequencesCountOffset_ ) - , sequencesIndexBuffer( sequencesIndexBuffer_ ) - , sequencesIndexOffset( sequencesIndexOffset_ ) - { - } - - CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); - } - - CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); - return *this; - } - CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CmdProcessCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ ) - { - objectTable = objectTable_; - return *this; - } - - CmdProcessCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ ) - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - CmdProcessCommandsInfoNVX& setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ ) - { - indirectCommandsTokenCount = indirectCommandsTokenCount_; - return *this; - } - - CmdProcessCommandsInfoNVX& setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ ) - { - pIndirectCommandsTokens = pIndirectCommandsTokens_; - return *this; - } - - CmdProcessCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ ) - { - maxSequencesCount = maxSequencesCount_; - return *this; - } - - CmdProcessCommandsInfoNVX& setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ ) - { - targetCommandBuffer = targetCommandBuffer_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesCountBuffer( Buffer sequencesCountBuffer_ ) - { - sequencesCountBuffer = sequencesCountBuffer_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesCountOffset( DeviceSize sequencesCountOffset_ ) - { - sequencesCountOffset = sequencesCountOffset_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ ) - { - sequencesIndexBuffer = sequencesIndexBuffer_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ ) - { - sequencesIndexOffset = sequencesIndexOffset_; - return *this; - } - - operator const VkCmdProcessCommandsInfoNVX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectTable == rhs.objectTable ) - && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) - && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount ) - && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens ) - && ( maxSequencesCount == rhs.maxSequencesCount ) - && ( targetCommandBuffer == rhs.targetCommandBuffer ) - && ( sequencesCountBuffer == rhs.sequencesCountBuffer ) - && ( sequencesCountOffset == rhs.sequencesCountOffset ) - && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) - && ( sequencesIndexOffset == rhs.sequencesIndexOffset ); - } - - bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; - - public: - const void* pNext = nullptr; - ObjectTableNVX objectTable; - IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t indirectCommandsTokenCount; - const IndirectCommandsTokenNVX* pIndirectCommandsTokens; - uint32_t maxSequencesCount; - CommandBuffer targetCommandBuffer; - Buffer sequencesCountBuffer; - DeviceSize sequencesCountOffset; - Buffer sequencesIndexBuffer; - DeviceSize sequencesIndexOffset; - }; - static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceGroupProperties - { - operator const VkPhysicalDeviceGroupProperties&() const - { - return *reinterpret_cast(this); - } - - bool operator==( PhysicalDeviceGroupProperties const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( physicalDeviceCount == rhs.physicalDeviceCount ) - && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( PhysicalDevice ) ) == 0 ) - && ( subsetAllocation == rhs.subsetAllocation ); - } - - bool operator!=( PhysicalDeviceGroupProperties const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceGroupProperties; - - public: - void* pNext = nullptr; - uint32_t physicalDeviceCount; - PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - Bool32 subsetAllocation; - }; - static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" ); - - using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class Instance; - - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueDebugReportCallbackEXT = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueDebugUtilsMessengerEXT = UniqueHandle; - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueSurfaceKHR = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - class Instance - { - public: - VULKAN_HPP_CONSTEXPR Instance() - : m_instance(VK_NULL_HANDLE) - {} - - VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) - : m_instance(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) - : m_instance( instance ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Instance & operator=(VkInstance instance) - { - m_instance = instance; - return *this; - } -#endif - - Instance & operator=( std::nullptr_t ) - { - m_instance = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Instance const & rhs ) const - { - return m_instance == rhs.m_instance; - } - - bool operator!=(Instance const & rhs ) const - { - return m_instance != rhs.m_instance; - } - - bool operator<(Instance const & rhs ) const - { - return m_instance < rhs.m_instance; - } - - template - void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type enumeratePhysicalDevices(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - template - Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - template - Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - template - Result createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - template - void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroySurfaceKHR( SurfaceKHR surface, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( SurfaceKHR surface, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_VI_NN - template - Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - template - Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - template - Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - template - Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - template - Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( DebugReportCallbackEXT callback, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type enumeratePhysicalDeviceGroups(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = DispatchLoaderStatic> - typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - template - Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - template - Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - template - Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void destroy( DebugUtilsMessengerEXT messenger, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const - { - return m_instance; - } - - explicit operator bool() const - { - return m_instance != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_instance == VK_NULL_HANDLE; - } - - private: - VkInstance m_instance; - }; - - static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); - - template - VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyInstance( m_instance, reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::destroy( Optional allocator, Dispatch const &d ) const - { - d.vkDestroyInstance( m_instance, reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d) const - { - return static_cast( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast( pPhysicalDevices ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDevices(Dispatch const &d ) const - { - std::vector physicalDevices; - uint32_t physicalDeviceCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceCount ) - { - physicalDevices.resize( physicalDeviceCount ); - result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); - physicalDevices.resize( physicalDeviceCount ); - return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char* pName, Dispatch const &d) const - { - return d.vkGetInstanceProcAddr( m_instance, pName ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name, Dispatch const &d ) const - { - return d.vkGetInstanceProcAddr( m_instance, name.c_str() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - template - VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - template - VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - template - VULKAN_HPP_INLINE Result Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - template - VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional allocator, Dispatch const &d ) const - { - d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_VI_NN - template - VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNN" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNNUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - template - VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - template - VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - template - VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - template - VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - template - VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d) const - { - return static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pCallback ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const - { - DebugReportCallbackEXT callback; - Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &callback ) ) ); - return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXT" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const - { - DebugReportCallbackEXT callback; - Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &callback ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXTUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast( callback ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const - { - d.vkDebugReportMessageEXT( m_instance, static_cast( flags ), static_cast( objectType ), object, location, messageCode, pLayerPrefix, pMessage ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() ); -#else - if ( layerPrefix.size() != message.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - d.vkDebugReportMessageEXT( m_instance, static_cast( flags ), static_cast( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const - { - return static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroups(Dispatch const &d ) const - { - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const - { - return static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroupsKHR(Dispatch const &d ) const - { - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - template - VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVK" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVKUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - template - VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const - { - return static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVK" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const &d ) const - { - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVKUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - template - VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const - { - return static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMessenger ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const - { - DebugUtilsMessengerEXT messenger; - Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &messenger ) ) ); - return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXT" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator, Dispatch const &d ) const - { - DebugUtilsMessengerEXT messenger; - Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &messenger ) ) ); - - ObjectDestroy deleter( *this, allocator ); - return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXTUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const - { - d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, Optional allocator, Dispatch const &d ) const - { - d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast( messenger ), reinterpret_cast( static_cast( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d) const - { - d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast( messageSeverity ), static_cast( messageTypes ), reinterpret_cast( pCallbackData ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d ) const - { - d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast( messageSeverity ), static_cast( messageTypes ), reinterpret_cast( &callbackData ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - struct DeviceGroupDeviceCreateInfo - { - DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0, - const PhysicalDevice* pPhysicalDevices_ = nullptr ) - : physicalDeviceCount( physicalDeviceCount_ ) - , pPhysicalDevices( pPhysicalDevices_ ) - { - } - - DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) ); - } - - DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) ); - return *this; - } - DeviceGroupDeviceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupDeviceCreateInfo& setPhysicalDeviceCount( uint32_t physicalDeviceCount_ ) - { - physicalDeviceCount = physicalDeviceCount_; - return *this; - } - - DeviceGroupDeviceCreateInfo& setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ ) - { - pPhysicalDevices = pPhysicalDevices_; - return *this; - } - - operator const VkDeviceGroupDeviceCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DeviceGroupDeviceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( physicalDeviceCount == rhs.physicalDeviceCount ) - && ( pPhysicalDevices == rhs.pPhysicalDevices ); - } - - bool operator!=( DeviceGroupDeviceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; - - public: - const void* pNext = nullptr; - uint32_t physicalDeviceCount; - const PhysicalDevice* pPhysicalDevices; - }; - static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" ); - - using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - - template <> class UniqueHandleTraits {public: using deleter = ObjectDestroy; }; - using UniqueInstance = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - template - Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d = Dispatch() ); -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - ResultValueType::type createInstance( const InstanceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ); -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - ResultValueType::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ); -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - template - VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d) - { - return static_cast( d.vkCreateInstance( reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pInstance ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_INLINE ResultValueType::type createInstance( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) - { - Instance instance; - Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &instance ) ) ); - return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstance" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - VULKAN_HPP_INLINE ResultValueType::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const &d ) - { - Instance instance; - Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &instance ) ) ); - - ObjectDestroy deleter( allocator ); - return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstanceUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - struct BaseOutStructure - { - BaseOutStructure( ) - { - } - - BaseOutStructure( VkBaseOutStructure const & rhs ) - { - memcpy( this, &rhs, sizeof( BaseOutStructure ) ); - } - - BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) - { - memcpy( this, &rhs, sizeof( BaseOutStructure ) ); - return *this; - } - BaseOutStructure& setPNext( struct BaseOutStructure* pNext_ ) - { - pNext = pNext_; - return *this; - } - - operator const VkBaseOutStructure&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BaseOutStructure const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ); - } - - bool operator!=( BaseOutStructure const& rhs ) const - { - return !operator==( rhs ); - } - - StructureType sType; - struct BaseOutStructure* pNext = nullptr; - }; - static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" ); - - struct BaseInStructure - { - BaseInStructure( ) - { - } - - BaseInStructure( VkBaseInStructure const & rhs ) - { - memcpy( this, &rhs, sizeof( BaseInStructure ) ); - } - - BaseInStructure& operator=( VkBaseInStructure const & rhs ) - { - memcpy( this, &rhs, sizeof( BaseInStructure ) ); - return *this; - } - BaseInStructure& setPNext( const struct BaseInStructure* pNext_ ) - { - pNext = pNext_; - return *this; - } - - operator const VkBaseInStructure&() const - { - return *reinterpret_cast(this); - } - - bool operator==( BaseInStructure const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ); - } - - bool operator!=( BaseInStructure const& rhs ) const - { - return !operator==( rhs ); - } - - StructureType sType; - const struct BaseInStructure* pNext = nullptr; - }; - static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); - - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_NV - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_NV*/ -#ifdef VK_USE_PLATFORM_WIN32_NV - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_NV*/ - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_NV - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_NV*/ - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - template <> struct isStructureChainValid{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - template <> struct isStructureChainValid{ enum { value = true }; }; - VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(EventCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(EventCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryMapFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryMapFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagBitsKHR) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagsKHR) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagBitsKHR) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagsKHR) - { - return "{}"; - } - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_VI_NN - VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_VI_NN - VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagBitsNV) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagsNV) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagBitsNV) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagsNV) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagBitsNV) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagsNV) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCallbackDataFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCallbackDataFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageLayout value) - { - switch (value) - { - case ImageLayout::eUndefined: return "Undefined"; - case ImageLayout::eGeneral: return "General"; - case ImageLayout::eColorAttachmentOptimal: return "ColorAttachmentOptimal"; - case ImageLayout::eDepthStencilAttachmentOptimal: return "DepthStencilAttachmentOptimal"; - case ImageLayout::eDepthStencilReadOnlyOptimal: return "DepthStencilReadOnlyOptimal"; - case ImageLayout::eShaderReadOnlyOptimal: return "ShaderReadOnlyOptimal"; - case ImageLayout::eTransferSrcOptimal: return "TransferSrcOptimal"; - case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal"; - case ImageLayout::ePreinitialized: return "Preinitialized"; - case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal: return "DepthReadOnlyStencilAttachmentOptimal"; - case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal: return "DepthAttachmentStencilReadOnlyOptimal"; - case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR"; - case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentLoadOp value) - { - switch (value) - { - case AttachmentLoadOp::eLoad: return "Load"; - case AttachmentLoadOp::eClear: return "Clear"; - case AttachmentLoadOp::eDontCare: return "DontCare"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentStoreOp value) - { - switch (value) - { - case AttachmentStoreOp::eStore: return "Store"; - case AttachmentStoreOp::eDontCare: return "DontCare"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageType value) - { - switch (value) - { - case ImageType::e1D: return "1D"; - case ImageType::e2D: return "2D"; - case ImageType::e3D: return "3D"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageTiling value) - { - switch (value) - { - case ImageTiling::eOptimal: return "Optimal"; - case ImageTiling::eLinear: return "Linear"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageViewType value) - { - switch (value) - { - case ImageViewType::e1D: return "1D"; - case ImageViewType::e2D: return "2D"; - case ImageViewType::e3D: return "3D"; - case ImageViewType::eCube: return "Cube"; - case ImageViewType::e1DArray: return "1DArray"; - case ImageViewType::e2DArray: return "2DArray"; - case ImageViewType::eCubeArray: return "CubeArray"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferLevel value) - { - switch (value) - { - case CommandBufferLevel::ePrimary: return "Primary"; - case CommandBufferLevel::eSecondary: return "Secondary"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ComponentSwizzle value) - { - switch (value) - { - case ComponentSwizzle::eIdentity: return "Identity"; - case ComponentSwizzle::eZero: return "Zero"; - case ComponentSwizzle::eOne: return "One"; - case ComponentSwizzle::eR: return "R"; - case ComponentSwizzle::eG: return "G"; - case ComponentSwizzle::eB: return "B"; - case ComponentSwizzle::eA: return "A"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorType value) - { - switch (value) - { - case DescriptorType::eSampler: return "Sampler"; - case DescriptorType::eCombinedImageSampler: return "CombinedImageSampler"; - case DescriptorType::eSampledImage: return "SampledImage"; - case DescriptorType::eStorageImage: return "StorageImage"; - case DescriptorType::eUniformTexelBuffer: return "UniformTexelBuffer"; - case DescriptorType::eStorageTexelBuffer: return "StorageTexelBuffer"; - case DescriptorType::eUniformBuffer: return "UniformBuffer"; - case DescriptorType::eStorageBuffer: return "StorageBuffer"; - case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic"; - case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic"; - case DescriptorType::eInputAttachment: return "InputAttachment"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryType value) - { - switch (value) - { - case QueryType::eOcclusion: return "Occlusion"; - case QueryType::ePipelineStatistics: return "PipelineStatistics"; - case QueryType::eTimestamp: return "Timestamp"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BorderColor value) - { - switch (value) - { - case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack"; - case BorderColor::eIntTransparentBlack: return "IntTransparentBlack"; - case BorderColor::eFloatOpaqueBlack: return "FloatOpaqueBlack"; - case BorderColor::eIntOpaqueBlack: return "IntOpaqueBlack"; - case BorderColor::eFloatOpaqueWhite: return "FloatOpaqueWhite"; - case BorderColor::eIntOpaqueWhite: return "IntOpaqueWhite"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineBindPoint value) - { - switch (value) - { - case PipelineBindPoint::eGraphics: return "Graphics"; - case PipelineBindPoint::eCompute: return "Compute"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCacheHeaderVersion value) - { - switch (value) - { - case PipelineCacheHeaderVersion::eOne: return "One"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PrimitiveTopology value) - { - switch (value) - { - case PrimitiveTopology::ePointList: return "PointList"; - case PrimitiveTopology::eLineList: return "LineList"; - case PrimitiveTopology::eLineStrip: return "LineStrip"; - case PrimitiveTopology::eTriangleList: return "TriangleList"; - case PrimitiveTopology::eTriangleStrip: return "TriangleStrip"; - case PrimitiveTopology::eTriangleFan: return "TriangleFan"; - case PrimitiveTopology::eLineListWithAdjacency: return "LineListWithAdjacency"; - case PrimitiveTopology::eLineStripWithAdjacency: return "LineStripWithAdjacency"; - case PrimitiveTopology::eTriangleListWithAdjacency: return "TriangleListWithAdjacency"; - case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency"; - case PrimitiveTopology::ePatchList: return "PatchList"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SharingMode value) - { - switch (value) - { - case SharingMode::eExclusive: return "Exclusive"; - case SharingMode::eConcurrent: return "Concurrent"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(IndexType value) - { - switch (value) - { - case IndexType::eUint16: return "Uint16"; - case IndexType::eUint32: return "Uint32"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(Filter value) - { - switch (value) - { - case Filter::eNearest: return "Nearest"; - case Filter::eLinear: return "Linear"; - case Filter::eCubicIMG: return "CubicIMG"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerMipmapMode value) - { - switch (value) - { - case SamplerMipmapMode::eNearest: return "Nearest"; - case SamplerMipmapMode::eLinear: return "Linear"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerAddressMode value) - { - switch (value) - { - case SamplerAddressMode::eRepeat: return "Repeat"; - case SamplerAddressMode::eMirroredRepeat: return "MirroredRepeat"; - case SamplerAddressMode::eClampToEdge: return "ClampToEdge"; - case SamplerAddressMode::eClampToBorder: return "ClampToBorder"; - case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CompareOp value) - { - switch (value) - { - case CompareOp::eNever: return "Never"; - case CompareOp::eLess: return "Less"; - case CompareOp::eEqual: return "Equal"; - case CompareOp::eLessOrEqual: return "LessOrEqual"; - case CompareOp::eGreater: return "Greater"; - case CompareOp::eNotEqual: return "NotEqual"; - case CompareOp::eGreaterOrEqual: return "GreaterOrEqual"; - case CompareOp::eAlways: return "Always"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PolygonMode value) - { - switch (value) - { - case PolygonMode::eFill: return "Fill"; - case PolygonMode::eLine: return "Line"; - case PolygonMode::ePoint: return "Point"; - case PolygonMode::eFillRectangleNV: return "FillRectangleNV"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CullModeFlagBits value) - { - switch (value) - { - case CullModeFlagBits::eNone: return "None"; - case CullModeFlagBits::eFront: return "Front"; - case CullModeFlagBits::eBack: return "Back"; - case CullModeFlagBits::eFrontAndBack: return "FrontAndBack"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CullModeFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CullModeFlagBits::eNone) result += "None | "; - if (value & CullModeFlagBits::eFront) result += "Front | "; - if (value & CullModeFlagBits::eBack) result += "Back | "; - if (value & CullModeFlagBits::eFrontAndBack) result += "FrontAndBack | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FrontFace value) - { - switch (value) - { - case FrontFace::eCounterClockwise: return "CounterClockwise"; - case FrontFace::eClockwise: return "Clockwise"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BlendFactor value) - { - switch (value) - { - case BlendFactor::eZero: return "Zero"; - case BlendFactor::eOne: return "One"; - case BlendFactor::eSrcColor: return "SrcColor"; - case BlendFactor::eOneMinusSrcColor: return "OneMinusSrcColor"; - case BlendFactor::eDstColor: return "DstColor"; - case BlendFactor::eOneMinusDstColor: return "OneMinusDstColor"; - case BlendFactor::eSrcAlpha: return "SrcAlpha"; - case BlendFactor::eOneMinusSrcAlpha: return "OneMinusSrcAlpha"; - case BlendFactor::eDstAlpha: return "DstAlpha"; - case BlendFactor::eOneMinusDstAlpha: return "OneMinusDstAlpha"; - case BlendFactor::eConstantColor: return "ConstantColor"; - case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor"; - case BlendFactor::eConstantAlpha: return "ConstantAlpha"; - case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha"; - case BlendFactor::eSrcAlphaSaturate: return "SrcAlphaSaturate"; - case BlendFactor::eSrc1Color: return "Src1Color"; - case BlendFactor::eOneMinusSrc1Color: return "OneMinusSrc1Color"; - case BlendFactor::eSrc1Alpha: return "Src1Alpha"; - case BlendFactor::eOneMinusSrc1Alpha: return "OneMinusSrc1Alpha"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BlendOp value) - { - switch (value) - { - case BlendOp::eAdd: return "Add"; - case BlendOp::eSubtract: return "Subtract"; - case BlendOp::eReverseSubtract: return "ReverseSubtract"; - case BlendOp::eMin: return "Min"; - case BlendOp::eMax: return "Max"; - case BlendOp::eZeroEXT: return "ZeroEXT"; - case BlendOp::eSrcEXT: return "SrcEXT"; - case BlendOp::eDstEXT: return "DstEXT"; - case BlendOp::eSrcOverEXT: return "SrcOverEXT"; - case BlendOp::eDstOverEXT: return "DstOverEXT"; - case BlendOp::eSrcInEXT: return "SrcInEXT"; - case BlendOp::eDstInEXT: return "DstInEXT"; - case BlendOp::eSrcOutEXT: return "SrcOutEXT"; - case BlendOp::eDstOutEXT: return "DstOutEXT"; - case BlendOp::eSrcAtopEXT: return "SrcAtopEXT"; - case BlendOp::eDstAtopEXT: return "DstAtopEXT"; - case BlendOp::eXorEXT: return "XorEXT"; - case BlendOp::eMultiplyEXT: return "MultiplyEXT"; - case BlendOp::eScreenEXT: return "ScreenEXT"; - case BlendOp::eOverlayEXT: return "OverlayEXT"; - case BlendOp::eDarkenEXT: return "DarkenEXT"; - case BlendOp::eLightenEXT: return "LightenEXT"; - case BlendOp::eColordodgeEXT: return "ColordodgeEXT"; - case BlendOp::eColorburnEXT: return "ColorburnEXT"; - case BlendOp::eHardlightEXT: return "HardlightEXT"; - case BlendOp::eSoftlightEXT: return "SoftlightEXT"; - case BlendOp::eDifferenceEXT: return "DifferenceEXT"; - case BlendOp::eExclusionEXT: return "ExclusionEXT"; - case BlendOp::eInvertEXT: return "InvertEXT"; - case BlendOp::eInvertRgbEXT: return "InvertRgbEXT"; - case BlendOp::eLineardodgeEXT: return "LineardodgeEXT"; - case BlendOp::eLinearburnEXT: return "LinearburnEXT"; - case BlendOp::eVividlightEXT: return "VividlightEXT"; - case BlendOp::eLinearlightEXT: return "LinearlightEXT"; - case BlendOp::ePinlightEXT: return "PinlightEXT"; - case BlendOp::eHardmixEXT: return "HardmixEXT"; - case BlendOp::eHslHueEXT: return "HslHueEXT"; - case BlendOp::eHslSaturationEXT: return "HslSaturationEXT"; - case BlendOp::eHslColorEXT: return "HslColorEXT"; - case BlendOp::eHslLuminosityEXT: return "HslLuminosityEXT"; - case BlendOp::ePlusEXT: return "PlusEXT"; - case BlendOp::ePlusClampedEXT: return "PlusClampedEXT"; - case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT"; - case BlendOp::ePlusDarkerEXT: return "PlusDarkerEXT"; - case BlendOp::eMinusEXT: return "MinusEXT"; - case BlendOp::eMinusClampedEXT: return "MinusClampedEXT"; - case BlendOp::eContrastEXT: return "ContrastEXT"; - case BlendOp::eInvertOvgEXT: return "InvertOvgEXT"; - case BlendOp::eRedEXT: return "RedEXT"; - case BlendOp::eGreenEXT: return "GreenEXT"; - case BlendOp::eBlueEXT: return "BlueEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(StencilOp value) - { - switch (value) - { - case StencilOp::eKeep: return "Keep"; - case StencilOp::eZero: return "Zero"; - case StencilOp::eReplace: return "Replace"; - case StencilOp::eIncrementAndClamp: return "IncrementAndClamp"; - case StencilOp::eDecrementAndClamp: return "DecrementAndClamp"; - case StencilOp::eInvert: return "Invert"; - case StencilOp::eIncrementAndWrap: return "IncrementAndWrap"; - case StencilOp::eDecrementAndWrap: return "DecrementAndWrap"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(LogicOp value) - { - switch (value) - { - case LogicOp::eClear: return "Clear"; - case LogicOp::eAnd: return "And"; - case LogicOp::eAndReverse: return "AndReverse"; - case LogicOp::eCopy: return "Copy"; - case LogicOp::eAndInverted: return "AndInverted"; - case LogicOp::eNoOp: return "NoOp"; - case LogicOp::eXor: return "Xor"; - case LogicOp::eOr: return "Or"; - case LogicOp::eNor: return "Nor"; - case LogicOp::eEquivalent: return "Equivalent"; - case LogicOp::eInvert: return "Invert"; - case LogicOp::eOrReverse: return "OrReverse"; - case LogicOp::eCopyInverted: return "CopyInverted"; - case LogicOp::eOrInverted: return "OrInverted"; - case LogicOp::eNand: return "Nand"; - case LogicOp::eSet: return "Set"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(InternalAllocationType value) - { - switch (value) - { - case InternalAllocationType::eExecutable: return "Executable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SystemAllocationScope value) - { - switch (value) - { - case SystemAllocationScope::eCommand: return "Command"; - case SystemAllocationScope::eObject: return "Object"; - case SystemAllocationScope::eCache: return "Cache"; - case SystemAllocationScope::eDevice: return "Device"; - case SystemAllocationScope::eInstance: return "Instance"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PhysicalDeviceType value) - { - switch (value) - { - case PhysicalDeviceType::eOther: return "Other"; - case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu"; - case PhysicalDeviceType::eDiscreteGpu: return "DiscreteGpu"; - case PhysicalDeviceType::eVirtualGpu: return "VirtualGpu"; - case PhysicalDeviceType::eCpu: return "Cpu"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(VertexInputRate value) - { - switch (value) - { - case VertexInputRate::eVertex: return "Vertex"; - case VertexInputRate::eInstance: return "Instance"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(Format value) - { - switch (value) - { - case Format::eUndefined: return "Undefined"; - case Format::eR4G4UnormPack8: return "R4G4UnormPack8"; - case Format::eR4G4B4A4UnormPack16: return "R4G4B4A4UnormPack16"; - case Format::eB4G4R4A4UnormPack16: return "B4G4R4A4UnormPack16"; - case Format::eR5G6B5UnormPack16: return "R5G6B5UnormPack16"; - case Format::eB5G6R5UnormPack16: return "B5G6R5UnormPack16"; - case Format::eR5G5B5A1UnormPack16: return "R5G5B5A1UnormPack16"; - case Format::eB5G5R5A1UnormPack16: return "B5G5R5A1UnormPack16"; - case Format::eA1R5G5B5UnormPack16: return "A1R5G5B5UnormPack16"; - case Format::eR8Unorm: return "R8Unorm"; - case Format::eR8Snorm: return "R8Snorm"; - case Format::eR8Uscaled: return "R8Uscaled"; - case Format::eR8Sscaled: return "R8Sscaled"; - case Format::eR8Uint: return "R8Uint"; - case Format::eR8Sint: return "R8Sint"; - case Format::eR8Srgb: return "R8Srgb"; - case Format::eR8G8Unorm: return "R8G8Unorm"; - case Format::eR8G8Snorm: return "R8G8Snorm"; - case Format::eR8G8Uscaled: return "R8G8Uscaled"; - case Format::eR8G8Sscaled: return "R8G8Sscaled"; - case Format::eR8G8Uint: return "R8G8Uint"; - case Format::eR8G8Sint: return "R8G8Sint"; - case Format::eR8G8Srgb: return "R8G8Srgb"; - case Format::eR8G8B8Unorm: return "R8G8B8Unorm"; - case Format::eR8G8B8Snorm: return "R8G8B8Snorm"; - case Format::eR8G8B8Uscaled: return "R8G8B8Uscaled"; - case Format::eR8G8B8Sscaled: return "R8G8B8Sscaled"; - case Format::eR8G8B8Uint: return "R8G8B8Uint"; - case Format::eR8G8B8Sint: return "R8G8B8Sint"; - case Format::eR8G8B8Srgb: return "R8G8B8Srgb"; - case Format::eB8G8R8Unorm: return "B8G8R8Unorm"; - case Format::eB8G8R8Snorm: return "B8G8R8Snorm"; - case Format::eB8G8R8Uscaled: return "B8G8R8Uscaled"; - case Format::eB8G8R8Sscaled: return "B8G8R8Sscaled"; - case Format::eB8G8R8Uint: return "B8G8R8Uint"; - case Format::eB8G8R8Sint: return "B8G8R8Sint"; - case Format::eB8G8R8Srgb: return "B8G8R8Srgb"; - case Format::eR8G8B8A8Unorm: return "R8G8B8A8Unorm"; - case Format::eR8G8B8A8Snorm: return "R8G8B8A8Snorm"; - case Format::eR8G8B8A8Uscaled: return "R8G8B8A8Uscaled"; - case Format::eR8G8B8A8Sscaled: return "R8G8B8A8Sscaled"; - case Format::eR8G8B8A8Uint: return "R8G8B8A8Uint"; - case Format::eR8G8B8A8Sint: return "R8G8B8A8Sint"; - case Format::eR8G8B8A8Srgb: return "R8G8B8A8Srgb"; - case Format::eB8G8R8A8Unorm: return "B8G8R8A8Unorm"; - case Format::eB8G8R8A8Snorm: return "B8G8R8A8Snorm"; - case Format::eB8G8R8A8Uscaled: return "B8G8R8A8Uscaled"; - case Format::eB8G8R8A8Sscaled: return "B8G8R8A8Sscaled"; - case Format::eB8G8R8A8Uint: return "B8G8R8A8Uint"; - case Format::eB8G8R8A8Sint: return "B8G8R8A8Sint"; - case Format::eB8G8R8A8Srgb: return "B8G8R8A8Srgb"; - case Format::eA8B8G8R8UnormPack32: return "A8B8G8R8UnormPack32"; - case Format::eA8B8G8R8SnormPack32: return "A8B8G8R8SnormPack32"; - case Format::eA8B8G8R8UscaledPack32: return "A8B8G8R8UscaledPack32"; - case Format::eA8B8G8R8SscaledPack32: return "A8B8G8R8SscaledPack32"; - case Format::eA8B8G8R8UintPack32: return "A8B8G8R8UintPack32"; - case Format::eA8B8G8R8SintPack32: return "A8B8G8R8SintPack32"; - case Format::eA8B8G8R8SrgbPack32: return "A8B8G8R8SrgbPack32"; - case Format::eA2R10G10B10UnormPack32: return "A2R10G10B10UnormPack32"; - case Format::eA2R10G10B10SnormPack32: return "A2R10G10B10SnormPack32"; - case Format::eA2R10G10B10UscaledPack32: return "A2R10G10B10UscaledPack32"; - case Format::eA2R10G10B10SscaledPack32: return "A2R10G10B10SscaledPack32"; - case Format::eA2R10G10B10UintPack32: return "A2R10G10B10UintPack32"; - case Format::eA2R10G10B10SintPack32: return "A2R10G10B10SintPack32"; - case Format::eA2B10G10R10UnormPack32: return "A2B10G10R10UnormPack32"; - case Format::eA2B10G10R10SnormPack32: return "A2B10G10R10SnormPack32"; - case Format::eA2B10G10R10UscaledPack32: return "A2B10G10R10UscaledPack32"; - case Format::eA2B10G10R10SscaledPack32: return "A2B10G10R10SscaledPack32"; - case Format::eA2B10G10R10UintPack32: return "A2B10G10R10UintPack32"; - case Format::eA2B10G10R10SintPack32: return "A2B10G10R10SintPack32"; - case Format::eR16Unorm: return "R16Unorm"; - case Format::eR16Snorm: return "R16Snorm"; - case Format::eR16Uscaled: return "R16Uscaled"; - case Format::eR16Sscaled: return "R16Sscaled"; - case Format::eR16Uint: return "R16Uint"; - case Format::eR16Sint: return "R16Sint"; - case Format::eR16Sfloat: return "R16Sfloat"; - case Format::eR16G16Unorm: return "R16G16Unorm"; - case Format::eR16G16Snorm: return "R16G16Snorm"; - case Format::eR16G16Uscaled: return "R16G16Uscaled"; - case Format::eR16G16Sscaled: return "R16G16Sscaled"; - case Format::eR16G16Uint: return "R16G16Uint"; - case Format::eR16G16Sint: return "R16G16Sint"; - case Format::eR16G16Sfloat: return "R16G16Sfloat"; - case Format::eR16G16B16Unorm: return "R16G16B16Unorm"; - case Format::eR16G16B16Snorm: return "R16G16B16Snorm"; - case Format::eR16G16B16Uscaled: return "R16G16B16Uscaled"; - case Format::eR16G16B16Sscaled: return "R16G16B16Sscaled"; - case Format::eR16G16B16Uint: return "R16G16B16Uint"; - case Format::eR16G16B16Sint: return "R16G16B16Sint"; - case Format::eR16G16B16Sfloat: return "R16G16B16Sfloat"; - case Format::eR16G16B16A16Unorm: return "R16G16B16A16Unorm"; - case Format::eR16G16B16A16Snorm: return "R16G16B16A16Snorm"; - case Format::eR16G16B16A16Uscaled: return "R16G16B16A16Uscaled"; - case Format::eR16G16B16A16Sscaled: return "R16G16B16A16Sscaled"; - case Format::eR16G16B16A16Uint: return "R16G16B16A16Uint"; - case Format::eR16G16B16A16Sint: return "R16G16B16A16Sint"; - case Format::eR16G16B16A16Sfloat: return "R16G16B16A16Sfloat"; - case Format::eR32Uint: return "R32Uint"; - case Format::eR32Sint: return "R32Sint"; - case Format::eR32Sfloat: return "R32Sfloat"; - case Format::eR32G32Uint: return "R32G32Uint"; - case Format::eR32G32Sint: return "R32G32Sint"; - case Format::eR32G32Sfloat: return "R32G32Sfloat"; - case Format::eR32G32B32Uint: return "R32G32B32Uint"; - case Format::eR32G32B32Sint: return "R32G32B32Sint"; - case Format::eR32G32B32Sfloat: return "R32G32B32Sfloat"; - case Format::eR32G32B32A32Uint: return "R32G32B32A32Uint"; - case Format::eR32G32B32A32Sint: return "R32G32B32A32Sint"; - case Format::eR32G32B32A32Sfloat: return "R32G32B32A32Sfloat"; - case Format::eR64Uint: return "R64Uint"; - case Format::eR64Sint: return "R64Sint"; - case Format::eR64Sfloat: return "R64Sfloat"; - case Format::eR64G64Uint: return "R64G64Uint"; - case Format::eR64G64Sint: return "R64G64Sint"; - case Format::eR64G64Sfloat: return "R64G64Sfloat"; - case Format::eR64G64B64Uint: return "R64G64B64Uint"; - case Format::eR64G64B64Sint: return "R64G64B64Sint"; - case Format::eR64G64B64Sfloat: return "R64G64B64Sfloat"; - case Format::eR64G64B64A64Uint: return "R64G64B64A64Uint"; - case Format::eR64G64B64A64Sint: return "R64G64B64A64Sint"; - case Format::eR64G64B64A64Sfloat: return "R64G64B64A64Sfloat"; - case Format::eB10G11R11UfloatPack32: return "B10G11R11UfloatPack32"; - case Format::eE5B9G9R9UfloatPack32: return "E5B9G9R9UfloatPack32"; - case Format::eD16Unorm: return "D16Unorm"; - case Format::eX8D24UnormPack32: return "X8D24UnormPack32"; - case Format::eD32Sfloat: return "D32Sfloat"; - case Format::eS8Uint: return "S8Uint"; - case Format::eD16UnormS8Uint: return "D16UnormS8Uint"; - case Format::eD24UnormS8Uint: return "D24UnormS8Uint"; - case Format::eD32SfloatS8Uint: return "D32SfloatS8Uint"; - case Format::eBc1RgbUnormBlock: return "Bc1RgbUnormBlock"; - case Format::eBc1RgbSrgbBlock: return "Bc1RgbSrgbBlock"; - case Format::eBc1RgbaUnormBlock: return "Bc1RgbaUnormBlock"; - case Format::eBc1RgbaSrgbBlock: return "Bc1RgbaSrgbBlock"; - case Format::eBc2UnormBlock: return "Bc2UnormBlock"; - case Format::eBc2SrgbBlock: return "Bc2SrgbBlock"; - case Format::eBc3UnormBlock: return "Bc3UnormBlock"; - case Format::eBc3SrgbBlock: return "Bc3SrgbBlock"; - case Format::eBc4UnormBlock: return "Bc4UnormBlock"; - case Format::eBc4SnormBlock: return "Bc4SnormBlock"; - case Format::eBc5UnormBlock: return "Bc5UnormBlock"; - case Format::eBc5SnormBlock: return "Bc5SnormBlock"; - case Format::eBc6HUfloatBlock: return "Bc6HUfloatBlock"; - case Format::eBc6HSfloatBlock: return "Bc6HSfloatBlock"; - case Format::eBc7UnormBlock: return "Bc7UnormBlock"; - case Format::eBc7SrgbBlock: return "Bc7SrgbBlock"; - case Format::eEtc2R8G8B8UnormBlock: return "Etc2R8G8B8UnormBlock"; - case Format::eEtc2R8G8B8SrgbBlock: return "Etc2R8G8B8SrgbBlock"; - case Format::eEtc2R8G8B8A1UnormBlock: return "Etc2R8G8B8A1UnormBlock"; - case Format::eEtc2R8G8B8A1SrgbBlock: return "Etc2R8G8B8A1SrgbBlock"; - case Format::eEtc2R8G8B8A8UnormBlock: return "Etc2R8G8B8A8UnormBlock"; - case Format::eEtc2R8G8B8A8SrgbBlock: return "Etc2R8G8B8A8SrgbBlock"; - case Format::eEacR11UnormBlock: return "EacR11UnormBlock"; - case Format::eEacR11SnormBlock: return "EacR11SnormBlock"; - case Format::eEacR11G11UnormBlock: return "EacR11G11UnormBlock"; - case Format::eEacR11G11SnormBlock: return "EacR11G11SnormBlock"; - case Format::eAstc4x4UnormBlock: return "Astc4x4UnormBlock"; - case Format::eAstc4x4SrgbBlock: return "Astc4x4SrgbBlock"; - case Format::eAstc5x4UnormBlock: return "Astc5x4UnormBlock"; - case Format::eAstc5x4SrgbBlock: return "Astc5x4SrgbBlock"; - case Format::eAstc5x5UnormBlock: return "Astc5x5UnormBlock"; - case Format::eAstc5x5SrgbBlock: return "Astc5x5SrgbBlock"; - case Format::eAstc6x5UnormBlock: return "Astc6x5UnormBlock"; - case Format::eAstc6x5SrgbBlock: return "Astc6x5SrgbBlock"; - case Format::eAstc6x6UnormBlock: return "Astc6x6UnormBlock"; - case Format::eAstc6x6SrgbBlock: return "Astc6x6SrgbBlock"; - case Format::eAstc8x5UnormBlock: return "Astc8x5UnormBlock"; - case Format::eAstc8x5SrgbBlock: return "Astc8x5SrgbBlock"; - case Format::eAstc8x6UnormBlock: return "Astc8x6UnormBlock"; - case Format::eAstc8x6SrgbBlock: return "Astc8x6SrgbBlock"; - case Format::eAstc8x8UnormBlock: return "Astc8x8UnormBlock"; - case Format::eAstc8x8SrgbBlock: return "Astc8x8SrgbBlock"; - case Format::eAstc10x5UnormBlock: return "Astc10x5UnormBlock"; - case Format::eAstc10x5SrgbBlock: return "Astc10x5SrgbBlock"; - case Format::eAstc10x6UnormBlock: return "Astc10x6UnormBlock"; - case Format::eAstc10x6SrgbBlock: return "Astc10x6SrgbBlock"; - case Format::eAstc10x8UnormBlock: return "Astc10x8UnormBlock"; - case Format::eAstc10x8SrgbBlock: return "Astc10x8SrgbBlock"; - case Format::eAstc10x10UnormBlock: return "Astc10x10UnormBlock"; - case Format::eAstc10x10SrgbBlock: return "Astc10x10SrgbBlock"; - case Format::eAstc12x10UnormBlock: return "Astc12x10UnormBlock"; - case Format::eAstc12x10SrgbBlock: return "Astc12x10SrgbBlock"; - case Format::eAstc12x12UnormBlock: return "Astc12x12UnormBlock"; - case Format::eAstc12x12SrgbBlock: return "Astc12x12SrgbBlock"; - case Format::eG8B8G8R8422Unorm: return "G8B8G8R8422Unorm"; - case Format::eB8G8R8G8422Unorm: return "B8G8R8G8422Unorm"; - case Format::eG8B8R83Plane420Unorm: return "G8B8R83Plane420Unorm"; - case Format::eG8B8R82Plane420Unorm: return "G8B8R82Plane420Unorm"; - case Format::eG8B8R83Plane422Unorm: return "G8B8R83Plane422Unorm"; - case Format::eG8B8R82Plane422Unorm: return "G8B8R82Plane422Unorm"; - case Format::eG8B8R83Plane444Unorm: return "G8B8R83Plane444Unorm"; - case Format::eR10X6UnormPack16: return "R10X6UnormPack16"; - case Format::eR10X6G10X6Unorm2Pack16: return "R10X6G10X6Unorm2Pack16"; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: return "R10X6G10X6B10X6A10X6Unorm4Pack16"; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: return "G10X6B10X6G10X6R10X6422Unorm4Pack16"; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: return "B10X6G10X6R10X6G10X6422Unorm4Pack16"; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: return "G10X6B10X6R10X63Plane420Unorm3Pack16"; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: return "G10X6B10X6R10X62Plane420Unorm3Pack16"; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: return "G10X6B10X6R10X63Plane422Unorm3Pack16"; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: return "G10X6B10X6R10X62Plane422Unorm3Pack16"; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: return "G10X6B10X6R10X63Plane444Unorm3Pack16"; - case Format::eR12X4UnormPack16: return "R12X4UnormPack16"; - case Format::eR12X4G12X4Unorm2Pack16: return "R12X4G12X4Unorm2Pack16"; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: return "R12X4G12X4B12X4A12X4Unorm4Pack16"; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: return "G12X4B12X4G12X4R12X4422Unorm4Pack16"; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: return "B12X4G12X4R12X4G12X4422Unorm4Pack16"; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: return "G12X4B12X4R12X43Plane420Unorm3Pack16"; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: return "G12X4B12X4R12X42Plane420Unorm3Pack16"; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: return "G12X4B12X4R12X43Plane422Unorm3Pack16"; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: return "G12X4B12X4R12X42Plane422Unorm3Pack16"; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: return "G12X4B12X4R12X43Plane444Unorm3Pack16"; - case Format::eG16B16G16R16422Unorm: return "G16B16G16R16422Unorm"; - case Format::eB16G16R16G16422Unorm: return "B16G16R16G16422Unorm"; - case Format::eG16B16R163Plane420Unorm: return "G16B16R163Plane420Unorm"; - case Format::eG16B16R162Plane420Unorm: return "G16B16R162Plane420Unorm"; - case Format::eG16B16R163Plane422Unorm: return "G16B16R163Plane422Unorm"; - case Format::eG16B16R162Plane422Unorm: return "G16B16R162Plane422Unorm"; - case Format::eG16B16R163Plane444Unorm: return "G16B16R163Plane444Unorm"; - case Format::ePvrtc12BppUnormBlockIMG: return "Pvrtc12BppUnormBlockIMG"; - case Format::ePvrtc14BppUnormBlockIMG: return "Pvrtc14BppUnormBlockIMG"; - case Format::ePvrtc22BppUnormBlockIMG: return "Pvrtc22BppUnormBlockIMG"; - case Format::ePvrtc24BppUnormBlockIMG: return "Pvrtc24BppUnormBlockIMG"; - case Format::ePvrtc12BppSrgbBlockIMG: return "Pvrtc12BppSrgbBlockIMG"; - case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG"; - case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG"; - case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(StructureType value) - { - switch (value) - { - case StructureType::eApplicationInfo: return "ApplicationInfo"; - case StructureType::eInstanceCreateInfo: return "InstanceCreateInfo"; - case StructureType::eDeviceQueueCreateInfo: return "DeviceQueueCreateInfo"; - case StructureType::eDeviceCreateInfo: return "DeviceCreateInfo"; - case StructureType::eSubmitInfo: return "SubmitInfo"; - case StructureType::eMemoryAllocateInfo: return "MemoryAllocateInfo"; - case StructureType::eMappedMemoryRange: return "MappedMemoryRange"; - case StructureType::eBindSparseInfo: return "BindSparseInfo"; - case StructureType::eFenceCreateInfo: return "FenceCreateInfo"; - case StructureType::eSemaphoreCreateInfo: return "SemaphoreCreateInfo"; - case StructureType::eEventCreateInfo: return "EventCreateInfo"; - case StructureType::eQueryPoolCreateInfo: return "QueryPoolCreateInfo"; - case StructureType::eBufferCreateInfo: return "BufferCreateInfo"; - case StructureType::eBufferViewCreateInfo: return "BufferViewCreateInfo"; - case StructureType::eImageCreateInfo: return "ImageCreateInfo"; - case StructureType::eImageViewCreateInfo: return "ImageViewCreateInfo"; - case StructureType::eShaderModuleCreateInfo: return "ShaderModuleCreateInfo"; - case StructureType::ePipelineCacheCreateInfo: return "PipelineCacheCreateInfo"; - case StructureType::ePipelineShaderStageCreateInfo: return "PipelineShaderStageCreateInfo"; - case StructureType::ePipelineVertexInputStateCreateInfo: return "PipelineVertexInputStateCreateInfo"; - case StructureType::ePipelineInputAssemblyStateCreateInfo: return "PipelineInputAssemblyStateCreateInfo"; - case StructureType::ePipelineTessellationStateCreateInfo: return "PipelineTessellationStateCreateInfo"; - case StructureType::ePipelineViewportStateCreateInfo: return "PipelineViewportStateCreateInfo"; - case StructureType::ePipelineRasterizationStateCreateInfo: return "PipelineRasterizationStateCreateInfo"; - case StructureType::ePipelineMultisampleStateCreateInfo: return "PipelineMultisampleStateCreateInfo"; - case StructureType::ePipelineDepthStencilStateCreateInfo: return "PipelineDepthStencilStateCreateInfo"; - case StructureType::ePipelineColorBlendStateCreateInfo: return "PipelineColorBlendStateCreateInfo"; - case StructureType::ePipelineDynamicStateCreateInfo: return "PipelineDynamicStateCreateInfo"; - case StructureType::eGraphicsPipelineCreateInfo: return "GraphicsPipelineCreateInfo"; - case StructureType::eComputePipelineCreateInfo: return "ComputePipelineCreateInfo"; - case StructureType::ePipelineLayoutCreateInfo: return "PipelineLayoutCreateInfo"; - case StructureType::eSamplerCreateInfo: return "SamplerCreateInfo"; - case StructureType::eDescriptorSetLayoutCreateInfo: return "DescriptorSetLayoutCreateInfo"; - case StructureType::eDescriptorPoolCreateInfo: return "DescriptorPoolCreateInfo"; - case StructureType::eDescriptorSetAllocateInfo: return "DescriptorSetAllocateInfo"; - case StructureType::eWriteDescriptorSet: return "WriteDescriptorSet"; - case StructureType::eCopyDescriptorSet: return "CopyDescriptorSet"; - case StructureType::eFramebufferCreateInfo: return "FramebufferCreateInfo"; - case StructureType::eRenderPassCreateInfo: return "RenderPassCreateInfo"; - case StructureType::eCommandPoolCreateInfo: return "CommandPoolCreateInfo"; - case StructureType::eCommandBufferAllocateInfo: return "CommandBufferAllocateInfo"; - case StructureType::eCommandBufferInheritanceInfo: return "CommandBufferInheritanceInfo"; - case StructureType::eCommandBufferBeginInfo: return "CommandBufferBeginInfo"; - case StructureType::eRenderPassBeginInfo: return "RenderPassBeginInfo"; - case StructureType::eBufferMemoryBarrier: return "BufferMemoryBarrier"; - case StructureType::eImageMemoryBarrier: return "ImageMemoryBarrier"; - case StructureType::eMemoryBarrier: return "MemoryBarrier"; - case StructureType::eLoaderInstanceCreateInfo: return "LoaderInstanceCreateInfo"; - case StructureType::eLoaderDeviceCreateInfo: return "LoaderDeviceCreateInfo"; - case StructureType::ePhysicalDeviceSubgroupProperties: return "PhysicalDeviceSubgroupProperties"; - case StructureType::eBindBufferMemoryInfo: return "BindBufferMemoryInfo"; - case StructureType::eBindImageMemoryInfo: return "BindImageMemoryInfo"; - case StructureType::ePhysicalDevice16BitStorageFeatures: return "PhysicalDevice16BitStorageFeatures"; - case StructureType::eMemoryDedicatedRequirements: return "MemoryDedicatedRequirements"; - case StructureType::eMemoryDedicatedAllocateInfo: return "MemoryDedicatedAllocateInfo"; - case StructureType::eMemoryAllocateFlagsInfo: return "MemoryAllocateFlagsInfo"; - case StructureType::eDeviceGroupRenderPassBeginInfo: return "DeviceGroupRenderPassBeginInfo"; - case StructureType::eDeviceGroupCommandBufferBeginInfo: return "DeviceGroupCommandBufferBeginInfo"; - case StructureType::eDeviceGroupSubmitInfo: return "DeviceGroupSubmitInfo"; - case StructureType::eDeviceGroupBindSparseInfo: return "DeviceGroupBindSparseInfo"; - case StructureType::eBindBufferMemoryDeviceGroupInfo: return "BindBufferMemoryDeviceGroupInfo"; - case StructureType::eBindImageMemoryDeviceGroupInfo: return "BindImageMemoryDeviceGroupInfo"; - case StructureType::ePhysicalDeviceGroupProperties: return "PhysicalDeviceGroupProperties"; - case StructureType::eDeviceGroupDeviceCreateInfo: return "DeviceGroupDeviceCreateInfo"; - case StructureType::eBufferMemoryRequirementsInfo2: return "BufferMemoryRequirementsInfo2"; - case StructureType::eImageMemoryRequirementsInfo2: return "ImageMemoryRequirementsInfo2"; - case StructureType::eImageSparseMemoryRequirementsInfo2: return "ImageSparseMemoryRequirementsInfo2"; - case StructureType::eMemoryRequirements2: return "MemoryRequirements2"; - case StructureType::eSparseImageMemoryRequirements2: return "SparseImageMemoryRequirements2"; - case StructureType::ePhysicalDeviceFeatures2: return "PhysicalDeviceFeatures2"; - case StructureType::ePhysicalDeviceProperties2: return "PhysicalDeviceProperties2"; - case StructureType::eFormatProperties2: return "FormatProperties2"; - case StructureType::eImageFormatProperties2: return "ImageFormatProperties2"; - case StructureType::ePhysicalDeviceImageFormatInfo2: return "PhysicalDeviceImageFormatInfo2"; - case StructureType::eQueueFamilyProperties2: return "QueueFamilyProperties2"; - case StructureType::ePhysicalDeviceMemoryProperties2: return "PhysicalDeviceMemoryProperties2"; - case StructureType::eSparseImageFormatProperties2: return "SparseImageFormatProperties2"; - case StructureType::ePhysicalDeviceSparseImageFormatInfo2: return "PhysicalDeviceSparseImageFormatInfo2"; - case StructureType::ePhysicalDevicePointClippingProperties: return "PhysicalDevicePointClippingProperties"; - case StructureType::eRenderPassInputAttachmentAspectCreateInfo: return "RenderPassInputAttachmentAspectCreateInfo"; - case StructureType::eImageViewUsageCreateInfo: return "ImageViewUsageCreateInfo"; - case StructureType::ePipelineTessellationDomainOriginStateCreateInfo: return "PipelineTessellationDomainOriginStateCreateInfo"; - case StructureType::eRenderPassMultiviewCreateInfo: return "RenderPassMultiviewCreateInfo"; - case StructureType::ePhysicalDeviceMultiviewFeatures: return "PhysicalDeviceMultiviewFeatures"; - case StructureType::ePhysicalDeviceMultiviewProperties: return "PhysicalDeviceMultiviewProperties"; - case StructureType::ePhysicalDeviceVariablePointerFeatures: return "PhysicalDeviceVariablePointerFeatures"; - case StructureType::eProtectedSubmitInfo: return "ProtectedSubmitInfo"; - case StructureType::ePhysicalDeviceProtectedMemoryFeatures: return "PhysicalDeviceProtectedMemoryFeatures"; - case StructureType::ePhysicalDeviceProtectedMemoryProperties: return "PhysicalDeviceProtectedMemoryProperties"; - case StructureType::eDeviceQueueInfo2: return "DeviceQueueInfo2"; - case StructureType::eSamplerYcbcrConversionCreateInfo: return "SamplerYcbcrConversionCreateInfo"; - case StructureType::eSamplerYcbcrConversionInfo: return "SamplerYcbcrConversionInfo"; - case StructureType::eBindImagePlaneMemoryInfo: return "BindImagePlaneMemoryInfo"; - case StructureType::eImagePlaneMemoryRequirementsInfo: return "ImagePlaneMemoryRequirementsInfo"; - case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures: return "PhysicalDeviceSamplerYcbcrConversionFeatures"; - case StructureType::eSamplerYcbcrConversionImageFormatProperties: return "SamplerYcbcrConversionImageFormatProperties"; - case StructureType::eDescriptorUpdateTemplateCreateInfo: return "DescriptorUpdateTemplateCreateInfo"; - case StructureType::ePhysicalDeviceExternalImageFormatInfo: return "PhysicalDeviceExternalImageFormatInfo"; - case StructureType::eExternalImageFormatProperties: return "ExternalImageFormatProperties"; - case StructureType::ePhysicalDeviceExternalBufferInfo: return "PhysicalDeviceExternalBufferInfo"; - case StructureType::eExternalBufferProperties: return "ExternalBufferProperties"; - case StructureType::ePhysicalDeviceIdProperties: return "PhysicalDeviceIdProperties"; - case StructureType::eExternalMemoryBufferCreateInfo: return "ExternalMemoryBufferCreateInfo"; - case StructureType::eExternalMemoryImageCreateInfo: return "ExternalMemoryImageCreateInfo"; - case StructureType::eExportMemoryAllocateInfo: return "ExportMemoryAllocateInfo"; - case StructureType::ePhysicalDeviceExternalFenceInfo: return "PhysicalDeviceExternalFenceInfo"; - case StructureType::eExternalFenceProperties: return "ExternalFenceProperties"; - case StructureType::eExportFenceCreateInfo: return "ExportFenceCreateInfo"; - case StructureType::eExportSemaphoreCreateInfo: return "ExportSemaphoreCreateInfo"; - case StructureType::ePhysicalDeviceExternalSemaphoreInfo: return "PhysicalDeviceExternalSemaphoreInfo"; - case StructureType::eExternalSemaphoreProperties: return "ExternalSemaphoreProperties"; - case StructureType::ePhysicalDeviceMaintenance3Properties: return "PhysicalDeviceMaintenance3Properties"; - case StructureType::eDescriptorSetLayoutSupport: return "DescriptorSetLayoutSupport"; - case StructureType::ePhysicalDeviceShaderDrawParameterFeatures: return "PhysicalDeviceShaderDrawParameterFeatures"; - case StructureType::eSwapchainCreateInfoKHR: return "SwapchainCreateInfoKHR"; - case StructureType::ePresentInfoKHR: return "PresentInfoKHR"; - case StructureType::eDeviceGroupPresentCapabilitiesKHR: return "DeviceGroupPresentCapabilitiesKHR"; - case StructureType::eImageSwapchainCreateInfoKHR: return "ImageSwapchainCreateInfoKHR"; - case StructureType::eBindImageMemorySwapchainInfoKHR: return "BindImageMemorySwapchainInfoKHR"; - case StructureType::eAcquireNextImageInfoKHR: return "AcquireNextImageInfoKHR"; - case StructureType::eDeviceGroupPresentInfoKHR: return "DeviceGroupPresentInfoKHR"; - case StructureType::eDeviceGroupSwapchainCreateInfoKHR: return "DeviceGroupSwapchainCreateInfoKHR"; - case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR"; - case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR"; - case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR"; - case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR"; - case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR"; - case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR"; - case StructureType::eMirSurfaceCreateInfoKHR: return "MirSurfaceCreateInfoKHR"; - case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR"; - case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR"; - case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT"; - case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD"; - case StructureType::eDebugMarkerObjectNameInfoEXT: return "DebugMarkerObjectNameInfoEXT"; - case StructureType::eDebugMarkerObjectTagInfoEXT: return "DebugMarkerObjectTagInfoEXT"; - case StructureType::eDebugMarkerMarkerInfoEXT: return "DebugMarkerMarkerInfoEXT"; - case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV"; - case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV"; - case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV"; - case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD"; - case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV"; - case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV"; - case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV"; - case StructureType::eExportMemoryWin32HandleInfoNV: return "ExportMemoryWin32HandleInfoNV"; - case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV"; - case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT"; - case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN"; - case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR"; - case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR"; - case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR"; - case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR"; - case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR"; - case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR"; - case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR"; - case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR"; - case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR"; - case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR"; - case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR"; - case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR"; - case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR"; - case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR"; - case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR"; - case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR"; - case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX"; - case StructureType::eIndirectCommandsLayoutCreateInfoNVX: return "IndirectCommandsLayoutCreateInfoNVX"; - case StructureType::eCmdProcessCommandsInfoNVX: return "CmdProcessCommandsInfoNVX"; - case StructureType::eCmdReserveSpaceForCommandsInfoNVX: return "CmdReserveSpaceForCommandsInfoNVX"; - case StructureType::eDeviceGeneratedCommandsLimitsNVX: return "DeviceGeneratedCommandsLimitsNVX"; - case StructureType::eDeviceGeneratedCommandsFeaturesNVX: return "DeviceGeneratedCommandsFeaturesNVX"; - case StructureType::ePipelineViewportWScalingStateCreateInfoNV: return "PipelineViewportWScalingStateCreateInfoNV"; - case StructureType::eSurfaceCapabilities2EXT: return "SurfaceCapabilities2EXT"; - case StructureType::eDisplayPowerInfoEXT: return "DisplayPowerInfoEXT"; - case StructureType::eDeviceEventInfoEXT: return "DeviceEventInfoEXT"; - case StructureType::eDisplayEventInfoEXT: return "DisplayEventInfoEXT"; - case StructureType::eSwapchainCounterCreateInfoEXT: return "SwapchainCounterCreateInfoEXT"; - case StructureType::ePresentTimesInfoGOOGLE: return "PresentTimesInfoGOOGLE"; - case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"; - case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV"; - case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT"; - case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT: return "PhysicalDeviceConservativeRasterizationPropertiesEXT"; - case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT: return "PipelineRasterizationConservativeStateCreateInfoEXT"; - case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT"; - case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR"; - case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR"; - case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR"; - case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR"; - case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR"; - case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR"; - case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR"; - case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR"; - case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR"; - case StructureType::eDisplayProperties2KHR: return "DisplayProperties2KHR"; - case StructureType::eDisplayPlaneProperties2KHR: return "DisplayPlaneProperties2KHR"; - case StructureType::eDisplayModeProperties2KHR: return "DisplayModeProperties2KHR"; - case StructureType::eDisplayPlaneInfo2KHR: return "DisplayPlaneInfo2KHR"; - case StructureType::eDisplayPlaneCapabilities2KHR: return "DisplayPlaneCapabilities2KHR"; - case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK"; - case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK"; - case StructureType::eDebugUtilsObjectNameInfoEXT: return "DebugUtilsObjectNameInfoEXT"; - case StructureType::eDebugUtilsObjectTagInfoEXT: return "DebugUtilsObjectTagInfoEXT"; - case StructureType::eDebugUtilsLabelEXT: return "DebugUtilsLabelEXT"; - case StructureType::eDebugUtilsMessengerCallbackDataEXT: return "DebugUtilsMessengerCallbackDataEXT"; - case StructureType::eDebugUtilsMessengerCreateInfoEXT: return "DebugUtilsMessengerCreateInfoEXT"; - case StructureType::eAndroidHardwareBufferUsageANDROID: return "AndroidHardwareBufferUsageANDROID"; - case StructureType::eAndroidHardwareBufferPropertiesANDROID: return "AndroidHardwareBufferPropertiesANDROID"; - case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID: return "AndroidHardwareBufferFormatPropertiesANDROID"; - case StructureType::eImportAndroidHardwareBufferInfoANDROID: return "ImportAndroidHardwareBufferInfoANDROID"; - case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID: return "MemoryGetAndroidHardwareBufferInfoANDROID"; - case StructureType::eExternalFormatANDROID: return "ExternalFormatANDROID"; - case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT"; - case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT"; - case StructureType::eSampleLocationsInfoEXT: return "SampleLocationsInfoEXT"; - case StructureType::eRenderPassSampleLocationsBeginInfoEXT: return "RenderPassSampleLocationsBeginInfoEXT"; - case StructureType::ePipelineSampleLocationsStateCreateInfoEXT: return "PipelineSampleLocationsStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT: return "PhysicalDeviceSampleLocationsPropertiesEXT"; - case StructureType::eMultisamplePropertiesEXT: return "MultisamplePropertiesEXT"; - case StructureType::eImageFormatListCreateInfoKHR: return "ImageFormatListCreateInfoKHR"; - case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT"; - case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT"; - case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT"; - case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV"; - case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV"; - case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT"; - case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT"; - case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT: return "DescriptorSetLayoutBindingFlagsCreateInfoEXT"; - case StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT: return "PhysicalDeviceDescriptorIndexingFeaturesEXT"; - case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT: return "PhysicalDeviceDescriptorIndexingPropertiesEXT"; - case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT: return "DescriptorSetVariableDescriptorCountAllocateInfoEXT"; - case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT: return "DescriptorSetVariableDescriptorCountLayoutSupportEXT"; - case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT"; - case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT"; - case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT"; - case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; - case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD"; - case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; - case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubpassContents value) - { - switch (value) - { - case SubpassContents::eInline: return "Inline"; - case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DynamicState value) - { - switch (value) - { - case DynamicState::eViewport: return "Viewport"; - case DynamicState::eScissor: return "Scissor"; - case DynamicState::eLineWidth: return "LineWidth"; - case DynamicState::eDepthBias: return "DepthBias"; - case DynamicState::eBlendConstants: return "BlendConstants"; - case DynamicState::eDepthBounds: return "DepthBounds"; - case DynamicState::eStencilCompareMask: return "StencilCompareMask"; - case DynamicState::eStencilWriteMask: return "StencilWriteMask"; - case DynamicState::eStencilReference: return "StencilReference"; - case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV"; - case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT"; - case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateType value) - { - switch (value) - { - case DescriptorUpdateTemplateType::eDescriptorSet: return "DescriptorSet"; - case DescriptorUpdateTemplateType::ePushDescriptorsKHR: return "PushDescriptorsKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ObjectType value) - { - switch (value) - { - case ObjectType::eUnknown: return "Unknown"; - case ObjectType::eInstance: return "Instance"; - case ObjectType::ePhysicalDevice: return "PhysicalDevice"; - case ObjectType::eDevice: return "Device"; - case ObjectType::eQueue: return "Queue"; - case ObjectType::eSemaphore: return "Semaphore"; - case ObjectType::eCommandBuffer: return "CommandBuffer"; - case ObjectType::eFence: return "Fence"; - case ObjectType::eDeviceMemory: return "DeviceMemory"; - case ObjectType::eBuffer: return "Buffer"; - case ObjectType::eImage: return "Image"; - case ObjectType::eEvent: return "Event"; - case ObjectType::eQueryPool: return "QueryPool"; - case ObjectType::eBufferView: return "BufferView"; - case ObjectType::eImageView: return "ImageView"; - case ObjectType::eShaderModule: return "ShaderModule"; - case ObjectType::ePipelineCache: return "PipelineCache"; - case ObjectType::ePipelineLayout: return "PipelineLayout"; - case ObjectType::eRenderPass: return "RenderPass"; - case ObjectType::ePipeline: return "Pipeline"; - case ObjectType::eDescriptorSetLayout: return "DescriptorSetLayout"; - case ObjectType::eSampler: return "Sampler"; - case ObjectType::eDescriptorPool: return "DescriptorPool"; - case ObjectType::eDescriptorSet: return "DescriptorSet"; - case ObjectType::eFramebuffer: return "Framebuffer"; - case ObjectType::eCommandPool: return "CommandPool"; - case ObjectType::eSamplerYcbcrConversion: return "SamplerYcbcrConversion"; - case ObjectType::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate"; - case ObjectType::eSurfaceKHR: return "SurfaceKHR"; - case ObjectType::eSwapchainKHR: return "SwapchainKHR"; - case ObjectType::eDisplayKHR: return "DisplayKHR"; - case ObjectType::eDisplayModeKHR: return "DisplayModeKHR"; - case ObjectType::eDebugReportCallbackEXT: return "DebugReportCallbackEXT"; - case ObjectType::eObjectTableNVX: return "ObjectTableNVX"; - case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX"; - case ObjectType::eDebugUtilsMessengerEXT: return "DebugUtilsMessengerEXT"; - case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value) - { - switch (value) - { - case QueueFlagBits::eGraphics: return "Graphics"; - case QueueFlagBits::eCompute: return "Compute"; - case QueueFlagBits::eTransfer: return "Transfer"; - case QueueFlagBits::eSparseBinding: return "SparseBinding"; - case QueueFlagBits::eProtected: return "Protected"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueueFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueueFlagBits::eGraphics) result += "Graphics | "; - if (value & QueueFlagBits::eCompute) result += "Compute | "; - if (value & QueueFlagBits::eTransfer) result += "Transfer | "; - if (value & QueueFlagBits::eSparseBinding) result += "SparseBinding | "; - if (value & QueueFlagBits::eProtected) result += "Protected | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlagBits value) - { - switch (value) - { - case DeviceQueueCreateFlagBits::eProtected: return "Protected"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & DeviceQueueCreateFlagBits::eProtected) result += "Protected | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlagBits value) - { - switch (value) - { - case MemoryPropertyFlagBits::eDeviceLocal: return "DeviceLocal"; - case MemoryPropertyFlagBits::eHostVisible: return "HostVisible"; - case MemoryPropertyFlagBits::eHostCoherent: return "HostCoherent"; - case MemoryPropertyFlagBits::eHostCached: return "HostCached"; - case MemoryPropertyFlagBits::eLazilyAllocated: return "LazilyAllocated"; - case MemoryPropertyFlagBits::eProtected: return "Protected"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & MemoryPropertyFlagBits::eDeviceLocal) result += "DeviceLocal | "; - if (value & MemoryPropertyFlagBits::eHostVisible) result += "HostVisible | "; - if (value & MemoryPropertyFlagBits::eHostCoherent) result += "HostCoherent | "; - if (value & MemoryPropertyFlagBits::eHostCached) result += "HostCached | "; - if (value & MemoryPropertyFlagBits::eLazilyAllocated) result += "LazilyAllocated | "; - if (value & MemoryPropertyFlagBits::eProtected) result += "Protected | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlagBits value) - { - switch (value) - { - case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal"; - case MemoryHeapFlagBits::eMultiInstance: return "MultiInstance"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | "; - if (value & MemoryHeapFlagBits::eMultiInstance) result += "MultiInstance | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(AccessFlagBits value) - { - switch (value) - { - case AccessFlagBits::eIndirectCommandRead: return "IndirectCommandRead"; - case AccessFlagBits::eIndexRead: return "IndexRead"; - case AccessFlagBits::eVertexAttributeRead: return "VertexAttributeRead"; - case AccessFlagBits::eUniformRead: return "UniformRead"; - case AccessFlagBits::eInputAttachmentRead: return "InputAttachmentRead"; - case AccessFlagBits::eShaderRead: return "ShaderRead"; - case AccessFlagBits::eShaderWrite: return "ShaderWrite"; - case AccessFlagBits::eColorAttachmentRead: return "ColorAttachmentRead"; - case AccessFlagBits::eColorAttachmentWrite: return "ColorAttachmentWrite"; - case AccessFlagBits::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead"; - case AccessFlagBits::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite"; - case AccessFlagBits::eTransferRead: return "TransferRead"; - case AccessFlagBits::eTransferWrite: return "TransferWrite"; - case AccessFlagBits::eHostRead: return "HostRead"; - case AccessFlagBits::eHostWrite: return "HostWrite"; - case AccessFlagBits::eMemoryRead: return "MemoryRead"; - case AccessFlagBits::eMemoryWrite: return "MemoryWrite"; - case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX"; - case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX"; - case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AccessFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & AccessFlagBits::eIndirectCommandRead) result += "IndirectCommandRead | "; - if (value & AccessFlagBits::eIndexRead) result += "IndexRead | "; - if (value & AccessFlagBits::eVertexAttributeRead) result += "VertexAttributeRead | "; - if (value & AccessFlagBits::eUniformRead) result += "UniformRead | "; - if (value & AccessFlagBits::eInputAttachmentRead) result += "InputAttachmentRead | "; - if (value & AccessFlagBits::eShaderRead) result += "ShaderRead | "; - if (value & AccessFlagBits::eShaderWrite) result += "ShaderWrite | "; - if (value & AccessFlagBits::eColorAttachmentRead) result += "ColorAttachmentRead | "; - if (value & AccessFlagBits::eColorAttachmentWrite) result += "ColorAttachmentWrite | "; - if (value & AccessFlagBits::eDepthStencilAttachmentRead) result += "DepthStencilAttachmentRead | "; - if (value & AccessFlagBits::eDepthStencilAttachmentWrite) result += "DepthStencilAttachmentWrite | "; - if (value & AccessFlagBits::eTransferRead) result += "TransferRead | "; - if (value & AccessFlagBits::eTransferWrite) result += "TransferWrite | "; - if (value & AccessFlagBits::eHostRead) result += "HostRead | "; - if (value & AccessFlagBits::eHostWrite) result += "HostWrite | "; - if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | "; - if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | "; - if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | "; - if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | "; - if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferUsageFlagBits value) - { - switch (value) - { - case BufferUsageFlagBits::eTransferSrc: return "TransferSrc"; - case BufferUsageFlagBits::eTransferDst: return "TransferDst"; - case BufferUsageFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer"; - case BufferUsageFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer"; - case BufferUsageFlagBits::eUniformBuffer: return "UniformBuffer"; - case BufferUsageFlagBits::eStorageBuffer: return "StorageBuffer"; - case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer"; - case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer"; - case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BufferUsageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & BufferUsageFlagBits::eTransferSrc) result += "TransferSrc | "; - if (value & BufferUsageFlagBits::eTransferDst) result += "TransferDst | "; - if (value & BufferUsageFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | "; - if (value & BufferUsageFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | "; - if (value & BufferUsageFlagBits::eUniformBuffer) result += "UniformBuffer | "; - if (value & BufferUsageFlagBits::eStorageBuffer) result += "StorageBuffer | "; - if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | "; - if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | "; - if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferCreateFlagBits value) - { - switch (value) - { - case BufferCreateFlagBits::eSparseBinding: return "SparseBinding"; - case BufferCreateFlagBits::eSparseResidency: return "SparseResidency"; - case BufferCreateFlagBits::eSparseAliased: return "SparseAliased"; - case BufferCreateFlagBits::eProtected: return "Protected"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BufferCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & BufferCreateFlagBits::eSparseBinding) result += "SparseBinding | "; - if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | "; - if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | "; - if (value & BufferCreateFlagBits::eProtected) result += "Protected | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ShaderStageFlagBits value) - { - switch (value) - { - case ShaderStageFlagBits::eVertex: return "Vertex"; - case ShaderStageFlagBits::eTessellationControl: return "TessellationControl"; - case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation"; - case ShaderStageFlagBits::eGeometry: return "Geometry"; - case ShaderStageFlagBits::eFragment: return "Fragment"; - case ShaderStageFlagBits::eCompute: return "Compute"; - case ShaderStageFlagBits::eAllGraphics: return "AllGraphics"; - case ShaderStageFlagBits::eAll: return "All"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ShaderStageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ShaderStageFlagBits::eVertex) result += "Vertex | "; - if (value & ShaderStageFlagBits::eTessellationControl) result += "TessellationControl | "; - if (value & ShaderStageFlagBits::eTessellationEvaluation) result += "TessellationEvaluation | "; - if (value & ShaderStageFlagBits::eGeometry) result += "Geometry | "; - if (value & ShaderStageFlagBits::eFragment) result += "Fragment | "; - if (value & ShaderStageFlagBits::eCompute) result += "Compute | "; - if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | "; - if (value & ShaderStageFlagBits::eAll) result += "All | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageUsageFlagBits value) - { - switch (value) - { - case ImageUsageFlagBits::eTransferSrc: return "TransferSrc"; - case ImageUsageFlagBits::eTransferDst: return "TransferDst"; - case ImageUsageFlagBits::eSampled: return "Sampled"; - case ImageUsageFlagBits::eStorage: return "Storage"; - case ImageUsageFlagBits::eColorAttachment: return "ColorAttachment"; - case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment"; - case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment"; - case ImageUsageFlagBits::eInputAttachment: return "InputAttachment"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageUsageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ImageUsageFlagBits::eTransferSrc) result += "TransferSrc | "; - if (value & ImageUsageFlagBits::eTransferDst) result += "TransferDst | "; - if (value & ImageUsageFlagBits::eSampled) result += "Sampled | "; - if (value & ImageUsageFlagBits::eStorage) result += "Storage | "; - if (value & ImageUsageFlagBits::eColorAttachment) result += "ColorAttachment | "; - if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | "; - if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | "; - if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageCreateFlagBits value) - { - switch (value) - { - case ImageCreateFlagBits::eSparseBinding: return "SparseBinding"; - case ImageCreateFlagBits::eSparseResidency: return "SparseResidency"; - case ImageCreateFlagBits::eSparseAliased: return "SparseAliased"; - case ImageCreateFlagBits::eMutableFormat: return "MutableFormat"; - case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible"; - case ImageCreateFlagBits::eAlias: return "Alias"; - case ImageCreateFlagBits::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; - case ImageCreateFlagBits::e2DArrayCompatible: return "2DArrayCompatible"; - case ImageCreateFlagBits::eBlockTexelViewCompatible: return "BlockTexelViewCompatible"; - case ImageCreateFlagBits::eExtendedUsage: return "ExtendedUsage"; - case ImageCreateFlagBits::eProtected: return "Protected"; - case ImageCreateFlagBits::eDisjoint: return "Disjoint"; - case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ImageCreateFlagBits::eSparseBinding) result += "SparseBinding | "; - if (value & ImageCreateFlagBits::eSparseResidency) result += "SparseResidency | "; - if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | "; - if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | "; - if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | "; - if (value & ImageCreateFlagBits::eAlias) result += "Alias | "; - if (value & ImageCreateFlagBits::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | "; - if (value & ImageCreateFlagBits::e2DArrayCompatible) result += "2DArrayCompatible | "; - if (value & ImageCreateFlagBits::eBlockTexelViewCompatible) result += "BlockTexelViewCompatible | "; - if (value & ImageCreateFlagBits::eExtendedUsage) result += "ExtendedUsage | "; - if (value & ImageCreateFlagBits::eProtected) result += "Protected | "; - if (value & ImageCreateFlagBits::eDisjoint) result += "Disjoint | "; - if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlagBits value) - { - switch (value) - { - case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization"; - case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives"; - case PipelineCreateFlagBits::eDerivative: return "Derivative"; - case PipelineCreateFlagBits::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex"; - case PipelineCreateFlagBits::eDispatchBase: return "DispatchBase"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | "; - if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | "; - if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | "; - if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex) result += "ViewIndexFromDeviceIndex | "; - if (value & PipelineCreateFlagBits::eDispatchBase) result += "DispatchBase | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ColorComponentFlagBits value) - { - switch (value) - { - case ColorComponentFlagBits::eR: return "R"; - case ColorComponentFlagBits::eG: return "G"; - case ColorComponentFlagBits::eB: return "B"; - case ColorComponentFlagBits::eA: return "A"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ColorComponentFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ColorComponentFlagBits::eR) result += "R | "; - if (value & ColorComponentFlagBits::eG) result += "G | "; - if (value & ColorComponentFlagBits::eB) result += "B | "; - if (value & ColorComponentFlagBits::eA) result += "A | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FenceCreateFlagBits value) - { - switch (value) - { - case FenceCreateFlagBits::eSignaled: return "Signaled"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(FenceCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & FenceCreateFlagBits::eSignaled) result += "Signaled | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlagBits value) - { - switch (value) - { - case FormatFeatureFlagBits::eSampledImage: return "SampledImage"; - case FormatFeatureFlagBits::eStorageImage: return "StorageImage"; - case FormatFeatureFlagBits::eStorageImageAtomic: return "StorageImageAtomic"; - case FormatFeatureFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer"; - case FormatFeatureFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer"; - case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "StorageTexelBufferAtomic"; - case FormatFeatureFlagBits::eVertexBuffer: return "VertexBuffer"; - case FormatFeatureFlagBits::eColorAttachment: return "ColorAttachment"; - case FormatFeatureFlagBits::eColorAttachmentBlend: return "ColorAttachmentBlend"; - case FormatFeatureFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment"; - case FormatFeatureFlagBits::eBlitSrc: return "BlitSrc"; - case FormatFeatureFlagBits::eBlitDst: return "BlitDst"; - case FormatFeatureFlagBits::eSampledImageFilterLinear: return "SampledImageFilterLinear"; - case FormatFeatureFlagBits::eTransferSrc: return "TransferSrc"; - case FormatFeatureFlagBits::eTransferDst: return "TransferDst"; - case FormatFeatureFlagBits::eMidpointChromaSamples: return "MidpointChromaSamples"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter: return "SampledImageYcbcrConversionLinearFilter"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable"; - case FormatFeatureFlagBits::eDisjoint: return "Disjoint"; - case FormatFeatureFlagBits::eCositedChromaSamples: return "CositedChromaSamples"; - case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG"; - case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & FormatFeatureFlagBits::eSampledImage) result += "SampledImage | "; - if (value & FormatFeatureFlagBits::eStorageImage) result += "StorageImage | "; - if (value & FormatFeatureFlagBits::eStorageImageAtomic) result += "StorageImageAtomic | "; - if (value & FormatFeatureFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | "; - if (value & FormatFeatureFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | "; - if (value & FormatFeatureFlagBits::eStorageTexelBufferAtomic) result += "StorageTexelBufferAtomic | "; - if (value & FormatFeatureFlagBits::eVertexBuffer) result += "VertexBuffer | "; - if (value & FormatFeatureFlagBits::eColorAttachment) result += "ColorAttachment | "; - if (value & FormatFeatureFlagBits::eColorAttachmentBlend) result += "ColorAttachmentBlend | "; - if (value & FormatFeatureFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | "; - if (value & FormatFeatureFlagBits::eBlitSrc) result += "BlitSrc | "; - if (value & FormatFeatureFlagBits::eBlitDst) result += "BlitDst | "; - if (value & FormatFeatureFlagBits::eSampledImageFilterLinear) result += "SampledImageFilterLinear | "; - if (value & FormatFeatureFlagBits::eTransferSrc) result += "TransferSrc | "; - if (value & FormatFeatureFlagBits::eTransferDst) result += "TransferDst | "; - if (value & FormatFeatureFlagBits::eMidpointChromaSamples) result += "MidpointChromaSamples | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) result += "SampledImageYcbcrConversionLinearFilter | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) result += "SampledImageYcbcrConversionSeparateReconstructionFilter | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) result += "SampledImageYcbcrConversionChromaReconstructionExplicit | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | "; - if (value & FormatFeatureFlagBits::eDisjoint) result += "Disjoint | "; - if (value & FormatFeatureFlagBits::eCositedChromaSamples) result += "CositedChromaSamples | "; - if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | "; - if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryControlFlagBits value) - { - switch (value) - { - case QueryControlFlagBits::ePrecise: return "Precise"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryControlFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueryControlFlagBits::ePrecise) result += "Precise | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryResultFlagBits value) - { - switch (value) - { - case QueryResultFlagBits::e64: return "64"; - case QueryResultFlagBits::eWait: return "Wait"; - case QueryResultFlagBits::eWithAvailability: return "WithAvailability"; - case QueryResultFlagBits::ePartial: return "Partial"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryResultFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueryResultFlagBits::e64) result += "64 | "; - if (value & QueryResultFlagBits::eWait) result += "Wait | "; - if (value & QueryResultFlagBits::eWithAvailability) result += "WithAvailability | "; - if (value & QueryResultFlagBits::ePartial) result += "Partial | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlagBits value) - { - switch (value) - { - case CommandBufferUsageFlagBits::eOneTimeSubmit: return "OneTimeSubmit"; - case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue"; - case CommandBufferUsageFlagBits::eSimultaneousUse: return "SimultaneousUse"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandBufferUsageFlagBits::eOneTimeSubmit) result += "OneTimeSubmit | "; - if (value & CommandBufferUsageFlagBits::eRenderPassContinue) result += "RenderPassContinue | "; - if (value & CommandBufferUsageFlagBits::eSimultaneousUse) result += "SimultaneousUse | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlagBits value) - { - switch (value) - { - case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "InputAssemblyVertices"; - case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "InputAssemblyPrimitives"; - case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "VertexShaderInvocations"; - case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "GeometryShaderInvocations"; - case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "GeometryShaderPrimitives"; - case QueryPipelineStatisticFlagBits::eClippingInvocations: return "ClippingInvocations"; - case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "ClippingPrimitives"; - case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "FragmentShaderInvocations"; - case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches"; - case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations"; - case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices) result += "InputAssemblyVertices | "; - if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) result += "InputAssemblyPrimitives | "; - if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations) result += "VertexShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) result += "GeometryShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) result += "GeometryShaderPrimitives | "; - if (value & QueryPipelineStatisticFlagBits::eClippingInvocations) result += "ClippingInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives) result += "ClippingPrimitives | "; - if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) result += "FragmentShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) result += "TessellationControlShaderPatches | "; - if (value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) result += "TessellationEvaluationShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations) result += "ComputeShaderInvocations | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageAspectFlagBits value) - { - switch (value) - { - case ImageAspectFlagBits::eColor: return "Color"; - case ImageAspectFlagBits::eDepth: return "Depth"; - case ImageAspectFlagBits::eStencil: return "Stencil"; - case ImageAspectFlagBits::eMetadata: return "Metadata"; - case ImageAspectFlagBits::ePlane0: return "Plane0"; - case ImageAspectFlagBits::ePlane1: return "Plane1"; - case ImageAspectFlagBits::ePlane2: return "Plane2"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageAspectFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ImageAspectFlagBits::eColor) result += "Color | "; - if (value & ImageAspectFlagBits::eDepth) result += "Depth | "; - if (value & ImageAspectFlagBits::eStencil) result += "Stencil | "; - if (value & ImageAspectFlagBits::eMetadata) result += "Metadata | "; - if (value & ImageAspectFlagBits::ePlane0) result += "Plane0 | "; - if (value & ImageAspectFlagBits::ePlane1) result += "Plane1 | "; - if (value & ImageAspectFlagBits::ePlane2) result += "Plane2 | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlagBits value) - { - switch (value) - { - case SparseImageFormatFlagBits::eSingleMiptail: return "SingleMiptail"; - case SparseImageFormatFlagBits::eAlignedMipSize: return "AlignedMipSize"; - case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SparseImageFormatFlagBits::eSingleMiptail) result += "SingleMiptail | "; - if (value & SparseImageFormatFlagBits::eAlignedMipSize) result += "AlignedMipSize | "; - if (value & SparseImageFormatFlagBits::eNonstandardBlockSize) result += "NonstandardBlockSize | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlagBits value) - { - switch (value) - { - case SparseMemoryBindFlagBits::eMetadata: return "Metadata"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SparseMemoryBindFlagBits::eMetadata) result += "Metadata | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits value) - { - switch (value) - { - case PipelineStageFlagBits::eTopOfPipe: return "TopOfPipe"; - case PipelineStageFlagBits::eDrawIndirect: return "DrawIndirect"; - case PipelineStageFlagBits::eVertexInput: return "VertexInput"; - case PipelineStageFlagBits::eVertexShader: return "VertexShader"; - case PipelineStageFlagBits::eTessellationControlShader: return "TessellationControlShader"; - case PipelineStageFlagBits::eTessellationEvaluationShader: return "TessellationEvaluationShader"; - case PipelineStageFlagBits::eGeometryShader: return "GeometryShader"; - case PipelineStageFlagBits::eFragmentShader: return "FragmentShader"; - case PipelineStageFlagBits::eEarlyFragmentTests: return "EarlyFragmentTests"; - case PipelineStageFlagBits::eLateFragmentTests: return "LateFragmentTests"; - case PipelineStageFlagBits::eColorAttachmentOutput: return "ColorAttachmentOutput"; - case PipelineStageFlagBits::eComputeShader: return "ComputeShader"; - case PipelineStageFlagBits::eTransfer: return "Transfer"; - case PipelineStageFlagBits::eBottomOfPipe: return "BottomOfPipe"; - case PipelineStageFlagBits::eHost: return "Host"; - case PipelineStageFlagBits::eAllGraphics: return "AllGraphics"; - case PipelineStageFlagBits::eAllCommands: return "AllCommands"; - case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineStageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & PipelineStageFlagBits::eTopOfPipe) result += "TopOfPipe | "; - if (value & PipelineStageFlagBits::eDrawIndirect) result += "DrawIndirect | "; - if (value & PipelineStageFlagBits::eVertexInput) result += "VertexInput | "; - if (value & PipelineStageFlagBits::eVertexShader) result += "VertexShader | "; - if (value & PipelineStageFlagBits::eTessellationControlShader) result += "TessellationControlShader | "; - if (value & PipelineStageFlagBits::eTessellationEvaluationShader) result += "TessellationEvaluationShader | "; - if (value & PipelineStageFlagBits::eGeometryShader) result += "GeometryShader | "; - if (value & PipelineStageFlagBits::eFragmentShader) result += "FragmentShader | "; - if (value & PipelineStageFlagBits::eEarlyFragmentTests) result += "EarlyFragmentTests | "; - if (value & PipelineStageFlagBits::eLateFragmentTests) result += "LateFragmentTests | "; - if (value & PipelineStageFlagBits::eColorAttachmentOutput) result += "ColorAttachmentOutput | "; - if (value & PipelineStageFlagBits::eComputeShader) result += "ComputeShader | "; - if (value & PipelineStageFlagBits::eTransfer) result += "Transfer | "; - if (value & PipelineStageFlagBits::eBottomOfPipe) result += "BottomOfPipe | "; - if (value & PipelineStageFlagBits::eHost) result += "Host | "; - if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | "; - if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | "; - if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlagBits value) - { - switch (value) - { - case CommandPoolCreateFlagBits::eTransient: return "Transient"; - case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer"; - case CommandPoolCreateFlagBits::eProtected: return "Protected"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandPoolCreateFlagBits::eTransient) result += "Transient | "; - if (value & CommandPoolCreateFlagBits::eResetCommandBuffer) result += "ResetCommandBuffer | "; - if (value & CommandPoolCreateFlagBits::eProtected) result += "Protected | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlagBits value) - { - switch (value) - { - case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandPoolResetFlagBits::eReleaseResources) result += "ReleaseResources | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlagBits value) - { - switch (value) - { - case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandBufferResetFlagBits::eReleaseResources) result += "ReleaseResources | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SampleCountFlagBits value) - { - switch (value) - { - case SampleCountFlagBits::e1: return "1"; - case SampleCountFlagBits::e2: return "2"; - case SampleCountFlagBits::e4: return "4"; - case SampleCountFlagBits::e8: return "8"; - case SampleCountFlagBits::e16: return "16"; - case SampleCountFlagBits::e32: return "32"; - case SampleCountFlagBits::e64: return "64"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SampleCountFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SampleCountFlagBits::e1) result += "1 | "; - if (value & SampleCountFlagBits::e2) result += "2 | "; - if (value & SampleCountFlagBits::e4) result += "4 | "; - if (value & SampleCountFlagBits::e8) result += "8 | "; - if (value & SampleCountFlagBits::e16) result += "16 | "; - if (value & SampleCountFlagBits::e32) result += "32 | "; - if (value & SampleCountFlagBits::e64) result += "64 | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlagBits value) - { - switch (value) - { - case AttachmentDescriptionFlagBits::eMayAlias: return "MayAlias"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & AttachmentDescriptionFlagBits::eMayAlias) result += "MayAlias | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(StencilFaceFlagBits value) - { - switch (value) - { - case StencilFaceFlagBits::eFront: return "Front"; - case StencilFaceFlagBits::eBack: return "Back"; - case StencilFaceFlagBits::eVkStencilFrontAndBack: return "VkStencilFrontAndBack"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(StencilFaceFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & StencilFaceFlagBits::eFront) result += "Front | "; - if (value & StencilFaceFlagBits::eBack) result += "Back | "; - if (value & StencilFaceFlagBits::eVkStencilFrontAndBack) result += "VkStencilFrontAndBack | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlagBits value) - { - switch (value) - { - case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet"; - case DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT: return "UpdateAfterBindEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet) result += "FreeDescriptorSet | "; - if (value & DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT) result += "UpdateAfterBindEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DependencyFlagBits value) - { - switch (value) - { - case DependencyFlagBits::eByRegion: return "ByRegion"; - case DependencyFlagBits::eDeviceGroup: return "DeviceGroup"; - case DependencyFlagBits::eViewLocal: return "ViewLocal"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DependencyFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & DependencyFlagBits::eByRegion) result += "ByRegion | "; - if (value & DependencyFlagBits::eDeviceGroup) result += "DeviceGroup | "; - if (value & DependencyFlagBits::eViewLocal) result += "ViewLocal | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PresentModeKHR value) - { - switch (value) - { - case PresentModeKHR::eImmediate: return "Immediate"; - case PresentModeKHR::eMailbox: return "Mailbox"; - case PresentModeKHR::eFifo: return "Fifo"; - case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed"; - case PresentModeKHR::eSharedDemandRefresh: return "SharedDemandRefresh"; - case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ColorSpaceKHR value) - { - switch (value) - { - case ColorSpaceKHR::eSrgbNonlinear: return "SrgbNonlinear"; - case ColorSpaceKHR::eDisplayP3NonlinearEXT: return "DisplayP3NonlinearEXT"; - case ColorSpaceKHR::eExtendedSrgbLinearEXT: return "ExtendedSrgbLinearEXT"; - case ColorSpaceKHR::eDciP3LinearEXT: return "DciP3LinearEXT"; - case ColorSpaceKHR::eDciP3NonlinearEXT: return "DciP3NonlinearEXT"; - case ColorSpaceKHR::eBt709LinearEXT: return "Bt709LinearEXT"; - case ColorSpaceKHR::eBt709NonlinearEXT: return "Bt709NonlinearEXT"; - case ColorSpaceKHR::eBt2020LinearEXT: return "Bt2020LinearEXT"; - case ColorSpaceKHR::eHdr10St2084EXT: return "Hdr10St2084EXT"; - case ColorSpaceKHR::eDolbyvisionEXT: return "DolbyvisionEXT"; - case ColorSpaceKHR::eHdr10HlgEXT: return "Hdr10HlgEXT"; - case ColorSpaceKHR::eAdobergbLinearEXT: return "AdobergbLinearEXT"; - case ColorSpaceKHR::eAdobergbNonlinearEXT: return "AdobergbNonlinearEXT"; - case ColorSpaceKHR::ePassThroughEXT: return "PassThroughEXT"; - case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagBitsKHR value) - { - switch (value) - { - case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "Opaque"; - case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "Global"; - case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "PerPixel"; - case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque) result += "Opaque | "; - if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal) result += "Global | "; - if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel) result += "PerPixel | "; - if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) result += "PerPixelPremultiplied | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagBitsKHR value) - { - switch (value) - { - case CompositeAlphaFlagBitsKHR::eOpaque: return "Opaque"; - case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "PreMultiplied"; - case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied"; - case CompositeAlphaFlagBitsKHR::eInherit: return "Inherit"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & CompositeAlphaFlagBitsKHR::eOpaque) result += "Opaque | "; - if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied) result += "PreMultiplied | "; - if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied) result += "PostMultiplied | "; - if (value & CompositeAlphaFlagBitsKHR::eInherit) result += "Inherit | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagBitsKHR value) - { - switch (value) - { - case SurfaceTransformFlagBitsKHR::eIdentity: return "Identity"; - case SurfaceTransformFlagBitsKHR::eRotate90: return "Rotate90"; - case SurfaceTransformFlagBitsKHR::eRotate180: return "Rotate180"; - case SurfaceTransformFlagBitsKHR::eRotate270: return "Rotate270"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "HorizontalMirror"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "HorizontalMirrorRotate90"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270"; - case SurfaceTransformFlagBitsKHR::eInherit: return "Inherit"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & SurfaceTransformFlagBitsKHR::eIdentity) result += "Identity | "; - if (value & SurfaceTransformFlagBitsKHR::eRotate90) result += "Rotate90 | "; - if (value & SurfaceTransformFlagBitsKHR::eRotate180) result += "Rotate180 | "; - if (value & SurfaceTransformFlagBitsKHR::eRotate270) result += "Rotate270 | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror) result += "HorizontalMirror | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) result += "HorizontalMirrorRotate90 | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) result += "HorizontalMirrorRotate180 | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) result += "HorizontalMirrorRotate270 | "; - if (value & SurfaceTransformFlagBitsKHR::eInherit) result += "Inherit | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value) - { - switch (value) - { - case DebugReportFlagBitsEXT::eInformation: return "Information"; - case DebugReportFlagBitsEXT::eWarning: return "Warning"; - case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning"; - case DebugReportFlagBitsEXT::eError: return "Error"; - case DebugReportFlagBitsEXT::eDebug: return "Debug"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DebugReportFlagsEXT value) - { - if (!value) return "{}"; - std::string result; - if (value & DebugReportFlagBitsEXT::eInformation) result += "Information | "; - if (value & DebugReportFlagBitsEXT::eWarning) result += "Warning | "; - if (value & DebugReportFlagBitsEXT::ePerformanceWarning) result += "PerformanceWarning | "; - if (value & DebugReportFlagBitsEXT::eError) result += "Error | "; - if (value & DebugReportFlagBitsEXT::eDebug) result += "Debug | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugReportObjectTypeEXT value) - { - switch (value) - { - case DebugReportObjectTypeEXT::eUnknown: return "Unknown"; - case DebugReportObjectTypeEXT::eInstance: return "Instance"; - case DebugReportObjectTypeEXT::ePhysicalDevice: return "PhysicalDevice"; - case DebugReportObjectTypeEXT::eDevice: return "Device"; - case DebugReportObjectTypeEXT::eQueue: return "Queue"; - case DebugReportObjectTypeEXT::eSemaphore: return "Semaphore"; - case DebugReportObjectTypeEXT::eCommandBuffer: return "CommandBuffer"; - case DebugReportObjectTypeEXT::eFence: return "Fence"; - case DebugReportObjectTypeEXT::eDeviceMemory: return "DeviceMemory"; - case DebugReportObjectTypeEXT::eBuffer: return "Buffer"; - case DebugReportObjectTypeEXT::eImage: return "Image"; - case DebugReportObjectTypeEXT::eEvent: return "Event"; - case DebugReportObjectTypeEXT::eQueryPool: return "QueryPool"; - case DebugReportObjectTypeEXT::eBufferView: return "BufferView"; - case DebugReportObjectTypeEXT::eImageView: return "ImageView"; - case DebugReportObjectTypeEXT::eShaderModule: return "ShaderModule"; - case DebugReportObjectTypeEXT::ePipelineCache: return "PipelineCache"; - case DebugReportObjectTypeEXT::ePipelineLayout: return "PipelineLayout"; - case DebugReportObjectTypeEXT::eRenderPass: return "RenderPass"; - case DebugReportObjectTypeEXT::ePipeline: return "Pipeline"; - case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DescriptorSetLayout"; - case DebugReportObjectTypeEXT::eSampler: return "Sampler"; - case DebugReportObjectTypeEXT::eDescriptorPool: return "DescriptorPool"; - case DebugReportObjectTypeEXT::eDescriptorSet: return "DescriptorSet"; - case DebugReportObjectTypeEXT::eFramebuffer: return "Framebuffer"; - case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool"; - case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr"; - case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr"; - case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt"; - case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr"; - case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr"; - case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx"; - case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNvx: return "IndirectCommandsLayoutNvx"; - case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt"; - case DebugReportObjectTypeEXT::eSamplerYcbcrConversion: return "SamplerYcbcrConversion"; - case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value) - { - switch (value) - { - case RasterizationOrderAMD::eStrict: return "Strict"; - case RasterizationOrderAMD::eRelaxed: return "Relaxed"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsNV value) - { - switch (value) - { - case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32: return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image: return "D3D11Image"; - case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt: return "D3D11ImageKmt"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsNV value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) result += "D3D11Image | "; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) result += "D3D11ImageKmt | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsNV value) - { - switch (value) - { - case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBitsNV::eExportable: return "Exportable"; - case ExternalMemoryFeatureFlagBitsNV::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsNV value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) result += "DedicatedOnly | "; - if (value & ExternalMemoryFeatureFlagBitsNV::eExportable) result += "Exportable | "; - if (value & ExternalMemoryFeatureFlagBitsNV::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCheckEXT value) - { - switch (value) - { - case ValidationCheckEXT::eAll: return "All"; - case ValidationCheckEXT::eShaders: return "Shaders"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlagBits value) - { - switch (value) - { - case SubgroupFeatureFlagBits::eBasic: return "Basic"; - case SubgroupFeatureFlagBits::eVote: return "Vote"; - case SubgroupFeatureFlagBits::eArithmetic: return "Arithmetic"; - case SubgroupFeatureFlagBits::eBallot: return "Ballot"; - case SubgroupFeatureFlagBits::eShuffle: return "Shuffle"; - case SubgroupFeatureFlagBits::eShuffleRelative: return "ShuffleRelative"; - case SubgroupFeatureFlagBits::eClustered: return "Clustered"; - case SubgroupFeatureFlagBits::eQuad: return "Quad"; - case SubgroupFeatureFlagBits::ePartitionedNV: return "PartitionedNV"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SubgroupFeatureFlagBits::eBasic) result += "Basic | "; - if (value & SubgroupFeatureFlagBits::eVote) result += "Vote | "; - if (value & SubgroupFeatureFlagBits::eArithmetic) result += "Arithmetic | "; - if (value & SubgroupFeatureFlagBits::eBallot) result += "Ballot | "; - if (value & SubgroupFeatureFlagBits::eShuffle) result += "Shuffle | "; - if (value & SubgroupFeatureFlagBits::eShuffleRelative) result += "ShuffleRelative | "; - if (value & SubgroupFeatureFlagBits::eClustered) result += "Clustered | "; - if (value & SubgroupFeatureFlagBits::eQuad) result += "Quad | "; - if (value & SubgroupFeatureFlagBits::ePartitionedNV) result += "PartitionedNV | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagBitsNVX value) - { - switch (value) - { - case IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences: return "UnorderedSequences"; - case IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences: return "SparseSequences"; - case IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions: return "EmptyExecutions"; - case IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences: return "IndexedSequences"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagsNVX value) - { - if (!value) return "{}"; - std::string result; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) result += "UnorderedSequences | "; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) result += "SparseSequences | "; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) result += "EmptyExecutions | "; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) result += "IndexedSequences | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagBitsNVX value) - { - switch (value) - { - case ObjectEntryUsageFlagBitsNVX::eGraphics: return "Graphics"; - case ObjectEntryUsageFlagBitsNVX::eCompute: return "Compute"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagsNVX value) - { - if (!value) return "{}"; - std::string result; - if (value & ObjectEntryUsageFlagBitsNVX::eGraphics) result += "Graphics | "; - if (value & ObjectEntryUsageFlagBitsNVX::eCompute) result += "Compute | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(IndirectCommandsTokenTypeNVX value) - { - switch (value) - { - case IndirectCommandsTokenTypeNVX::ePipeline: return "Pipeline"; - case IndirectCommandsTokenTypeNVX::eDescriptorSet: return "DescriptorSet"; - case IndirectCommandsTokenTypeNVX::eIndexBuffer: return "IndexBuffer"; - case IndirectCommandsTokenTypeNVX::eVertexBuffer: return "VertexBuffer"; - case IndirectCommandsTokenTypeNVX::ePushConstant: return "PushConstant"; - case IndirectCommandsTokenTypeNVX::eDrawIndexed: return "DrawIndexed"; - case IndirectCommandsTokenTypeNVX::eDraw: return "Draw"; - case IndirectCommandsTokenTypeNVX::eDispatch: return "Dispatch"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ObjectEntryTypeNVX value) - { - switch (value) - { - case ObjectEntryTypeNVX::eDescriptorSet: return "DescriptorSet"; - case ObjectEntryTypeNVX::ePipeline: return "Pipeline"; - case ObjectEntryTypeNVX::eIndexBuffer: return "IndexBuffer"; - case ObjectEntryTypeNVX::eVertexBuffer: return "VertexBuffer"; - case ObjectEntryTypeNVX::ePushConstant: return "PushConstant"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlagBits value) - { - switch (value) - { - case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR"; - case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT: return "UpdateAfterBindPoolEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) result += "PushDescriptorKHR | "; - if (value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT) result += "UpdateAfterBindPoolEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBits value) - { - switch (value) - { - case ExternalMemoryHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd"; - case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBits::eD3D11Texture: return "D3D11Texture"; - case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt: return "D3D11TextureKmt"; - case ExternalMemoryHandleTypeFlagBits::eD3D12Heap: return "D3D12Heap"; - case ExternalMemoryHandleTypeFlagBits::eD3D12Resource: return "D3D12Resource"; - case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT: return "DmaBufEXT"; - case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID: return "AndroidHardwareBufferANDROID"; - case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT: return "HostAllocationEXT"; - case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture) result += "D3D11Texture | "; - if (value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) result += "D3D11TextureKmt | "; - if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap) result += "D3D12Heap | "; - if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource) result += "D3D12Resource | "; - if (value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) result += "DmaBufEXT | "; - if (value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) result += "AndroidHardwareBufferANDROID | "; - if (value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) result += "HostAllocationEXT | "; - if (value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT) result += "HostMappedForeignMemoryEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBits value) - { - switch (value) - { - case ExternalMemoryFeatureFlagBits::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBits::eExportable: return "Exportable"; - case ExternalMemoryFeatureFlagBits::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryFeatureFlagBits::eDedicatedOnly) result += "DedicatedOnly | "; - if (value & ExternalMemoryFeatureFlagBits::eExportable) result += "Exportable | "; - if (value & ExternalMemoryFeatureFlagBits::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBits value) - { - switch (value) - { - case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd"; - case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32"; - case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence: return "D3D12Fence"; - case ExternalSemaphoreHandleTypeFlagBits::eSyncFd: return "SyncFd"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) result += "D3D12Fence | "; - if (value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd) result += "SyncFd | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBits value) - { - switch (value) - { - case ExternalSemaphoreFeatureFlagBits::eExportable: return "Exportable"; - case ExternalSemaphoreFeatureFlagBits::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalSemaphoreFeatureFlagBits::eExportable) result += "Exportable | "; - if (value & ExternalSemaphoreFeatureFlagBits::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBits value) - { - switch (value) - { - case SemaphoreImportFlagBits::eTemporary: return "Temporary"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SemaphoreImportFlagBits::eTemporary) result += "Temporary | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBits value) - { - switch (value) - { - case ExternalFenceHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd"; - case ExternalFenceHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32"; - case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalFenceHandleTypeFlagBits::eSyncFd: return "SyncFd"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalFenceHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalFenceHandleTypeFlagBits::eSyncFd) result += "SyncFd | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBits value) - { - switch (value) - { - case ExternalFenceFeatureFlagBits::eExportable: return "Exportable"; - case ExternalFenceFeatureFlagBits::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalFenceFeatureFlagBits::eExportable) result += "Exportable | "; - if (value & ExternalFenceFeatureFlagBits::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBits value) - { - switch (value) - { - case FenceImportFlagBits::eTemporary: return "Temporary"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(FenceImportFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & FenceImportFlagBits::eTemporary) result += "Temporary | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value) - { - switch (value) - { - case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagsEXT value) - { - if (!value) return "{}"; - std::string result; - if (value & SurfaceCounterFlagBitsEXT::eVblank) result += "Vblank | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplayPowerStateEXT value) - { - switch (value) - { - case DisplayPowerStateEXT::eOff: return "Off"; - case DisplayPowerStateEXT::eSuspend: return "Suspend"; - case DisplayPowerStateEXT::eOn: return "On"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DeviceEventTypeEXT value) - { - switch (value) - { - case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DisplayEventTypeEXT value) - { - switch (value) - { - case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBits value) - { - switch (value) - { - case PeerMemoryFeatureFlagBits::eCopySrc: return "CopySrc"; - case PeerMemoryFeatureFlagBits::eCopyDst: return "CopyDst"; - case PeerMemoryFeatureFlagBits::eGenericSrc: return "GenericSrc"; - case PeerMemoryFeatureFlagBits::eGenericDst: return "GenericDst"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & PeerMemoryFeatureFlagBits::eCopySrc) result += "CopySrc | "; - if (value & PeerMemoryFeatureFlagBits::eCopyDst) result += "CopyDst | "; - if (value & PeerMemoryFeatureFlagBits::eGenericSrc) result += "GenericSrc | "; - if (value & PeerMemoryFeatureFlagBits::eGenericDst) result += "GenericDst | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBits value) - { - switch (value) - { - case MemoryAllocateFlagBits::eDeviceMask: return "DeviceMask"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & MemoryAllocateFlagBits::eDeviceMask) result += "DeviceMask | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagBitsKHR value) - { - switch (value) - { - case DeviceGroupPresentModeFlagBitsKHR::eLocal: return "Local"; - case DeviceGroupPresentModeFlagBitsKHR::eRemote: return "Remote"; - case DeviceGroupPresentModeFlagBitsKHR::eSum: return "Sum"; - case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice: return "LocalMultiDevice"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & DeviceGroupPresentModeFlagBitsKHR::eLocal) result += "Local | "; - if (value & DeviceGroupPresentModeFlagBitsKHR::eRemote) result += "Remote | "; - if (value & DeviceGroupPresentModeFlagBitsKHR::eSum) result += "Sum | "; - if (value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice) result += "LocalMultiDevice | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagBitsKHR value) - { - switch (value) - { - case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; - case SwapchainCreateFlagBitsKHR::eProtected: return "Protected"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | "; - if (value & SwapchainCreateFlagBitsKHR::eProtected) result += "Protected | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value) - { - switch (value) - { - case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX"; - case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX"; - case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY"; - case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY"; - case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ"; - case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ"; - case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW"; - case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value) - { - switch (value) - { - case DiscardRectangleModeEXT::eInclusive: return "Inclusive"; - case DiscardRectangleModeEXT::eExclusive: return "Exclusive"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value) - { - switch (value) - { - case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX"; - case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX) result += "PerViewAttributesNVX | "; - if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) result += "PerViewPositionXOnlyNVX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PointClippingBehavior value) - { - switch (value) - { - case PointClippingBehavior::eAllClipPlanes: return "AllClipPlanes"; - case PointClippingBehavior::eUserClipPlanesOnly: return "UserClipPlanesOnly"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerReductionModeEXT value) - { - switch (value) - { - case SamplerReductionModeEXT::eWeightedAverage: return "WeightedAverage"; - case SamplerReductionModeEXT::eMin: return "Min"; - case SamplerReductionModeEXT::eMax: return "Max"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(TessellationDomainOrigin value) - { - switch (value) - { - case TessellationDomainOrigin::eUpperLeft: return "UpperLeft"; - case TessellationDomainOrigin::eLowerLeft: return "LowerLeft"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrModelConversion value) - { - switch (value) - { - case SamplerYcbcrModelConversion::eRgbIdentity: return "RgbIdentity"; - case SamplerYcbcrModelConversion::eYcbcrIdentity: return "YcbcrIdentity"; - case SamplerYcbcrModelConversion::eYcbcr709: return "Ycbcr709"; - case SamplerYcbcrModelConversion::eYcbcr601: return "Ycbcr601"; - case SamplerYcbcrModelConversion::eYcbcr2020: return "Ycbcr2020"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrRange value) - { - switch (value) - { - case SamplerYcbcrRange::eItuFull: return "ItuFull"; - case SamplerYcbcrRange::eItuNarrow: return "ItuNarrow"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ChromaLocation value) - { - switch (value) - { - case ChromaLocation::eCositedEven: return "CositedEven"; - case ChromaLocation::eMidpoint: return "Midpoint"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value) - { - switch (value) - { - case BlendOverlapEXT::eUncorrelated: return "Uncorrelated"; - case BlendOverlapEXT::eDisjoint: return "Disjoint"; - case BlendOverlapEXT::eConjoint: return "Conjoint"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value) - { - switch (value) - { - case CoverageModulationModeNV::eNone: return "None"; - case CoverageModulationModeNV::eRgb: return "Rgb"; - case CoverageModulationModeNV::eAlpha: return "Alpha"; - case CoverageModulationModeNV::eRgba: return "Rgba"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCacheHeaderVersionEXT value) - { - switch (value) - { - case ValidationCacheHeaderVersionEXT::eOne: return "One"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value) - { - switch (value) - { - case ShaderInfoTypeAMD::eStatistics: return "Statistics"; - case ShaderInfoTypeAMD::eBinary: return "Binary"; - case ShaderInfoTypeAMD::eDisassembly: return "Disassembly"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value) - { - switch (value) - { - case QueueGlobalPriorityEXT::eLow: return "Low"; - case QueueGlobalPriorityEXT::eMedium: return "Medium"; - case QueueGlobalPriorityEXT::eHigh: return "High"; - case QueueGlobalPriorityEXT::eRealtime: return "Realtime"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageSeverityFlagBitsEXT value) - { - switch (value) - { - case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose: return "Verbose"; - case DebugUtilsMessageSeverityFlagBitsEXT::eInfo: return "Info"; - case DebugUtilsMessageSeverityFlagBitsEXT::eWarning: return "Warning"; - case DebugUtilsMessageSeverityFlagBitsEXT::eError: return "Error"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageSeverityFlagsEXT value) - { - if (!value) return "{}"; - std::string result; - if (value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) result += "Verbose | "; - if (value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo) result += "Info | "; - if (value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning) result += "Warning | "; - if (value & DebugUtilsMessageSeverityFlagBitsEXT::eError) result += "Error | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagBitsEXT value) - { - switch (value) - { - case DebugUtilsMessageTypeFlagBitsEXT::eGeneral: return "General"; - case DebugUtilsMessageTypeFlagBitsEXT::eValidation: return "Validation"; - case DebugUtilsMessageTypeFlagBitsEXT::ePerformance: return "Performance"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagsEXT value) - { - if (!value) return "{}"; - std::string result; - if (value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral) result += "General | "; - if (value & DebugUtilsMessageTypeFlagBitsEXT::eValidation) result += "Validation | "; - if (value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance) result += "Performance | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ConservativeRasterizationModeEXT value) - { - switch (value) - { - case ConservativeRasterizationModeEXT::eDisabled: return "Disabled"; - case ConservativeRasterizationModeEXT::eOverestimate: return "Overestimate"; - case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagBitsEXT value) - { - switch (value) - { - case DescriptorBindingFlagBitsEXT::eUpdateAfterBind: return "UpdateAfterBind"; - case DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending: return "UpdateUnusedWhilePending"; - case DescriptorBindingFlagBitsEXT::ePartiallyBound: return "PartiallyBound"; - case DescriptorBindingFlagBitsEXT::eVariableDescriptorCount: return "VariableDescriptorCount"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagsEXT value) - { - if (!value) return "{}"; - std::string result; - if (value & DescriptorBindingFlagBitsEXT::eUpdateAfterBind) result += "UpdateAfterBind | "; - if (value & DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) result += "UpdateUnusedWhilePending | "; - if (value & DescriptorBindingFlagBitsEXT::ePartiallyBound) result += "PartiallyBound | "; - if (value & DescriptorBindingFlagBitsEXT::eVariableDescriptorCount) result += "VariableDescriptorCount | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(VendorId value) - { - switch (value) - { - case VendorId::eViv: return "Viv"; - case VendorId::eVsi: return "Vsi"; - case VendorId::eKazan: return "Kazan"; - default: return "invalid"; - } - } - - class DispatchLoaderDynamic - { - public: - PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; - PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; - PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; - PFN_vkAllocateMemory vkAllocateMemory = 0; - PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; - PFN_vkBindBufferMemory vkBindBufferMemory = 0; - PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; - PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; - PFN_vkBindImageMemory vkBindImageMemory = 0; - PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; - PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; - PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; - PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; - PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; - PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; - PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; - PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; - PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; - PFN_vkCmdBlitImage vkCmdBlitImage = 0; - PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; - PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; - PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; - PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; - PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; - PFN_vkCmdCopyImage vkCmdCopyImage = 0; - PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; - PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; - PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; - PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; - PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; - PFN_vkCmdDispatch vkCmdDispatch = 0; - PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; - PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; - PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; - PFN_vkCmdDraw vkCmdDraw = 0; - PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; - PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; - PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; - PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; - PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; - PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; - PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; - PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; - PFN_vkCmdEndQuery vkCmdEndQuery = 0; - PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; - PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; - PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; - PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; - PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; - PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; - PFN_vkCmdProcessCommandsNVX vkCmdProcessCommandsNVX = 0; - PFN_vkCmdPushConstants vkCmdPushConstants = 0; - PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; - PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; - PFN_vkCmdReserveSpaceForCommandsNVX vkCmdReserveSpaceForCommandsNVX = 0; - PFN_vkCmdResetEvent vkCmdResetEvent = 0; - PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; - PFN_vkCmdResolveImage vkCmdResolveImage = 0; - PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; - PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; - PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; - PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; - PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; - PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; - PFN_vkCmdSetEvent vkCmdSetEvent = 0; - PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; - PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; - PFN_vkCmdSetScissor vkCmdSetScissor = 0; - PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; - PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; - PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; - PFN_vkCmdSetViewport vkCmdSetViewport = 0; - PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; - PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; - PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; - PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; - PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; -#ifdef VK_USE_PLATFORM_ANDROID_KHR - PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - PFN_vkCreateBuffer vkCreateBuffer = 0; - PFN_vkCreateBufferView vkCreateBufferView = 0; - PFN_vkCreateCommandPool vkCreateCommandPool = 0; - PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; - PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; - PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; - PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; - PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; - PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; - PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; - PFN_vkCreateDevice vkCreateDevice = 0; - PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; - PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; - PFN_vkCreateEvent vkCreateEvent = 0; - PFN_vkCreateFence vkCreateFence = 0; - PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; - PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; -#ifdef VK_USE_PLATFORM_IOS_MVK - PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - PFN_vkCreateImage vkCreateImage = 0; - PFN_vkCreateImageView vkCreateImageView = 0; - PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX = 0; - PFN_vkCreateInstance vkCreateInstance = 0; -#ifdef VK_USE_PLATFORM_MACOS_MVK - PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR = 0; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX = 0; - PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; - PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; - PFN_vkCreateQueryPool vkCreateQueryPool = 0; - PFN_vkCreateRenderPass vkCreateRenderPass = 0; - PFN_vkCreateSampler vkCreateSampler = 0; - PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; - PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; - PFN_vkCreateSemaphore vkCreateSemaphore = 0; - PFN_vkCreateShaderModule vkCreateShaderModule = 0; - PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; - PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; - PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; -#ifdef VK_USE_PLATFORM_VI_NN - PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; -#endif /*VK_USE_PLATFORM_VI_NN*/ -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_XCB_KHR - PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#ifdef VK_USE_PLATFORM_XLIB_KHR - PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; - PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; - PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; - PFN_vkDestroyBuffer vkDestroyBuffer = 0; - PFN_vkDestroyBufferView vkDestroyBufferView = 0; - PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; - PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; - PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; - PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; - PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; - PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; - PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; - PFN_vkDestroyDevice vkDestroyDevice = 0; - PFN_vkDestroyEvent vkDestroyEvent = 0; - PFN_vkDestroyFence vkDestroyFence = 0; - PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; - PFN_vkDestroyImage vkDestroyImage = 0; - PFN_vkDestroyImageView vkDestroyImageView = 0; - PFN_vkDestroyIndirectCommandsLayoutNVX vkDestroyIndirectCommandsLayoutNVX = 0; - PFN_vkDestroyInstance vkDestroyInstance = 0; - PFN_vkDestroyObjectTableNVX vkDestroyObjectTableNVX = 0; - PFN_vkDestroyPipeline vkDestroyPipeline = 0; - PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; - PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; - PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; - PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; - PFN_vkDestroySampler vkDestroySampler = 0; - PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; - PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; - PFN_vkDestroySemaphore vkDestroySemaphore = 0; - PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; - PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; - PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; - PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; - PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; - PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; - PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; - PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; - PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; - PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; - PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; - PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; - PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; - PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; - PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; - PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; - PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; - PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; - PFN_vkFreeMemory vkFreeMemory = 0; -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; - PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; - PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; - PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; - PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; - PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; - PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; - PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; - PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; - PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; - PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; - PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; - PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; - PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; - PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; - PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; - PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; - PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; - PFN_vkGetEventStatus vkGetEventStatus = 0; - PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; - PFN_vkGetFenceStatus vkGetFenceStatus = 0; -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; - PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; - PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; - PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; - PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; - PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; - PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; - PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; - PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_NV - PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; -#endif /*VK_USE_PLATFORM_WIN32_NV*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; - PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; - PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; - PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; - PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; - PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; - PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; - PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; - PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; - PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; - PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; - PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; - PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; - PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; - PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; - PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; - PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; - PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; -#ifdef VK_USE_PLATFORM_MIR_KHR - PFN_vkGetPhysicalDeviceMirPresentationSupportKHR vkGetPhysicalDeviceMirPresentationSupportKHR = 0; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; - PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; - PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; - PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; - PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; - PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; - PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; - PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_XCB_KHR - PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#ifdef VK_USE_PLATFORM_XLIB_KHR - PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; - PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; - PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; - PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; - PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; - PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; - PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; - PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; - PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; -#ifdef VK_USE_PLATFORM_WIN32_KHR - PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; - PFN_vkMapMemory vkMapMemory = 0; - PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; - PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; - PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; - PFN_vkQueueBindSparse vkQueueBindSparse = 0; - PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; - PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; - PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; - PFN_vkQueueSubmit vkQueueSubmit = 0; - PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; - PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; - PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; - PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX = 0; - PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; - PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; - PFN_vkResetCommandPool vkResetCommandPool = 0; - PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; - PFN_vkResetEvent vkResetEvent = 0; - PFN_vkResetFences vkResetFences = 0; - PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; - PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; - PFN_vkSetEvent vkSetEvent = 0; - PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; - PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; - PFN_vkTrimCommandPool vkTrimCommandPool = 0; - PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; - PFN_vkUnmapMemory vkUnmapMemory = 0; - PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX = 0; - PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; - PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; - PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; - PFN_vkWaitForFences vkWaitForFences = 0; - public: - DispatchLoaderDynamic(Instance instance = Instance(), Device device = Device()) - { - if (instance) - { - init(instance, device); - } - } - - void init(Instance instance, Device device = Device()) - { - vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(device ? device.getProcAddr( "vkAcquireNextImage2KHR") : instance.getProcAddr( "vkAcquireNextImage2KHR")); - vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(device ? device.getProcAddr( "vkAcquireNextImageKHR") : instance.getProcAddr( "vkAcquireNextImageKHR")); -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(device ? device.getProcAddr( "vkAcquireXlibDisplayEXT") : instance.getProcAddr( "vkAcquireXlibDisplayEXT")); -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(device ? device.getProcAddr( "vkAllocateCommandBuffers") : instance.getProcAddr( "vkAllocateCommandBuffers")); - vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(device ? device.getProcAddr( "vkAllocateDescriptorSets") : instance.getProcAddr( "vkAllocateDescriptorSets")); - vkAllocateMemory = PFN_vkAllocateMemory(device ? device.getProcAddr( "vkAllocateMemory") : instance.getProcAddr( "vkAllocateMemory")); - vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(device ? device.getProcAddr( "vkBeginCommandBuffer") : instance.getProcAddr( "vkBeginCommandBuffer")); - vkBindBufferMemory = PFN_vkBindBufferMemory(device ? device.getProcAddr( "vkBindBufferMemory") : instance.getProcAddr( "vkBindBufferMemory")); - vkBindBufferMemory2 = PFN_vkBindBufferMemory2(device ? device.getProcAddr( "vkBindBufferMemory2") : instance.getProcAddr( "vkBindBufferMemory2")); - vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(device ? device.getProcAddr( "vkBindBufferMemory2KHR") : instance.getProcAddr( "vkBindBufferMemory2KHR")); - vkBindImageMemory = PFN_vkBindImageMemory(device ? device.getProcAddr( "vkBindImageMemory") : instance.getProcAddr( "vkBindImageMemory")); - vkBindImageMemory2 = PFN_vkBindImageMemory2(device ? device.getProcAddr( "vkBindImageMemory2") : instance.getProcAddr( "vkBindImageMemory2")); - vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(device ? device.getProcAddr( "vkBindImageMemory2KHR") : instance.getProcAddr( "vkBindImageMemory2KHR")); - vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT")); - vkCmdBeginQuery = PFN_vkCmdBeginQuery(device ? device.getProcAddr( "vkCmdBeginQuery") : instance.getProcAddr( "vkCmdBeginQuery")); - vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(device ? device.getProcAddr( "vkCmdBeginRenderPass") : instance.getProcAddr( "vkCmdBeginRenderPass")); - vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(device ? device.getProcAddr( "vkCmdBindDescriptorSets") : instance.getProcAddr( "vkCmdBindDescriptorSets")); - vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(device ? device.getProcAddr( "vkCmdBindIndexBuffer") : instance.getProcAddr( "vkCmdBindIndexBuffer")); - vkCmdBindPipeline = PFN_vkCmdBindPipeline(device ? device.getProcAddr( "vkCmdBindPipeline") : instance.getProcAddr( "vkCmdBindPipeline")); - vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(device ? device.getProcAddr( "vkCmdBindVertexBuffers") : instance.getProcAddr( "vkCmdBindVertexBuffers")); - vkCmdBlitImage = PFN_vkCmdBlitImage(device ? device.getProcAddr( "vkCmdBlitImage") : instance.getProcAddr( "vkCmdBlitImage")); - vkCmdClearAttachments = PFN_vkCmdClearAttachments(device ? device.getProcAddr( "vkCmdClearAttachments") : instance.getProcAddr( "vkCmdClearAttachments")); - vkCmdClearColorImage = PFN_vkCmdClearColorImage(device ? device.getProcAddr( "vkCmdClearColorImage") : instance.getProcAddr( "vkCmdClearColorImage")); - vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(device ? device.getProcAddr( "vkCmdClearDepthStencilImage") : instance.getProcAddr( "vkCmdClearDepthStencilImage")); - vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(device ? device.getProcAddr( "vkCmdCopyBuffer") : instance.getProcAddr( "vkCmdCopyBuffer")); - vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(device ? device.getProcAddr( "vkCmdCopyBufferToImage") : instance.getProcAddr( "vkCmdCopyBufferToImage")); - vkCmdCopyImage = PFN_vkCmdCopyImage(device ? device.getProcAddr( "vkCmdCopyImage") : instance.getProcAddr( "vkCmdCopyImage")); - vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(device ? device.getProcAddr( "vkCmdCopyImageToBuffer") : instance.getProcAddr( "vkCmdCopyImageToBuffer")); - vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(device ? device.getProcAddr( "vkCmdCopyQueryPoolResults") : instance.getProcAddr( "vkCmdCopyQueryPoolResults")); - vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(device ? device.getProcAddr( "vkCmdDebugMarkerBeginEXT") : instance.getProcAddr( "vkCmdDebugMarkerBeginEXT")); - vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(device ? device.getProcAddr( "vkCmdDebugMarkerEndEXT") : instance.getProcAddr( "vkCmdDebugMarkerEndEXT")); - vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(device ? device.getProcAddr( "vkCmdDebugMarkerInsertEXT") : instance.getProcAddr( "vkCmdDebugMarkerInsertEXT")); - vkCmdDispatch = PFN_vkCmdDispatch(device ? device.getProcAddr( "vkCmdDispatch") : instance.getProcAddr( "vkCmdDispatch")); - vkCmdDispatchBase = PFN_vkCmdDispatchBase(device ? device.getProcAddr( "vkCmdDispatchBase") : instance.getProcAddr( "vkCmdDispatchBase")); - vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(device ? device.getProcAddr( "vkCmdDispatchBaseKHR") : instance.getProcAddr( "vkCmdDispatchBaseKHR")); - vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(device ? device.getProcAddr( "vkCmdDispatchIndirect") : instance.getProcAddr( "vkCmdDispatchIndirect")); - vkCmdDraw = PFN_vkCmdDraw(device ? device.getProcAddr( "vkCmdDraw") : instance.getProcAddr( "vkCmdDraw")); - vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(device ? device.getProcAddr( "vkCmdDrawIndexed") : instance.getProcAddr( "vkCmdDrawIndexed")); - vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(device ? device.getProcAddr( "vkCmdDrawIndexedIndirect") : instance.getProcAddr( "vkCmdDrawIndexedIndirect")); - vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD")); - vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR")); - vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(device ? device.getProcAddr( "vkCmdDrawIndirect") : instance.getProcAddr( "vkCmdDrawIndirect")); - vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndirectCountAMD")); - vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndirectCountKHR")); - vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdEndDebugUtilsLabelEXT")); - vkCmdEndQuery = PFN_vkCmdEndQuery(device ? device.getProcAddr( "vkCmdEndQuery") : instance.getProcAddr( "vkCmdEndQuery")); - vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(device ? device.getProcAddr( "vkCmdEndRenderPass") : instance.getProcAddr( "vkCmdEndRenderPass")); - vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(device ? device.getProcAddr( "vkCmdExecuteCommands") : instance.getProcAddr( "vkCmdExecuteCommands")); - vkCmdFillBuffer = PFN_vkCmdFillBuffer(device ? device.getProcAddr( "vkCmdFillBuffer") : instance.getProcAddr( "vkCmdFillBuffer")); - vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT")); - vkCmdNextSubpass = PFN_vkCmdNextSubpass(device ? device.getProcAddr( "vkCmdNextSubpass") : instance.getProcAddr( "vkCmdNextSubpass")); - vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(device ? device.getProcAddr( "vkCmdPipelineBarrier") : instance.getProcAddr( "vkCmdPipelineBarrier")); - vkCmdProcessCommandsNVX = PFN_vkCmdProcessCommandsNVX(device ? device.getProcAddr( "vkCmdProcessCommandsNVX") : instance.getProcAddr( "vkCmdProcessCommandsNVX")); - vkCmdPushConstants = PFN_vkCmdPushConstants(device ? device.getProcAddr( "vkCmdPushConstants") : instance.getProcAddr( "vkCmdPushConstants")); - vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(device ? device.getProcAddr( "vkCmdPushDescriptorSetKHR") : instance.getProcAddr( "vkCmdPushDescriptorSetKHR")); - vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkCmdPushDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkCmdPushDescriptorSetWithTemplateKHR")); - vkCmdReserveSpaceForCommandsNVX = PFN_vkCmdReserveSpaceForCommandsNVX(device ? device.getProcAddr( "vkCmdReserveSpaceForCommandsNVX") : instance.getProcAddr( "vkCmdReserveSpaceForCommandsNVX")); - vkCmdResetEvent = PFN_vkCmdResetEvent(device ? device.getProcAddr( "vkCmdResetEvent") : instance.getProcAddr( "vkCmdResetEvent")); - vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(device ? device.getProcAddr( "vkCmdResetQueryPool") : instance.getProcAddr( "vkCmdResetQueryPool")); - vkCmdResolveImage = PFN_vkCmdResolveImage(device ? device.getProcAddr( "vkCmdResolveImage") : instance.getProcAddr( "vkCmdResolveImage")); - vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(device ? device.getProcAddr( "vkCmdSetBlendConstants") : instance.getProcAddr( "vkCmdSetBlendConstants")); - vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(device ? device.getProcAddr( "vkCmdSetDepthBias") : instance.getProcAddr( "vkCmdSetDepthBias")); - vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(device ? device.getProcAddr( "vkCmdSetDepthBounds") : instance.getProcAddr( "vkCmdSetDepthBounds")); - vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(device ? device.getProcAddr( "vkCmdSetDeviceMask") : instance.getProcAddr( "vkCmdSetDeviceMask")); - vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(device ? device.getProcAddr( "vkCmdSetDeviceMaskKHR") : instance.getProcAddr( "vkCmdSetDeviceMaskKHR")); - vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(device ? device.getProcAddr( "vkCmdSetDiscardRectangleEXT") : instance.getProcAddr( "vkCmdSetDiscardRectangleEXT")); - vkCmdSetEvent = PFN_vkCmdSetEvent(device ? device.getProcAddr( "vkCmdSetEvent") : instance.getProcAddr( "vkCmdSetEvent")); - vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(device ? device.getProcAddr( "vkCmdSetLineWidth") : instance.getProcAddr( "vkCmdSetLineWidth")); - vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(device ? device.getProcAddr( "vkCmdSetSampleLocationsEXT") : instance.getProcAddr( "vkCmdSetSampleLocationsEXT")); - vkCmdSetScissor = PFN_vkCmdSetScissor(device ? device.getProcAddr( "vkCmdSetScissor") : instance.getProcAddr( "vkCmdSetScissor")); - vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(device ? device.getProcAddr( "vkCmdSetStencilCompareMask") : instance.getProcAddr( "vkCmdSetStencilCompareMask")); - vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(device ? device.getProcAddr( "vkCmdSetStencilReference") : instance.getProcAddr( "vkCmdSetStencilReference")); - vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(device ? device.getProcAddr( "vkCmdSetStencilWriteMask") : instance.getProcAddr( "vkCmdSetStencilWriteMask")); - vkCmdSetViewport = PFN_vkCmdSetViewport(device ? device.getProcAddr( "vkCmdSetViewport") : instance.getProcAddr( "vkCmdSetViewport")); - vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(device ? device.getProcAddr( "vkCmdSetViewportWScalingNV") : instance.getProcAddr( "vkCmdSetViewportWScalingNV")); - vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(device ? device.getProcAddr( "vkCmdUpdateBuffer") : instance.getProcAddr( "vkCmdUpdateBuffer")); - vkCmdWaitEvents = PFN_vkCmdWaitEvents(device ? device.getProcAddr( "vkCmdWaitEvents") : instance.getProcAddr( "vkCmdWaitEvents")); - vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(device ? device.getProcAddr( "vkCmdWriteBufferMarkerAMD") : instance.getProcAddr( "vkCmdWriteBufferMarkerAMD")); - vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(device ? device.getProcAddr( "vkCmdWriteTimestamp") : instance.getProcAddr( "vkCmdWriteTimestamp")); -#ifdef VK_USE_PLATFORM_ANDROID_KHR - vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR")); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - vkCreateBuffer = PFN_vkCreateBuffer(device ? device.getProcAddr( "vkCreateBuffer") : instance.getProcAddr( "vkCreateBuffer")); - vkCreateBufferView = PFN_vkCreateBufferView(device ? device.getProcAddr( "vkCreateBufferView") : instance.getProcAddr( "vkCreateBufferView")); - vkCreateCommandPool = PFN_vkCreateCommandPool(device ? device.getProcAddr( "vkCreateCommandPool") : instance.getProcAddr( "vkCreateCommandPool")); - vkCreateComputePipelines = PFN_vkCreateComputePipelines(device ? device.getProcAddr( "vkCreateComputePipelines") : instance.getProcAddr( "vkCreateComputePipelines")); - vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(instance.getProcAddr( "vkCreateDebugReportCallbackEXT")); - vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(instance.getProcAddr( "vkCreateDebugUtilsMessengerEXT")); - vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(device ? device.getProcAddr( "vkCreateDescriptorPool") : instance.getProcAddr( "vkCreateDescriptorPool")); - vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(device ? device.getProcAddr( "vkCreateDescriptorSetLayout") : instance.getProcAddr( "vkCreateDescriptorSetLayout")); - vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplate") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplate")); - vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR")); - vkCreateDevice = PFN_vkCreateDevice(device ? device.getProcAddr( "vkCreateDevice") : instance.getProcAddr( "vkCreateDevice")); - vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(device ? device.getProcAddr( "vkCreateDisplayModeKHR") : instance.getProcAddr( "vkCreateDisplayModeKHR")); - vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(instance.getProcAddr( "vkCreateDisplayPlaneSurfaceKHR")); - vkCreateEvent = PFN_vkCreateEvent(device ? device.getProcAddr( "vkCreateEvent") : instance.getProcAddr( "vkCreateEvent")); - vkCreateFence = PFN_vkCreateFence(device ? device.getProcAddr( "vkCreateFence") : instance.getProcAddr( "vkCreateFence")); - vkCreateFramebuffer = PFN_vkCreateFramebuffer(device ? device.getProcAddr( "vkCreateFramebuffer") : instance.getProcAddr( "vkCreateFramebuffer")); - vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(device ? device.getProcAddr( "vkCreateGraphicsPipelines") : instance.getProcAddr( "vkCreateGraphicsPipelines")); -#ifdef VK_USE_PLATFORM_IOS_MVK - vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(instance.getProcAddr( "vkCreateIOSSurfaceMVK")); -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - vkCreateImage = PFN_vkCreateImage(device ? device.getProcAddr( "vkCreateImage") : instance.getProcAddr( "vkCreateImage")); - vkCreateImageView = PFN_vkCreateImageView(device ? device.getProcAddr( "vkCreateImageView") : instance.getProcAddr( "vkCreateImageView")); - vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkCreateIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkCreateIndirectCommandsLayoutNVX")); - vkCreateInstance = PFN_vkCreateInstance(instance.getProcAddr( "vkCreateInstance")); -#ifdef VK_USE_PLATFORM_MACOS_MVK - vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(instance.getProcAddr( "vkCreateMacOSSurfaceMVK")); -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ -#ifdef VK_USE_PLATFORM_MIR_KHR - vkCreateMirSurfaceKHR = PFN_vkCreateMirSurfaceKHR(instance.getProcAddr( "vkCreateMirSurfaceKHR")); -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX(device ? device.getProcAddr( "vkCreateObjectTableNVX") : instance.getProcAddr( "vkCreateObjectTableNVX")); - vkCreatePipelineCache = PFN_vkCreatePipelineCache(device ? device.getProcAddr( "vkCreatePipelineCache") : instance.getProcAddr( "vkCreatePipelineCache")); - vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(device ? device.getProcAddr( "vkCreatePipelineLayout") : instance.getProcAddr( "vkCreatePipelineLayout")); - vkCreateQueryPool = PFN_vkCreateQueryPool(device ? device.getProcAddr( "vkCreateQueryPool") : instance.getProcAddr( "vkCreateQueryPool")); - vkCreateRenderPass = PFN_vkCreateRenderPass(device ? device.getProcAddr( "vkCreateRenderPass") : instance.getProcAddr( "vkCreateRenderPass")); - vkCreateSampler = PFN_vkCreateSampler(device ? device.getProcAddr( "vkCreateSampler") : instance.getProcAddr( "vkCreateSampler")); - vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(device ? device.getProcAddr( "vkCreateSamplerYcbcrConversion") : instance.getProcAddr( "vkCreateSamplerYcbcrConversion")); - vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(device ? device.getProcAddr( "vkCreateSamplerYcbcrConversionKHR") : instance.getProcAddr( "vkCreateSamplerYcbcrConversionKHR")); - vkCreateSemaphore = PFN_vkCreateSemaphore(device ? device.getProcAddr( "vkCreateSemaphore") : instance.getProcAddr( "vkCreateSemaphore")); - vkCreateShaderModule = PFN_vkCreateShaderModule(device ? device.getProcAddr( "vkCreateShaderModule") : instance.getProcAddr( "vkCreateShaderModule")); - vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(device ? device.getProcAddr( "vkCreateSharedSwapchainsKHR") : instance.getProcAddr( "vkCreateSharedSwapchainsKHR")); - vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(device ? device.getProcAddr( "vkCreateSwapchainKHR") : instance.getProcAddr( "vkCreateSwapchainKHR")); - vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(device ? device.getProcAddr( "vkCreateValidationCacheEXT") : instance.getProcAddr( "vkCreateValidationCacheEXT")); -#ifdef VK_USE_PLATFORM_VI_NN - vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(instance.getProcAddr( "vkCreateViSurfaceNN")); -#endif /*VK_USE_PLATFORM_VI_NN*/ -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(instance.getProcAddr( "vkCreateWaylandSurfaceKHR")); -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(instance.getProcAddr( "vkCreateWin32SurfaceKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_XCB_KHR - vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(instance.getProcAddr( "vkCreateXcbSurfaceKHR")); -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#ifdef VK_USE_PLATFORM_XLIB_KHR - vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(instance.getProcAddr( "vkCreateXlibSurfaceKHR")); -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectNameEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectNameEXT")); - vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectTagEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectTagEXT")); - vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(instance.getProcAddr( "vkDebugReportMessageEXT")); - vkDestroyBuffer = PFN_vkDestroyBuffer(device ? device.getProcAddr( "vkDestroyBuffer") : instance.getProcAddr( "vkDestroyBuffer")); - vkDestroyBufferView = PFN_vkDestroyBufferView(device ? device.getProcAddr( "vkDestroyBufferView") : instance.getProcAddr( "vkDestroyBufferView")); - vkDestroyCommandPool = PFN_vkDestroyCommandPool(device ? device.getProcAddr( "vkDestroyCommandPool") : instance.getProcAddr( "vkDestroyCommandPool")); - vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(instance.getProcAddr( "vkDestroyDebugReportCallbackEXT")); - vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(instance.getProcAddr( "vkDestroyDebugUtilsMessengerEXT")); - vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(device ? device.getProcAddr( "vkDestroyDescriptorPool") : instance.getProcAddr( "vkDestroyDescriptorPool")); - vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(device ? device.getProcAddr( "vkDestroyDescriptorSetLayout") : instance.getProcAddr( "vkDestroyDescriptorSetLayout")); - vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(device ? device.getProcAddr( "vkDestroyDescriptorUpdateTemplate") : instance.getProcAddr( "vkDestroyDescriptorUpdateTemplate")); - vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkDestroyDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkDestroyDescriptorUpdateTemplateKHR")); - vkDestroyDevice = PFN_vkDestroyDevice(device ? device.getProcAddr( "vkDestroyDevice") : instance.getProcAddr( "vkDestroyDevice")); - vkDestroyEvent = PFN_vkDestroyEvent(device ? device.getProcAddr( "vkDestroyEvent") : instance.getProcAddr( "vkDestroyEvent")); - vkDestroyFence = PFN_vkDestroyFence(device ? device.getProcAddr( "vkDestroyFence") : instance.getProcAddr( "vkDestroyFence")); - vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(device ? device.getProcAddr( "vkDestroyFramebuffer") : instance.getProcAddr( "vkDestroyFramebuffer")); - vkDestroyImage = PFN_vkDestroyImage(device ? device.getProcAddr( "vkDestroyImage") : instance.getProcAddr( "vkDestroyImage")); - vkDestroyImageView = PFN_vkDestroyImageView(device ? device.getProcAddr( "vkDestroyImageView") : instance.getProcAddr( "vkDestroyImageView")); - vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX")); - vkDestroyInstance = PFN_vkDestroyInstance(instance.getProcAddr( "vkDestroyInstance")); - vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX(device ? device.getProcAddr( "vkDestroyObjectTableNVX") : instance.getProcAddr( "vkDestroyObjectTableNVX")); - vkDestroyPipeline = PFN_vkDestroyPipeline(device ? device.getProcAddr( "vkDestroyPipeline") : instance.getProcAddr( "vkDestroyPipeline")); - vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(device ? device.getProcAddr( "vkDestroyPipelineCache") : instance.getProcAddr( "vkDestroyPipelineCache")); - vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(device ? device.getProcAddr( "vkDestroyPipelineLayout") : instance.getProcAddr( "vkDestroyPipelineLayout")); - vkDestroyQueryPool = PFN_vkDestroyQueryPool(device ? device.getProcAddr( "vkDestroyQueryPool") : instance.getProcAddr( "vkDestroyQueryPool")); - vkDestroyRenderPass = PFN_vkDestroyRenderPass(device ? device.getProcAddr( "vkDestroyRenderPass") : instance.getProcAddr( "vkDestroyRenderPass")); - vkDestroySampler = PFN_vkDestroySampler(device ? device.getProcAddr( "vkDestroySampler") : instance.getProcAddr( "vkDestroySampler")); - vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(device ? device.getProcAddr( "vkDestroySamplerYcbcrConversion") : instance.getProcAddr( "vkDestroySamplerYcbcrConversion")); - vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(device ? device.getProcAddr( "vkDestroySamplerYcbcrConversionKHR") : instance.getProcAddr( "vkDestroySamplerYcbcrConversionKHR")); - vkDestroySemaphore = PFN_vkDestroySemaphore(device ? device.getProcAddr( "vkDestroySemaphore") : instance.getProcAddr( "vkDestroySemaphore")); - vkDestroyShaderModule = PFN_vkDestroyShaderModule(device ? device.getProcAddr( "vkDestroyShaderModule") : instance.getProcAddr( "vkDestroyShaderModule")); - vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(instance.getProcAddr( "vkDestroySurfaceKHR")); - vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(device ? device.getProcAddr( "vkDestroySwapchainKHR") : instance.getProcAddr( "vkDestroySwapchainKHR")); - vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(device ? device.getProcAddr( "vkDestroyValidationCacheEXT") : instance.getProcAddr( "vkDestroyValidationCacheEXT")); - vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(device ? device.getProcAddr( "vkDeviceWaitIdle") : instance.getProcAddr( "vkDeviceWaitIdle")); - vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(device ? device.getProcAddr( "vkDisplayPowerControlEXT") : instance.getProcAddr( "vkDisplayPowerControlEXT")); - vkEndCommandBuffer = PFN_vkEndCommandBuffer(device ? device.getProcAddr( "vkEndCommandBuffer") : instance.getProcAddr( "vkEndCommandBuffer")); - vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(device ? device.getProcAddr( "vkEnumerateDeviceExtensionProperties") : instance.getProcAddr( "vkEnumerateDeviceExtensionProperties")); - vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(device ? device.getProcAddr( "vkEnumerateDeviceLayerProperties") : instance.getProcAddr( "vkEnumerateDeviceLayerProperties")); - vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties(instance.getProcAddr( "vkEnumerateInstanceExtensionProperties")); - vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(instance.getProcAddr( "vkEnumerateInstanceLayerProperties")); - vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(instance.getProcAddr( "vkEnumerateInstanceVersion")); - vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroups")); - vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroupsKHR")); - vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(instance.getProcAddr( "vkEnumeratePhysicalDevices")); - vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(device ? device.getProcAddr( "vkFlushMappedMemoryRanges") : instance.getProcAddr( "vkFlushMappedMemoryRanges")); - vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(device ? device.getProcAddr( "vkFreeCommandBuffers") : instance.getProcAddr( "vkFreeCommandBuffers")); - vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(device ? device.getProcAddr( "vkFreeDescriptorSets") : instance.getProcAddr( "vkFreeDescriptorSets")); - vkFreeMemory = PFN_vkFreeMemory(device ? device.getProcAddr( "vkFreeMemory") : instance.getProcAddr( "vkFreeMemory")); -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(device ? device.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID") : instance.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID")); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(device ? device.getProcAddr( "vkGetBufferMemoryRequirements") : instance.getProcAddr( "vkGetBufferMemoryRequirements")); - vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2") : instance.getProcAddr( "vkGetBufferMemoryRequirements2")); - vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2KHR") : instance.getProcAddr( "vkGetBufferMemoryRequirements2KHR")); - vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupport") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupport")); - vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR")); - vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(device ? device.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures") : instance.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures")); - vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(device ? device.getProcAddr( "vkGetDeviceGroupPeerMemoryFeaturesKHR") : instance.getProcAddr( "vkGetDeviceGroupPeerMemoryFeaturesKHR")); - vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR(device ? device.getProcAddr( "vkGetDeviceGroupPresentCapabilitiesKHR") : instance.getProcAddr( "vkGetDeviceGroupPresentCapabilitiesKHR")); - vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR(device ? device.getProcAddr( "vkGetDeviceGroupSurfacePresentModesKHR") : instance.getProcAddr( "vkGetDeviceGroupSurfacePresentModesKHR")); - vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(device ? device.getProcAddr( "vkGetDeviceMemoryCommitment") : instance.getProcAddr( "vkGetDeviceMemoryCommitment")); - vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(device ? device.getProcAddr( "vkGetDeviceProcAddr") : instance.getProcAddr( "vkGetDeviceProcAddr")); - vkGetDeviceQueue = PFN_vkGetDeviceQueue(device ? device.getProcAddr( "vkGetDeviceQueue") : instance.getProcAddr( "vkGetDeviceQueue")); - vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(device ? device.getProcAddr( "vkGetDeviceQueue2") : instance.getProcAddr( "vkGetDeviceQueue2")); - vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(device ? device.getProcAddr( "vkGetDisplayModeProperties2KHR") : instance.getProcAddr( "vkGetDisplayModeProperties2KHR")); - vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(device ? device.getProcAddr( "vkGetDisplayModePropertiesKHR") : instance.getProcAddr( "vkGetDisplayModePropertiesKHR")); - vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(device ? device.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR") : instance.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR")); - vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(device ? device.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR") : instance.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR")); - vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(device ? device.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR") : instance.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR")); - vkGetEventStatus = PFN_vkGetEventStatus(device ? device.getProcAddr( "vkGetEventStatus") : instance.getProcAddr( "vkGetEventStatus")); - vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(device ? device.getProcAddr( "vkGetFenceFdKHR") : instance.getProcAddr( "vkGetFenceFdKHR")); - vkGetFenceStatus = PFN_vkGetFenceStatus(device ? device.getProcAddr( "vkGetFenceStatus") : instance.getProcAddr( "vkGetFenceStatus")); -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(device ? device.getProcAddr( "vkGetFenceWin32HandleKHR") : instance.getProcAddr( "vkGetFenceWin32HandleKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(device ? device.getProcAddr( "vkGetImageMemoryRequirements") : instance.getProcAddr( "vkGetImageMemoryRequirements")); - vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(device ? device.getProcAddr( "vkGetImageMemoryRequirements2") : instance.getProcAddr( "vkGetImageMemoryRequirements2")); - vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageMemoryRequirements2KHR")); - vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements")); - vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2")); - vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR")); - vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(device ? device.getProcAddr( "vkGetImageSubresourceLayout") : instance.getProcAddr( "vkGetImageSubresourceLayout")); - vkGetInstanceProcAddr = PFN_vkGetInstanceProcAddr(instance.getProcAddr( "vkGetInstanceProcAddr")); -#ifdef VK_USE_PLATFORM_ANDROID_ANDROID - vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID(device ? device.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID") : instance.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID")); -#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/ - vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(device ? device.getProcAddr( "vkGetMemoryFdKHR") : instance.getProcAddr( "vkGetMemoryFdKHR")); - vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(device ? device.getProcAddr( "vkGetMemoryFdPropertiesKHR") : instance.getProcAddr( "vkGetMemoryFdPropertiesKHR")); - vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(device ? device.getProcAddr( "vkGetMemoryHostPointerPropertiesEXT") : instance.getProcAddr( "vkGetMemoryHostPointerPropertiesEXT")); -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandleKHR") : instance.getProcAddr( "vkGetMemoryWin32HandleKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_NV - vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(device ? device.getProcAddr( "vkGetMemoryWin32HandleNV") : instance.getProcAddr( "vkGetMemoryWin32HandleNV")); -#endif /*VK_USE_PLATFORM_WIN32_NV*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR") : instance.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(device ? device.getProcAddr( "vkGetPastPresentationTimingGOOGLE") : instance.getProcAddr( "vkGetPastPresentationTimingGOOGLE")); - vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); - vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); - vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR")); - vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR")); - vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties")); - vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR")); - vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties")); - vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR")); - vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalImageFormatPropertiesNV") : instance.getProcAddr( "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); - vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties")); - vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); - vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures")); - vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures2") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures2")); - vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR")); - vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties")); - vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2")); - vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR")); - vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(device ? device.getProcAddr( "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX") : instance.getProcAddr( "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX")); - vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties")); - vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2")); - vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR")); - vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties")); - vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2")); - vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR")); -#ifdef VK_USE_PLATFORM_MIR_KHR - vkGetPhysicalDeviceMirPresentationSupportKHR = PFN_vkGetPhysicalDeviceMirPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceMirPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceMirPresentationSupportKHR")); -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(device ? device.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT") : instance.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT")); - vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR(device ? device.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR") : instance.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR")); - vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties") : instance.getProcAddr( "vkGetPhysicalDeviceProperties")); - vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceProperties2")); - vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceProperties2KHR")); - vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties")); - vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2")); - vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR")); - vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties")); - vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2")); - vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); - vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); - vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR")); - vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); - vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR")); - vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR")); - vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR")); - vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR")); -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_XCB_KHR - vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR")); -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#ifdef VK_USE_PLATFORM_XLIB_KHR - vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR")); -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(device ? device.getProcAddr( "vkGetPipelineCacheData") : instance.getProcAddr( "vkGetPipelineCacheData")); - vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(device ? device.getProcAddr( "vkGetQueryPoolResults") : instance.getProcAddr( "vkGetQueryPoolResults")); -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV - vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(device ? device.getProcAddr( "vkGetRandROutputDisplayEXT") : instance.getProcAddr( "vkGetRandROutputDisplayEXT")); -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/ - vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(device ? device.getProcAddr( "vkGetRefreshCycleDurationGOOGLE") : instance.getProcAddr( "vkGetRefreshCycleDurationGOOGLE")); - vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(device ? device.getProcAddr( "vkGetRenderAreaGranularity") : instance.getProcAddr( "vkGetRenderAreaGranularity")); - vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(device ? device.getProcAddr( "vkGetSemaphoreFdKHR") : instance.getProcAddr( "vkGetSemaphoreFdKHR")); -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkGetSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkGetSemaphoreWin32HandleKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(device ? device.getProcAddr( "vkGetShaderInfoAMD") : instance.getProcAddr( "vkGetShaderInfoAMD")); - vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(device ? device.getProcAddr( "vkGetSwapchainCounterEXT") : instance.getProcAddr( "vkGetSwapchainCounterEXT")); - vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(device ? device.getProcAddr( "vkGetSwapchainImagesKHR") : instance.getProcAddr( "vkGetSwapchainImagesKHR")); - vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(device ? device.getProcAddr( "vkGetSwapchainStatusKHR") : instance.getProcAddr( "vkGetSwapchainStatusKHR")); - vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(device ? device.getProcAddr( "vkGetValidationCacheDataEXT") : instance.getProcAddr( "vkGetValidationCacheDataEXT")); - vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(device ? device.getProcAddr( "vkImportFenceFdKHR") : instance.getProcAddr( "vkImportFenceFdKHR")); -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(device ? device.getProcAddr( "vkImportFenceWin32HandleKHR") : instance.getProcAddr( "vkImportFenceWin32HandleKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(device ? device.getProcAddr( "vkImportSemaphoreFdKHR") : instance.getProcAddr( "vkImportSemaphoreFdKHR")); -#ifdef VK_USE_PLATFORM_WIN32_KHR - vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkImportSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkImportSemaphoreWin32HandleKHR")); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(device ? device.getProcAddr( "vkInvalidateMappedMemoryRanges") : instance.getProcAddr( "vkInvalidateMappedMemoryRanges")); - vkMapMemory = PFN_vkMapMemory(device ? device.getProcAddr( "vkMapMemory") : instance.getProcAddr( "vkMapMemory")); - vkMergePipelineCaches = PFN_vkMergePipelineCaches(device ? device.getProcAddr( "vkMergePipelineCaches") : instance.getProcAddr( "vkMergePipelineCaches")); - vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(device ? device.getProcAddr( "vkMergeValidationCachesEXT") : instance.getProcAddr( "vkMergeValidationCachesEXT")); - vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT")); - vkQueueBindSparse = PFN_vkQueueBindSparse(device ? device.getProcAddr( "vkQueueBindSparse") : instance.getProcAddr( "vkQueueBindSparse")); - vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueEndDebugUtilsLabelEXT")); - vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueInsertDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueInsertDebugUtilsLabelEXT")); - vkQueuePresentKHR = PFN_vkQueuePresentKHR(device ? device.getProcAddr( "vkQueuePresentKHR") : instance.getProcAddr( "vkQueuePresentKHR")); - vkQueueSubmit = PFN_vkQueueSubmit(device ? device.getProcAddr( "vkQueueSubmit") : instance.getProcAddr( "vkQueueSubmit")); - vkQueueWaitIdle = PFN_vkQueueWaitIdle(device ? device.getProcAddr( "vkQueueWaitIdle") : instance.getProcAddr( "vkQueueWaitIdle")); - vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(device ? device.getProcAddr( "vkRegisterDeviceEventEXT") : instance.getProcAddr( "vkRegisterDeviceEventEXT")); - vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(device ? device.getProcAddr( "vkRegisterDisplayEventEXT") : instance.getProcAddr( "vkRegisterDisplayEventEXT")); - vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX(device ? device.getProcAddr( "vkRegisterObjectsNVX") : instance.getProcAddr( "vkRegisterObjectsNVX")); - vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(device ? device.getProcAddr( "vkReleaseDisplayEXT") : instance.getProcAddr( "vkReleaseDisplayEXT")); - vkResetCommandBuffer = PFN_vkResetCommandBuffer(device ? device.getProcAddr( "vkResetCommandBuffer") : instance.getProcAddr( "vkResetCommandBuffer")); - vkResetCommandPool = PFN_vkResetCommandPool(device ? device.getProcAddr( "vkResetCommandPool") : instance.getProcAddr( "vkResetCommandPool")); - vkResetDescriptorPool = PFN_vkResetDescriptorPool(device ? device.getProcAddr( "vkResetDescriptorPool") : instance.getProcAddr( "vkResetDescriptorPool")); - vkResetEvent = PFN_vkResetEvent(device ? device.getProcAddr( "vkResetEvent") : instance.getProcAddr( "vkResetEvent")); - vkResetFences = PFN_vkResetFences(device ? device.getProcAddr( "vkResetFences") : instance.getProcAddr( "vkResetFences")); - vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectNameEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectNameEXT")); - vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectTagEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectTagEXT")); - vkSetEvent = PFN_vkSetEvent(device ? device.getProcAddr( "vkSetEvent") : instance.getProcAddr( "vkSetEvent")); - vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(device ? device.getProcAddr( "vkSetHdrMetadataEXT") : instance.getProcAddr( "vkSetHdrMetadataEXT")); - vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(instance.getProcAddr( "vkSubmitDebugUtilsMessageEXT")); - vkTrimCommandPool = PFN_vkTrimCommandPool(device ? device.getProcAddr( "vkTrimCommandPool") : instance.getProcAddr( "vkTrimCommandPool")); - vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(device ? device.getProcAddr( "vkTrimCommandPoolKHR") : instance.getProcAddr( "vkTrimCommandPoolKHR")); - vkUnmapMemory = PFN_vkUnmapMemory(device ? device.getProcAddr( "vkUnmapMemory") : instance.getProcAddr( "vkUnmapMemory")); - vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX(device ? device.getProcAddr( "vkUnregisterObjectsNVX") : instance.getProcAddr( "vkUnregisterObjectsNVX")); - vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplate") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplate")); - vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR")); - vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(device ? device.getProcAddr( "vkUpdateDescriptorSets") : instance.getProcAddr( "vkUpdateDescriptorSets")); - vkWaitForFences = PFN_vkWaitForFences(device ? device.getProcAddr( "vkWaitForFences") : instance.getProcAddr( "vkWaitForFences")); - } - }; -} // namespace VULKAN_HPP_NAMESPACE - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_android.h b/generator/Vulkan-Headers/include/vulkan/vulkan_android.h deleted file mode 100644 index 07aaeda..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_android.h +++ /dev/null @@ -1,126 +0,0 @@ -#ifndef VULKAN_ANDROID_H_ -#define VULKAN_ANDROID_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_KHR_android_surface 1 -struct ANativeWindow; - -#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 -#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" - -typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; - -typedef struct VkAndroidSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkAndroidSurfaceCreateFlagsKHR flags; - struct ANativeWindow* window; -} VkAndroidSurfaceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( - VkInstance instance, - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#define VK_ANDROID_external_memory_android_hardware_buffer 1 -struct AHardwareBuffer; - -#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3 -#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" - -typedef struct VkAndroidHardwareBufferUsageANDROID { - VkStructureType sType; - void* pNext; - uint64_t androidHardwareBufferUsage; -} VkAndroidHardwareBufferUsageANDROID; - -typedef struct VkAndroidHardwareBufferPropertiesANDROID { - VkStructureType sType; - void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeBits; -} VkAndroidHardwareBufferPropertiesANDROID; - -typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { - VkStructureType sType; - void* pNext; - VkFormat format; - uint64_t externalFormat; - VkFormatFeatureFlags formatFeatures; - VkComponentMapping samplerYcbcrConversionComponents; - VkSamplerYcbcrModelConversion suggestedYcbcrModel; - VkSamplerYcbcrRange suggestedYcbcrRange; - VkChromaLocation suggestedXChromaOffset; - VkChromaLocation suggestedYChromaOffset; -} VkAndroidHardwareBufferFormatPropertiesANDROID; - -typedef struct VkImportAndroidHardwareBufferInfoANDROID { - VkStructureType sType; - const void* pNext; - struct AHardwareBuffer* buffer; -} VkImportAndroidHardwareBufferInfoANDROID; - -typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkMemoryGetAndroidHardwareBufferInfoANDROID; - -typedef struct VkExternalFormatANDROID { - VkStructureType sType; - void* pNext; - uint64_t externalFormat; -} VkExternalFormatANDROID; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( - VkDevice device, - const struct AHardwareBuffer* buffer, - VkAndroidHardwareBufferPropertiesANDROID* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( - VkDevice device, - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, - struct AHardwareBuffer** pBuffer); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_core.h b/generator/Vulkan-Headers/include/vulkan/vulkan_core.h deleted file mode 100644 index 93aa65b..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_core.h +++ /dev/null @@ -1,7586 +0,0 @@ -#ifndef VULKAN_CORE_H_ -#define VULKAN_CORE_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_VERSION_1_0 1 -#include "vk_platform.h" - -#define VK_MAKE_VERSION(major, minor, patch) \ - (((major) << 22) | ((minor) << 12) | (patch)) - -// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. -//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 - -// Vulkan 1.0 version number -#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 - -#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) -#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) -#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) -// Version of this file -#define VK_HEADER_VERSION 79 - - -#define VK_NULL_HANDLE 0 - - - -#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; - - -#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) -#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; -#else - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; -#endif -#endif - - - -typedef uint32_t VkFlags; -typedef uint32_t VkBool32; -typedef uint64_t VkDeviceSize; -typedef uint32_t VkSampleMask; - -VK_DEFINE_HANDLE(VkInstance) -VK_DEFINE_HANDLE(VkPhysicalDevice) -VK_DEFINE_HANDLE(VkDevice) -VK_DEFINE_HANDLE(VkQueue) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) -VK_DEFINE_HANDLE(VkCommandBuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) - -#define VK_LOD_CLAMP_NONE 1000.0f -#define VK_REMAINING_MIP_LEVELS (~0U) -#define VK_REMAINING_ARRAY_LAYERS (~0U) -#define VK_WHOLE_SIZE (~0ULL) -#define VK_ATTACHMENT_UNUSED (~0U) -#define VK_TRUE 1 -#define VK_FALSE 0 -#define VK_QUEUE_FAMILY_IGNORED (~0U) -#define VK_SUBPASS_EXTERNAL (~0U) -#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 -#define VK_UUID_SIZE 16 -#define VK_MAX_MEMORY_TYPES 32 -#define VK_MAX_MEMORY_HEAPS 16 -#define VK_MAX_EXTENSION_NAME_SIZE 256 -#define VK_MAX_DESCRIPTION_SIZE 256 - - -typedef enum VkPipelineCacheHeaderVersion { - VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, - VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, - VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, - VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), - VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheHeaderVersion; - -typedef enum VkResult { - VK_SUCCESS = 0, - VK_NOT_READY = 1, - VK_TIMEOUT = 2, - VK_EVENT_SET = 3, - VK_EVENT_RESET = 4, - VK_INCOMPLETE = 5, - VK_ERROR_OUT_OF_HOST_MEMORY = -1, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, - VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_DEVICE_LOST = -4, - VK_ERROR_MEMORY_MAP_FAILED = -5, - VK_ERROR_LAYER_NOT_PRESENT = -6, - VK_ERROR_EXTENSION_NOT_PRESENT = -7, - VK_ERROR_FEATURE_NOT_PRESENT = -8, - VK_ERROR_INCOMPATIBLE_DRIVER = -9, - VK_ERROR_TOO_MANY_OBJECTS = -10, - VK_ERROR_FORMAT_NOT_SUPPORTED = -11, - VK_ERROR_FRAGMENTED_POOL = -12, - VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, - VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, - VK_ERROR_SURFACE_LOST_KHR = -1000000000, - VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, - VK_SUBOPTIMAL_KHR = 1000001003, - VK_ERROR_OUT_OF_DATE_KHR = -1000001004, - VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, - VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, - VK_ERROR_INVALID_SHADER_NV = -1000012000, - VK_ERROR_FRAGMENTATION_EXT = -1000161000, - VK_ERROR_NOT_PERMITTED_EXT = -1000174001, - VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, - VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, - VK_RESULT_END_RANGE = VK_INCOMPLETE, - VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), - VK_RESULT_MAX_ENUM = 0x7FFFFFFF -} VkResult; - -typedef enum VkStructureType { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, - VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, - VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, - VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000, - VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, - VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, - VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, - VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, - VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, - VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, - VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, - VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, - VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, - VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, - VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, - VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, - VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, - VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, - VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, - VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, - VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, - VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, - VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, - VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, - VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, - VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, - VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, - VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, - VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, - VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, - VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, - VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, - VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, - VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, - VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, - VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, - VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, - VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, - VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, - VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, - VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, - VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, - VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, - VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, - VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, - VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, - VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, - VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, - VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, - VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, - VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, - VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, - VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, - VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, - VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, - VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, - VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, - VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, - VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, - VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, - VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, - VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), - VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkStructureType; - -typedef enum VkSystemAllocationScope { - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, - VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, - VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, - VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, - VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, - VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), - VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF -} VkSystemAllocationScope; - -typedef enum VkInternalAllocationType { - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, - VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, - VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, - VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), - VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkInternalAllocationType; - -typedef enum VkFormat { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM_PACK8 = 1, - VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, - VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, - VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, - VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, - VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, - VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, - VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, - VK_FORMAT_R8_UNORM = 9, - VK_FORMAT_R8_SNORM = 10, - VK_FORMAT_R8_USCALED = 11, - VK_FORMAT_R8_SSCALED = 12, - VK_FORMAT_R8_UINT = 13, - VK_FORMAT_R8_SINT = 14, - VK_FORMAT_R8_SRGB = 15, - VK_FORMAT_R8G8_UNORM = 16, - VK_FORMAT_R8G8_SNORM = 17, - VK_FORMAT_R8G8_USCALED = 18, - VK_FORMAT_R8G8_SSCALED = 19, - VK_FORMAT_R8G8_UINT = 20, - VK_FORMAT_R8G8_SINT = 21, - VK_FORMAT_R8G8_SRGB = 22, - VK_FORMAT_R8G8B8_UNORM = 23, - VK_FORMAT_R8G8B8_SNORM = 24, - VK_FORMAT_R8G8B8_USCALED = 25, - VK_FORMAT_R8G8B8_SSCALED = 26, - VK_FORMAT_R8G8B8_UINT = 27, - VK_FORMAT_R8G8B8_SINT = 28, - VK_FORMAT_R8G8B8_SRGB = 29, - VK_FORMAT_B8G8R8_UNORM = 30, - VK_FORMAT_B8G8R8_SNORM = 31, - VK_FORMAT_B8G8R8_USCALED = 32, - VK_FORMAT_B8G8R8_SSCALED = 33, - VK_FORMAT_B8G8R8_UINT = 34, - VK_FORMAT_B8G8R8_SINT = 35, - VK_FORMAT_B8G8R8_SRGB = 36, - VK_FORMAT_R8G8B8A8_UNORM = 37, - VK_FORMAT_R8G8B8A8_SNORM = 38, - VK_FORMAT_R8G8B8A8_USCALED = 39, - VK_FORMAT_R8G8B8A8_SSCALED = 40, - VK_FORMAT_R8G8B8A8_UINT = 41, - VK_FORMAT_R8G8B8A8_SINT = 42, - VK_FORMAT_R8G8B8A8_SRGB = 43, - VK_FORMAT_B8G8R8A8_UNORM = 44, - VK_FORMAT_B8G8R8A8_SNORM = 45, - VK_FORMAT_B8G8R8A8_USCALED = 46, - VK_FORMAT_B8G8R8A8_SSCALED = 47, - VK_FORMAT_B8G8R8A8_UINT = 48, - VK_FORMAT_B8G8R8A8_SINT = 49, - VK_FORMAT_B8G8R8A8_SRGB = 50, - VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, - VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, - VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, - VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, - VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, - VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, - VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, - VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, - VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, - VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, - VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, - VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, - VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, - VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, - VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, - VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, - VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, - VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, - VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, - VK_FORMAT_R16_UNORM = 70, - VK_FORMAT_R16_SNORM = 71, - VK_FORMAT_R16_USCALED = 72, - VK_FORMAT_R16_SSCALED = 73, - VK_FORMAT_R16_UINT = 74, - VK_FORMAT_R16_SINT = 75, - VK_FORMAT_R16_SFLOAT = 76, - VK_FORMAT_R16G16_UNORM = 77, - VK_FORMAT_R16G16_SNORM = 78, - VK_FORMAT_R16G16_USCALED = 79, - VK_FORMAT_R16G16_SSCALED = 80, - VK_FORMAT_R16G16_UINT = 81, - VK_FORMAT_R16G16_SINT = 82, - VK_FORMAT_R16G16_SFLOAT = 83, - VK_FORMAT_R16G16B16_UNORM = 84, - VK_FORMAT_R16G16B16_SNORM = 85, - VK_FORMAT_R16G16B16_USCALED = 86, - VK_FORMAT_R16G16B16_SSCALED = 87, - VK_FORMAT_R16G16B16_UINT = 88, - VK_FORMAT_R16G16B16_SINT = 89, - VK_FORMAT_R16G16B16_SFLOAT = 90, - VK_FORMAT_R16G16B16A16_UNORM = 91, - VK_FORMAT_R16G16B16A16_SNORM = 92, - VK_FORMAT_R16G16B16A16_USCALED = 93, - VK_FORMAT_R16G16B16A16_SSCALED = 94, - VK_FORMAT_R16G16B16A16_UINT = 95, - VK_FORMAT_R16G16B16A16_SINT = 96, - VK_FORMAT_R16G16B16A16_SFLOAT = 97, - VK_FORMAT_R32_UINT = 98, - VK_FORMAT_R32_SINT = 99, - VK_FORMAT_R32_SFLOAT = 100, - VK_FORMAT_R32G32_UINT = 101, - VK_FORMAT_R32G32_SINT = 102, - VK_FORMAT_R32G32_SFLOAT = 103, - VK_FORMAT_R32G32B32_UINT = 104, - VK_FORMAT_R32G32B32_SINT = 105, - VK_FORMAT_R32G32B32_SFLOAT = 106, - VK_FORMAT_R32G32B32A32_UINT = 107, - VK_FORMAT_R32G32B32A32_SINT = 108, - VK_FORMAT_R32G32B32A32_SFLOAT = 109, - VK_FORMAT_R64_UINT = 110, - VK_FORMAT_R64_SINT = 111, - VK_FORMAT_R64_SFLOAT = 112, - VK_FORMAT_R64G64_UINT = 113, - VK_FORMAT_R64G64_SINT = 114, - VK_FORMAT_R64G64_SFLOAT = 115, - VK_FORMAT_R64G64B64_UINT = 116, - VK_FORMAT_R64G64B64_SINT = 117, - VK_FORMAT_R64G64B64_SFLOAT = 118, - VK_FORMAT_R64G64B64A64_UINT = 119, - VK_FORMAT_R64G64B64A64_SINT = 120, - VK_FORMAT_R64G64B64A64_SFLOAT = 121, - VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, - VK_FORMAT_D16_UNORM = 124, - VK_FORMAT_X8_D24_UNORM_PACK32 = 125, - VK_FORMAT_D32_SFLOAT = 126, - VK_FORMAT_S8_UINT = 127, - VK_FORMAT_D16_UNORM_S8_UINT = 128, - VK_FORMAT_D24_UNORM_S8_UINT = 129, - VK_FORMAT_D32_SFLOAT_S8_UINT = 130, - VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, - VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, - VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, - VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, - VK_FORMAT_BC2_UNORM_BLOCK = 135, - VK_FORMAT_BC2_SRGB_BLOCK = 136, - VK_FORMAT_BC3_UNORM_BLOCK = 137, - VK_FORMAT_BC3_SRGB_BLOCK = 138, - VK_FORMAT_BC4_UNORM_BLOCK = 139, - VK_FORMAT_BC4_SNORM_BLOCK = 140, - VK_FORMAT_BC5_UNORM_BLOCK = 141, - VK_FORMAT_BC5_SNORM_BLOCK = 142, - VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, - VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, - VK_FORMAT_BC7_UNORM_BLOCK = 145, - VK_FORMAT_BC7_SRGB_BLOCK = 146, - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, - VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, - VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, - VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, - VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, - VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, - VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, - VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, - VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, - VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, - VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, - VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, - VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, - VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, - VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, - VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, - VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, - VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, - VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, - VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, - VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, - VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, - VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, - VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, - VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, - VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, - VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, - VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, - VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, - VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, - VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, - VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, - VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, - VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, - VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, - VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, - VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, - VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, - VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, - VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, - VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, - VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, - VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, - VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, - VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, - VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, - VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, - VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, - VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, - VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, - VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, - VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), - VK_FORMAT_MAX_ENUM = 0x7FFFFFFF -} VkFormat; - -typedef enum VkImageType { - VK_IMAGE_TYPE_1D = 0, - VK_IMAGE_TYPE_2D = 1, - VK_IMAGE_TYPE_3D = 2, - VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, - VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, - VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), - VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageType; - -typedef enum VkImageTiling { - VK_IMAGE_TILING_OPTIMAL = 0, - VK_IMAGE_TILING_LINEAR = 1, - VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, - VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), - VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF -} VkImageTiling; - -typedef enum VkPhysicalDeviceType { - VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, - VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, - VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, - VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, - VK_PHYSICAL_DEVICE_TYPE_CPU = 4, - VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, - VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, - VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), - VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkPhysicalDeviceType; - -typedef enum VkQueryType { - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_TIMESTAMP = 2, - VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, - VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, - VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), - VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkQueryType; - -typedef enum VkSharingMode { - VK_SHARING_MODE_EXCLUSIVE = 0, - VK_SHARING_MODE_CONCURRENT = 1, - VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, - VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, - VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), - VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSharingMode; - -typedef enum VkImageLayout { - VK_IMAGE_LAYOUT_UNDEFINED = 0, - VK_IMAGE_LAYOUT_GENERAL = 1, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, - VK_IMAGE_LAYOUT_PREINITIALIZED = 8, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, - VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, - VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, - VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, - VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - -typedef enum VkImageViewType { - VK_IMAGE_VIEW_TYPE_1D = 0, - VK_IMAGE_VIEW_TYPE_2D = 1, - VK_IMAGE_VIEW_TYPE_3D = 2, - VK_IMAGE_VIEW_TYPE_CUBE = 3, - VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, - VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, - VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, - VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, - VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), - VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageViewType; - -typedef enum VkComponentSwizzle { - VK_COMPONENT_SWIZZLE_IDENTITY = 0, - VK_COMPONENT_SWIZZLE_ZERO = 1, - VK_COMPONENT_SWIZZLE_ONE = 2, - VK_COMPONENT_SWIZZLE_R = 3, - VK_COMPONENT_SWIZZLE_G = 4, - VK_COMPONENT_SWIZZLE_B = 5, - VK_COMPONENT_SWIZZLE_A = 6, - VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, - VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, - VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), - VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF -} VkComponentSwizzle; - -typedef enum VkVertexInputRate { - VK_VERTEX_INPUT_RATE_VERTEX = 0, - VK_VERTEX_INPUT_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, - VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, - VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), - VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF -} VkVertexInputRate; - -typedef enum VkPrimitiveTopology { - VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, - VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF -} VkPrimitiveTopology; - -typedef enum VkPolygonMode { - VK_POLYGON_MODE_FILL = 0, - VK_POLYGON_MODE_LINE = 1, - VK_POLYGON_MODE_POINT = 2, - VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, - VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, - VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, - VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), - VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF -} VkPolygonMode; - -typedef enum VkFrontFace { - VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, - VK_FRONT_FACE_CLOCKWISE = 1, - VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, - VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, - VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), - VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF -} VkFrontFace; - -typedef enum VkCompareOp { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_OR_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_OR_EQUAL = 6, - VK_COMPARE_OP_ALWAYS = 7, - VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, - VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, - VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - -typedef enum VkStencilOp { - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, - VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, - VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, - VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, - VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, - VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), - VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF -} VkStencilOp; - -typedef enum VkLogicOp { - VK_LOGIC_OP_CLEAR = 0, - VK_LOGIC_OP_AND = 1, - VK_LOGIC_OP_AND_REVERSE = 2, - VK_LOGIC_OP_COPY = 3, - VK_LOGIC_OP_AND_INVERTED = 4, - VK_LOGIC_OP_NO_OP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIVALENT = 9, - VK_LOGIC_OP_INVERT = 10, - VK_LOGIC_OP_OR_REVERSE = 11, - VK_LOGIC_OP_COPY_INVERTED = 12, - VK_LOGIC_OP_OR_INVERTED = 13, - VK_LOGIC_OP_NAND = 14, - VK_LOGIC_OP_SET = 15, - VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, - VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, - VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), - VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF -} VkLogicOp; - -typedef enum VkBlendFactor { - VK_BLEND_FACTOR_ZERO = 0, - VK_BLEND_FACTOR_ONE = 1, - VK_BLEND_FACTOR_SRC_COLOR = 2, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_FACTOR_DST_COLOR = 4, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, - VK_BLEND_FACTOR_SRC_ALPHA = 6, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_FACTOR_DST_ALPHA = 8, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, - VK_BLEND_FACTOR_CONSTANT_COLOR = 10, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, - VK_BLEND_FACTOR_SRC1_COLOR = 15, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_FACTOR_SRC1_ALPHA = 17, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, - VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, - VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), - VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF -} VkBlendFactor; - -typedef enum VkBlendOp { - VK_BLEND_OP_ADD = 0, - VK_BLEND_OP_SUBTRACT = 1, - VK_BLEND_OP_REVERSE_SUBTRACT = 2, - VK_BLEND_OP_MIN = 3, - VK_BLEND_OP_MAX = 4, - VK_BLEND_OP_ZERO_EXT = 1000148000, - VK_BLEND_OP_SRC_EXT = 1000148001, - VK_BLEND_OP_DST_EXT = 1000148002, - VK_BLEND_OP_SRC_OVER_EXT = 1000148003, - VK_BLEND_OP_DST_OVER_EXT = 1000148004, - VK_BLEND_OP_SRC_IN_EXT = 1000148005, - VK_BLEND_OP_DST_IN_EXT = 1000148006, - VK_BLEND_OP_SRC_OUT_EXT = 1000148007, - VK_BLEND_OP_DST_OUT_EXT = 1000148008, - VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, - VK_BLEND_OP_DST_ATOP_EXT = 1000148010, - VK_BLEND_OP_XOR_EXT = 1000148011, - VK_BLEND_OP_MULTIPLY_EXT = 1000148012, - VK_BLEND_OP_SCREEN_EXT = 1000148013, - VK_BLEND_OP_OVERLAY_EXT = 1000148014, - VK_BLEND_OP_DARKEN_EXT = 1000148015, - VK_BLEND_OP_LIGHTEN_EXT = 1000148016, - VK_BLEND_OP_COLORDODGE_EXT = 1000148017, - VK_BLEND_OP_COLORBURN_EXT = 1000148018, - VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, - VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, - VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, - VK_BLEND_OP_EXCLUSION_EXT = 1000148022, - VK_BLEND_OP_INVERT_EXT = 1000148023, - VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, - VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, - VK_BLEND_OP_LINEARBURN_EXT = 1000148026, - VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, - VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, - VK_BLEND_OP_PINLIGHT_EXT = 1000148029, - VK_BLEND_OP_HARDMIX_EXT = 1000148030, - VK_BLEND_OP_HSL_HUE_EXT = 1000148031, - VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, - VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, - VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, - VK_BLEND_OP_PLUS_EXT = 1000148035, - VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, - VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, - VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, - VK_BLEND_OP_MINUS_EXT = 1000148039, - VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, - VK_BLEND_OP_CONTRAST_EXT = 1000148041, - VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, - VK_BLEND_OP_RED_EXT = 1000148043, - VK_BLEND_OP_GREEN_EXT = 1000148044, - VK_BLEND_OP_BLUE_EXT = 1000148045, - VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, - VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, - VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), - VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF -} VkBlendOp; - -typedef enum VkDynamicState { - VK_DYNAMIC_STATE_VIEWPORT = 0, - VK_DYNAMIC_STATE_SCISSOR = 1, - VK_DYNAMIC_STATE_LINE_WIDTH = 2, - VK_DYNAMIC_STATE_DEPTH_BIAS = 3, - VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, - VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, - VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, - VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, - VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, - VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, - VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, - VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, - VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, - VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), - VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF -} VkDynamicState; - -typedef enum VkFilter { - VK_FILTER_NEAREST = 0, - VK_FILTER_LINEAR = 1, - VK_FILTER_CUBIC_IMG = 1000015000, - VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, - VK_FILTER_END_RANGE = VK_FILTER_LINEAR, - VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), - VK_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkFilter; - -typedef enum VkSamplerMipmapMode { - VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, - VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, - VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, - VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, - VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), - VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerMipmapMode; - -typedef enum VkSamplerAddressMode { - VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, - VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, - VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, - VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), - VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerAddressMode; - -typedef enum VkBorderColor { - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, - VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, - VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, - VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, - VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, - VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, - VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, - VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, - VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum VkDescriptorType { - VK_DESCRIPTOR_TYPE_SAMPLER = 0, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, - VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, - VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, - VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), - VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorType; - -typedef enum VkAttachmentLoadOp { - VK_ATTACHMENT_LOAD_OP_LOAD = 0, - VK_ATTACHMENT_LOAD_OP_CLEAR = 1, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, - VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentLoadOp; - -typedef enum VkAttachmentStoreOp { - VK_ATTACHMENT_STORE_OP_STORE = 0, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, - VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, - VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), - VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentStoreOp; - -typedef enum VkPipelineBindPoint { - VK_PIPELINE_BIND_POINT_GRAPHICS = 0, - VK_PIPELINE_BIND_POINT_COMPUTE = 1, - VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, - VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, - VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum VkCommandBufferLevel { - VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, - VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, - VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, - VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, - VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), - VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferLevel; - -typedef enum VkIndexType { - VK_INDEX_TYPE_UINT16 = 0, - VK_INDEX_TYPE_UINT32 = 1, - VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, - VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, - VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - -typedef enum VkSubpassContents { - VK_SUBPASS_CONTENTS_INLINE = 0, - VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, - VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, - VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, - VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), - VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassContents; - -typedef enum VkObjectType { - VK_OBJECT_TYPE_UNKNOWN = 0, - VK_OBJECT_TYPE_INSTANCE = 1, - VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, - VK_OBJECT_TYPE_DEVICE = 3, - VK_OBJECT_TYPE_QUEUE = 4, - VK_OBJECT_TYPE_SEMAPHORE = 5, - VK_OBJECT_TYPE_COMMAND_BUFFER = 6, - VK_OBJECT_TYPE_FENCE = 7, - VK_OBJECT_TYPE_DEVICE_MEMORY = 8, - VK_OBJECT_TYPE_BUFFER = 9, - VK_OBJECT_TYPE_IMAGE = 10, - VK_OBJECT_TYPE_EVENT = 11, - VK_OBJECT_TYPE_QUERY_POOL = 12, - VK_OBJECT_TYPE_BUFFER_VIEW = 13, - VK_OBJECT_TYPE_IMAGE_VIEW = 14, - VK_OBJECT_TYPE_SHADER_MODULE = 15, - VK_OBJECT_TYPE_PIPELINE_CACHE = 16, - VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, - VK_OBJECT_TYPE_RENDER_PASS = 18, - VK_OBJECT_TYPE_PIPELINE = 19, - VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, - VK_OBJECT_TYPE_SAMPLER = 21, - VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, - VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, - VK_OBJECT_TYPE_FRAMEBUFFER = 24, - VK_OBJECT_TYPE_COMMAND_POOL = 25, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, - VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, - VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, - VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, - VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, - VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, - VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, - VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, - VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, - VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, - VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, - VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL, - VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1), - VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkObjectType; - -typedef enum VkVendorId { - VK_VENDOR_ID_VIV = 0x10001, - VK_VENDOR_ID_VSI = 0x10002, - VK_VENDOR_ID_KAZAN = 0x10003, - VK_VENDOR_ID_BEGIN_RANGE = VK_VENDOR_ID_VIV, - VK_VENDOR_ID_END_RANGE = VK_VENDOR_ID_KAZAN, - VK_VENDOR_ID_RANGE_SIZE = (VK_VENDOR_ID_KAZAN - VK_VENDOR_ID_VIV + 1), - VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF -} VkVendorId; - -typedef VkFlags VkInstanceCreateFlags; - -typedef enum VkFormatFeatureFlagBits { - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, - VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, - VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, - VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, - VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, - VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, - VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, - VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFormatFeatureFlagBits; -typedef VkFlags VkFormatFeatureFlags; - -typedef enum VkImageUsageFlagBits { - VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, - VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, - VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageUsageFlagBits; -typedef VkFlags VkImageUsageFlags; - -typedef enum VkImageCreateFlagBits { - VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, - VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, - VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, - VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, - VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, - VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, - VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, - VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; - -typedef enum VkSampleCountFlagBits { - VK_SAMPLE_COUNT_1_BIT = 0x00000001, - VK_SAMPLE_COUNT_2_BIT = 0x00000002, - VK_SAMPLE_COUNT_4_BIT = 0x00000004, - VK_SAMPLE_COUNT_8_BIT = 0x00000008, - VK_SAMPLE_COUNT_16_BIT = 0x00000010, - VK_SAMPLE_COUNT_32_BIT = 0x00000020, - VK_SAMPLE_COUNT_64_BIT = 0x00000040, - VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSampleCountFlagBits; -typedef VkFlags VkSampleCountFlags; - -typedef enum VkQueueFlagBits { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, - VK_QUEUE_COMPUTE_BIT = 0x00000002, - VK_QUEUE_TRANSFER_BIT = 0x00000004, - VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, - VK_QUEUE_PROTECTED_BIT = 0x00000010, - VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueueFlagBits; -typedef VkFlags VkQueueFlags; - -typedef enum VkMemoryPropertyFlagBits { - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, - VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, - VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryPropertyFlagBits; -typedef VkFlags VkMemoryPropertyFlags; - -typedef enum VkMemoryHeapFlagBits { - VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, - VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryHeapFlagBits; -typedef VkFlags VkMemoryHeapFlags; -typedef VkFlags VkDeviceCreateFlags; - -typedef enum VkDeviceQueueCreateFlagBits { - VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, - VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDeviceQueueCreateFlagBits; -typedef VkFlags VkDeviceQueueCreateFlags; - -typedef enum VkPipelineStageFlagBits { - VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, - VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, - VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, - VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, - VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, - VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, - VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineStageFlagBits; -typedef VkFlags VkPipelineStageFlags; -typedef VkFlags VkMemoryMapFlags; - -typedef enum VkImageAspectFlagBits { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, - VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, - VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, - VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, - VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, - VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, - VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, - VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - -typedef enum VkSparseImageFormatFlagBits { - VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, - VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, - VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, - VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseImageFormatFlagBits; -typedef VkFlags VkSparseImageFormatFlags; - -typedef enum VkSparseMemoryBindFlagBits { - VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, - VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseMemoryBindFlagBits; -typedef VkFlags VkSparseMemoryBindFlags; - -typedef enum VkFenceCreateFlagBits { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, - VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceCreateFlagBits; -typedef VkFlags VkFenceCreateFlags; -typedef VkFlags VkSemaphoreCreateFlags; -typedef VkFlags VkEventCreateFlags; -typedef VkFlags VkQueryPoolCreateFlags; - -typedef enum VkQueryPipelineStatisticFlagBits { - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, - VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, - VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, - VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, - VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryPipelineStatisticFlagBits; -typedef VkFlags VkQueryPipelineStatisticFlags; - -typedef enum VkQueryResultFlagBits { - VK_QUERY_RESULT_64_BIT = 0x00000001, - VK_QUERY_RESULT_WAIT_BIT = 0x00000002, - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, - VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, - VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryResultFlagBits; -typedef VkFlags VkQueryResultFlags; - -typedef enum VkBufferCreateFlagBits { - VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, - VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferCreateFlagBits; -typedef VkFlags VkBufferCreateFlags; - -typedef enum VkBufferUsageFlagBits { - VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, - VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferUsageFlagBits; -typedef VkFlags VkBufferUsageFlags; -typedef VkFlags VkBufferViewCreateFlags; -typedef VkFlags VkImageViewCreateFlags; -typedef VkFlags VkShaderModuleCreateFlags; -typedef VkFlags VkPipelineCacheCreateFlags; - -typedef enum VkPipelineCreateFlagBits { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, - VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, - VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCreateFlagBits; -typedef VkFlags VkPipelineCreateFlags; -typedef VkFlags VkPipelineShaderStageCreateFlags; - -typedef enum VkShaderStageFlagBits { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, - VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, - VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, - VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, - VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, - VK_SHADER_STAGE_ALL = 0x7FFFFFFF, - VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkShaderStageFlagBits; -typedef VkFlags VkPipelineVertexInputStateCreateFlags; -typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; -typedef VkFlags VkPipelineTessellationStateCreateFlags; -typedef VkFlags VkPipelineViewportStateCreateFlags; -typedef VkFlags VkPipelineRasterizationStateCreateFlags; - -typedef enum VkCullModeFlagBits { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT_BIT = 0x00000001, - VK_CULL_MODE_BACK_BIT = 0x00000002, - VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, - VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCullModeFlagBits; -typedef VkFlags VkCullModeFlags; -typedef VkFlags VkPipelineMultisampleStateCreateFlags; -typedef VkFlags VkPipelineDepthStencilStateCreateFlags; -typedef VkFlags VkPipelineColorBlendStateCreateFlags; - -typedef enum VkColorComponentFlagBits { - VK_COLOR_COMPONENT_R_BIT = 0x00000001, - VK_COLOR_COMPONENT_G_BIT = 0x00000002, - VK_COLOR_COMPONENT_B_BIT = 0x00000004, - VK_COLOR_COMPONENT_A_BIT = 0x00000008, - VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkColorComponentFlagBits; -typedef VkFlags VkColorComponentFlags; -typedef VkFlags VkPipelineDynamicStateCreateFlags; -typedef VkFlags VkPipelineLayoutCreateFlags; -typedef VkFlags VkShaderStageFlags; -typedef VkFlags VkSamplerCreateFlags; - -typedef enum VkDescriptorSetLayoutCreateFlagBits { - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorSetLayoutCreateFlagBits; -typedef VkFlags VkDescriptorSetLayoutCreateFlags; - -typedef enum VkDescriptorPoolCreateFlagBits { - VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002, - VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorPoolCreateFlagBits; -typedef VkFlags VkDescriptorPoolCreateFlags; -typedef VkFlags VkDescriptorPoolResetFlags; -typedef VkFlags VkFramebufferCreateFlags; -typedef VkFlags VkRenderPassCreateFlags; - -typedef enum VkAttachmentDescriptionFlagBits { - VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, - VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentDescriptionFlagBits; -typedef VkFlags VkAttachmentDescriptionFlags; - -typedef enum VkSubpassDescriptionFlagBits { - VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, - VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, - VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassDescriptionFlagBits; -typedef VkFlags VkSubpassDescriptionFlags; - -typedef enum VkAccessFlagBits { - VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, - VK_ACCESS_INDEX_READ_BIT = 0x00000002, - VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, - VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, - VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, - VK_ACCESS_SHADER_READ_BIT = 0x00000020, - VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, - VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, - VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, - VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, - VK_ACCESS_HOST_READ_BIT = 0x00002000, - VK_ACCESS_HOST_WRITE_BIT = 0x00004000, - VK_ACCESS_MEMORY_READ_BIT = 0x00008000, - VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, - VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, - VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, - VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, - VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAccessFlagBits; -typedef VkFlags VkAccessFlags; - -typedef enum VkDependencyFlagBits { - VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, - VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, - VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, - VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, - VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, - VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDependencyFlagBits; -typedef VkFlags VkDependencyFlags; - -typedef enum VkCommandPoolCreateFlagBits { - VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, - VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, - VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, - VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolCreateFlagBits; -typedef VkFlags VkCommandPoolCreateFlags; - -typedef enum VkCommandPoolResetFlagBits { - VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolResetFlagBits; -typedef VkFlags VkCommandPoolResetFlags; - -typedef enum VkCommandBufferUsageFlagBits { - VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, - VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, - VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, - VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferUsageFlagBits; -typedef VkFlags VkCommandBufferUsageFlags; - -typedef enum VkQueryControlFlagBits { - VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, - VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef enum VkCommandBufferResetFlagBits { - VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferResetFlagBits; -typedef VkFlags VkCommandBufferResetFlags; - -typedef enum VkStencilFaceFlagBits { - VK_STENCIL_FACE_FRONT_BIT = 0x00000001, - VK_STENCIL_FACE_BACK_BIT = 0x00000002, - VK_STENCIL_FRONT_AND_BACK = 0x00000003, - VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkStencilFaceFlagBits; -typedef VkFlags VkStencilFaceFlags; - -typedef struct VkApplicationInfo { - VkStructureType sType; - const void* pNext; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef struct VkInstanceCreateInfo { - VkStructureType sType; - const void* pNext; - VkInstanceCreateFlags flags; - const VkApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; -} VkInstanceCreateInfo; - -typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( - void* pUserData, - void* pOriginal, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkFreeFunction)( - void* pUserData, - void* pMemory); - -typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef struct VkAllocationCallbacks { - void* pUserData; - PFN_vkAllocationFunction pfnAllocation; - PFN_vkReallocationFunction pfnReallocation; - PFN_vkFreeFunction pfnFree; - PFN_vkInternalAllocationNotification pfnInternalAllocation; - PFN_vkInternalFreeNotification pfnInternalFree; -} VkAllocationCallbacks; - -typedef struct VkPhysicalDeviceFeatures { - VkBool32 robustBufferAccess; - VkBool32 fullDrawIndexUint32; - VkBool32 imageCubeArray; - VkBool32 independentBlend; - VkBool32 geometryShader; - VkBool32 tessellationShader; - VkBool32 sampleRateShading; - VkBool32 dualSrcBlend; - VkBool32 logicOp; - VkBool32 multiDrawIndirect; - VkBool32 drawIndirectFirstInstance; - VkBool32 depthClamp; - VkBool32 depthBiasClamp; - VkBool32 fillModeNonSolid; - VkBool32 depthBounds; - VkBool32 wideLines; - VkBool32 largePoints; - VkBool32 alphaToOne; - VkBool32 multiViewport; - VkBool32 samplerAnisotropy; - VkBool32 textureCompressionETC2; - VkBool32 textureCompressionASTC_LDR; - VkBool32 textureCompressionBC; - VkBool32 occlusionQueryPrecise; - VkBool32 pipelineStatisticsQuery; - VkBool32 vertexPipelineStoresAndAtomics; - VkBool32 fragmentStoresAndAtomics; - VkBool32 shaderTessellationAndGeometryPointSize; - VkBool32 shaderImageGatherExtended; - VkBool32 shaderStorageImageExtendedFormats; - VkBool32 shaderStorageImageMultisample; - VkBool32 shaderStorageImageReadWithoutFormat; - VkBool32 shaderStorageImageWriteWithoutFormat; - VkBool32 shaderUniformBufferArrayDynamicIndexing; - VkBool32 shaderSampledImageArrayDynamicIndexing; - VkBool32 shaderStorageBufferArrayDynamicIndexing; - VkBool32 shaderStorageImageArrayDynamicIndexing; - VkBool32 shaderClipDistance; - VkBool32 shaderCullDistance; - VkBool32 shaderFloat64; - VkBool32 shaderInt64; - VkBool32 shaderInt16; - VkBool32 shaderResourceResidency; - VkBool32 shaderResourceMinLod; - VkBool32 sparseBinding; - VkBool32 sparseResidencyBuffer; - VkBool32 sparseResidencyImage2D; - VkBool32 sparseResidencyImage3D; - VkBool32 sparseResidency2Samples; - VkBool32 sparseResidency4Samples; - VkBool32 sparseResidency8Samples; - VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyAliased; - VkBool32 variableMultisampleRate; - VkBool32 inheritedQueries; -} VkPhysicalDeviceFeatures; - -typedef struct VkFormatProperties { - VkFormatFeatureFlags linearTilingFeatures; - VkFormatFeatureFlags optimalTilingFeatures; - VkFormatFeatureFlags bufferFeatures; -} VkFormatProperties; - -typedef struct VkExtent3D { - uint32_t width; - uint32_t height; - uint32_t depth; -} VkExtent3D; - -typedef struct VkImageFormatProperties { - VkExtent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - VkSampleCountFlags sampleCounts; - VkDeviceSize maxResourceSize; -} VkImageFormatProperties; - -typedef struct VkPhysicalDeviceLimits { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - VkDeviceSize bufferImageGranularity; - VkDeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - VkDeviceSize minTexelBufferOffsetAlignment; - VkDeviceSize minUniformBufferOffsetAlignment; - VkDeviceSize minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - VkSampleCountFlags framebufferColorSampleCounts; - VkSampleCountFlags framebufferDepthSampleCounts; - VkSampleCountFlags framebufferStencilSampleCounts; - VkSampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - VkSampleCountFlags sampledImageColorSampleCounts; - VkSampleCountFlags sampledImageIntegerSampleCounts; - VkSampleCountFlags sampledImageDepthSampleCounts; - VkSampleCountFlags sampledImageStencilSampleCounts; - VkSampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - VkBool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - VkBool32 strictLines; - VkBool32 standardSampleLocations; - VkDeviceSize optimalBufferCopyOffsetAlignment; - VkDeviceSize optimalBufferCopyRowPitchAlignment; - VkDeviceSize nonCoherentAtomSize; -} VkPhysicalDeviceLimits; - -typedef struct VkPhysicalDeviceSparseProperties { - VkBool32 residencyStandard2DBlockShape; - VkBool32 residencyStandard2DMultisampleBlockShape; - VkBool32 residencyStandard3DBlockShape; - VkBool32 residencyAlignedMipSize; - VkBool32 residencyNonResidentStrict; -} VkPhysicalDeviceSparseProperties; - -typedef struct VkPhysicalDeviceProperties { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - VkPhysicalDeviceLimits limits; - VkPhysicalDeviceSparseProperties sparseProperties; -} VkPhysicalDeviceProperties; - -typedef struct VkQueueFamilyProperties { - VkQueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - VkExtent3D minImageTransferGranularity; -} VkQueueFamilyProperties; - -typedef struct VkMemoryType { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; - -typedef struct VkMemoryHeap { - VkDeviceSize size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; - -typedef struct VkPhysicalDeviceMemoryProperties { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; - -typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); -typedef struct VkDeviceQueueCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; -} VkDeviceQueueCreateInfo; - -typedef struct VkDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const VkDeviceQueueCreateInfo* pQueueCreateInfos; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures* pEnabledFeatures; -} VkDeviceCreateInfo; - -typedef struct VkExtensionProperties { - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; -} VkExtensionProperties; - -typedef struct VkLayerProperties { - char layerName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - uint32_t implementationVersion; - char description[VK_MAX_DESCRIPTION_SIZE]; -} VkLayerProperties; - -typedef struct VkSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - const VkPipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const VkCommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkSubmitInfo; - -typedef struct VkMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocateInfo; - -typedef struct VkMappedMemoryRange { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; -} VkMappedMemoryRange; - -typedef struct VkMemoryRequirements { - VkDeviceSize size; - VkDeviceSize alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements; - -typedef struct VkSparseImageFormatProperties { - VkImageAspectFlags aspectMask; - VkExtent3D imageGranularity; - VkSparseImageFormatFlags flags; -} VkSparseImageFormatProperties; - -typedef struct VkSparseImageMemoryRequirements { - VkSparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - VkDeviceSize imageMipTailSize; - VkDeviceSize imageMipTailOffset; - VkDeviceSize imageMipTailStride; -} VkSparseImageMemoryRequirements; - -typedef struct VkSparseMemoryBind { - VkDeviceSize resourceOffset; - VkDeviceSize size; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseMemoryBind; - -typedef struct VkSparseBufferMemoryBindInfo { - VkBuffer buffer; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseBufferMemoryBindInfo; - -typedef struct VkSparseImageOpaqueMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseImageOpaqueMemoryBindInfo; - -typedef struct VkImageSubresource { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t arrayLayer; -} VkImageSubresource; - -typedef struct VkOffset3D { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct VkSparseImageMemoryBind { - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseImageMemoryBind; - -typedef struct VkSparseImageMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseImageMemoryBind* pBinds; -} VkSparseImageMemoryBindInfo; - -typedef struct VkBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const VkSparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const VkSparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkBindSparseInfo; - -typedef struct VkFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; - -typedef struct VkSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; - -typedef struct VkEventCreateInfo { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - -typedef struct VkQueryPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkQueryPoolCreateFlags flags; - VkQueryType queryType; - uint32_t queryCount; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; - -typedef struct VkBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkDeviceSize size; - VkBufferUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkBufferCreateInfo; - -typedef struct VkBufferViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferViewCreateFlags flags; - VkBuffer buffer; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - -typedef struct VkImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - VkSampleCountFlagBits samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkImageLayout initialLayout; -} VkImageCreateInfo; - -typedef struct VkSubresourceLayout { - VkDeviceSize offset; - VkDeviceSize size; - VkDeviceSize rowPitch; - VkDeviceSize arrayPitch; - VkDeviceSize depthPitch; -} VkSubresourceLayout; - -typedef struct VkComponentMapping { - VkComponentSwizzle r; - VkComponentSwizzle g; - VkComponentSwizzle b; - VkComponentSwizzle a; -} VkComponentMapping; - -typedef struct VkImageSubresourceRange { - VkImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t levelCount; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceRange; - -typedef struct VkImageViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageViewCreateFlags flags; - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkComponentMapping components; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo; - -typedef struct VkShaderModuleCreateInfo { - VkStructureType sType; - const void* pNext; - VkShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; -} VkShaderModuleCreateInfo; - -typedef struct VkPipelineCacheCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; -} VkPipelineCacheCreateInfo; - -typedef struct VkSpecializationMapEntry { - uint32_t constantID; - uint32_t offset; - size_t size; -} VkSpecializationMapEntry; - -typedef struct VkSpecializationInfo { - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMapEntries; - size_t dataSize; - const void* pData; -} VkSpecializationInfo; - -typedef struct VkPipelineShaderStageCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineShaderStageCreateFlags flags; - VkShaderStageFlagBits stage; - VkShaderModule module; - const char* pName; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; - -typedef struct VkVertexInputBindingDescription { - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; -} VkVertexInputBindingDescription; - -typedef struct VkVertexInputAttributeDescription { - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription; - -typedef struct VkPipelineVertexInputStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; - -typedef struct VkPipelineInputAssemblyStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineInputAssemblyStateCreateFlags flags; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo; - -typedef struct VkPipelineTessellationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; -} VkPipelineTessellationStateCreateInfo; - -typedef struct VkViewport { - float x; - float y; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct VkOffset2D { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct VkExtent2D { - uint32_t width; - uint32_t height; -} VkExtent2D; - -typedef struct VkRect2D { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct VkPipelineViewportStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const VkViewport* pViewports; - uint32_t scissorCount; - const VkRect2D* pScissors; -} VkPipelineViewportStateCreateInfo; - -typedef struct VkPipelineRasterizationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationStateCreateFlags flags; - VkBool32 depthClampEnable; - VkBool32 rasterizerDiscardEnable; - VkPolygonMode polygonMode; - VkCullModeFlags cullMode; - VkFrontFace frontFace; - VkBool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; -} VkPipelineRasterizationStateCreateInfo; - -typedef struct VkPipelineMultisampleStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineMultisampleStateCreateFlags flags; - VkSampleCountFlagBits rasterizationSamples; - VkBool32 sampleShadingEnable; - float minSampleShading; - const VkSampleMask* pSampleMask; - VkBool32 alphaToCoverageEnable; - VkBool32 alphaToOneEnable; -} VkPipelineMultisampleStateCreateInfo; - -typedef struct VkStencilOpState { - VkStencilOp failOp; - VkStencilOp passOp; - VkStencilOp depthFailOp; - VkCompareOp compareOp; - uint32_t compareMask; - uint32_t writeMask; - uint32_t reference; -} VkStencilOpState; - -typedef struct VkPipelineDepthStencilStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDepthStencilStateCreateFlags flags; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsTestEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; - float minDepthBounds; - float maxDepthBounds; -} VkPipelineDepthStencilStateCreateInfo; - -typedef struct VkPipelineColorBlendAttachmentState { - VkBool32 blendEnable; - VkBlendFactor srcColorBlendFactor; - VkBlendFactor dstColorBlendFactor; - VkBlendOp colorBlendOp; - VkBlendFactor srcAlphaBlendFactor; - VkBlendFactor dstAlphaBlendFactor; - VkBlendOp alphaBlendOp; - VkColorComponentFlags colorWriteMask; -} VkPipelineColorBlendAttachmentState; - -typedef struct VkPipelineColorBlendStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineColorBlendStateCreateFlags flags; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; -} VkPipelineColorBlendStateCreateInfo; - -typedef struct VkPipelineDynamicStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const VkDynamicState* pDynamicStates; -} VkPipelineDynamicStateCreateInfo; - -typedef struct VkGraphicsPipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; - const VkPipelineViewportStateCreateInfo* pViewportState; - const VkPipelineRasterizationStateCreateInfo* pRasterizationState; - const VkPipelineMultisampleStateCreateInfo* pMultisampleState; - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; - const VkPipelineColorBlendStateCreateInfo* pColorBlendState; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineLayout layout; - VkRenderPass renderPass; - uint32_t subpass; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; - -typedef struct VkComputePipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - VkPipelineShaderStageCreateInfo stage; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; - -typedef struct VkPushConstantRange { - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; -} VkPushConstantRange; - -typedef struct VkPipelineLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct VkSamplerCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerCreateFlags flags; - VkFilter magFilter; - VkFilter minFilter; - VkSamplerMipmapMode mipmapMode; - VkSamplerAddressMode addressModeU; - VkSamplerAddressMode addressModeV; - VkSamplerAddressMode addressModeW; - float mipLodBias; - VkBool32 anisotropyEnable; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; - VkBool32 unnormalizedCoordinates; -} VkSamplerCreateInfo; - -typedef struct VkDescriptorSetLayoutBinding { - uint32_t binding; - VkDescriptorType descriptorType; - uint32_t descriptorCount; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct VkDescriptorSetLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const VkDescriptorSetLayoutBinding* pBindings; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct VkDescriptorPoolSize { - VkDescriptorType type; - uint32_t descriptorCount; -} VkDescriptorPoolSize; - -typedef struct VkDescriptorPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const VkDescriptorPoolSize* pPoolSizes; -} VkDescriptorPoolCreateInfo; - -typedef struct VkDescriptorSetAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; -} VkDescriptorSetAllocateInfo; - -typedef struct VkDescriptorImageInfo { - VkSampler sampler; - VkImageView imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo; - -typedef struct VkDescriptorBufferInfo { - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize range; -} VkDescriptorBufferInfo; - -typedef struct VkWriteDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - const VkDescriptorImageInfo* pImageInfo; - const VkDescriptorBufferInfo* pBufferInfo; - const VkBufferView* pTexelBufferView; -} VkWriteDescriptorSet; - -typedef struct VkCopyDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; -} VkCopyDescriptorSet; - -typedef struct VkFramebufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkFramebufferCreateFlags flags; - VkRenderPass renderPass; - uint32_t attachmentCount; - const VkImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef struct VkAttachmentDescription { - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription; - -typedef struct VkAttachmentReference { - uint32_t attachment; - VkImageLayout layout; -} VkAttachmentReference; - -typedef struct VkSubpassDescription { - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t inputAttachmentCount; - const VkAttachmentReference* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference* pColorAttachments; - const VkAttachmentReference* pResolveAttachments; - const VkAttachmentReference* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription; - -typedef struct VkSubpassDependency { - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; -} VkSubpassDependency; - -typedef struct VkRenderPassCreateInfo { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency* pDependencies; -} VkRenderPassCreateInfo; - -typedef struct VkCommandPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; -} VkCommandPoolCreateInfo; - -typedef struct VkCommandBufferAllocateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPool commandPool; - VkCommandBufferLevel level; - uint32_t commandBufferCount; -} VkCommandBufferAllocateInfo; - -typedef struct VkCommandBufferInheritanceInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - uint32_t subpass; - VkFramebuffer framebuffer; - VkBool32 occlusionQueryEnable; - VkQueryControlFlags queryFlags; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkCommandBufferInheritanceInfo; - -typedef struct VkCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - VkCommandBufferUsageFlags flags; - const VkCommandBufferInheritanceInfo* pInheritanceInfo; -} VkCommandBufferBeginInfo; - -typedef struct VkBufferCopy { - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy; - -typedef struct VkImageSubresourceLayers { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceLayers; - -typedef struct VkImageCopy { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy; - -typedef struct VkImageBlit { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit; - -typedef struct VkBufferImageCopy { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef union VkClearColorValue { - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; -} VkClearColorValue; - -typedef struct VkClearDepthStencilValue { - float depth; - uint32_t stencil; -} VkClearDepthStencilValue; - -typedef union VkClearValue { - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -} VkClearValue; - -typedef struct VkClearAttachment { - VkImageAspectFlags aspectMask; - uint32_t colorAttachment; - VkClearValue clearValue; -} VkClearAttachment; - -typedef struct VkClearRect { - VkRect2D rect; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkClearRect; - -typedef struct VkImageResolve { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef struct VkMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; -} VkMemoryBarrier; - -typedef struct VkBufferMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier; - -typedef struct VkImageMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier; - -typedef struct VkRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - VkFramebuffer framebuffer; - VkRect2D renderArea; - uint32_t clearValueCount; - const VkClearValue* pClearValues; -} VkRenderPassBeginInfo; - -typedef struct VkDispatchIndirectCommand { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCommand; - -typedef struct VkDrawIndexedIndirectCommand { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCommand; - -typedef struct VkDrawIndirectCommand { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCommand; - -typedef struct VkBaseOutStructure { - VkStructureType sType; - struct VkBaseOutStructure* pNext; -} VkBaseOutStructure; - -typedef struct VkBaseInStructure { - VkStructureType sType; - const struct VkBaseInStructure* pNext; -} VkBaseInStructure; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); -typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); -typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); -typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); -typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); -typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); -typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); -typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); -typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); -typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); -typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); -typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); -typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); -typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); -typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); -typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); -typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); -typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); -typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); -typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); -typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance); - -VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( - VkInstance instance, - const char* pName); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( - VkDevice device, - const char* pName); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( - VkQueue queue); - -VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( - VkDevice device); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( - VkDevice device, - const VkMemoryAllocateInfo* pAllocateInfo, - const VkAllocationCallbacks* pAllocator, - VkDeviceMemory* pMemory); - -VKAPI_ATTR void VKAPI_CALL vkFreeMemory( - VkDevice device, - VkDeviceMemory memory, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); - -VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( - VkDevice device, - VkDeviceMemory memory); - -VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); - -VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( - VkQueue queue, - uint32_t bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); - -VKAPI_ATTR void VKAPI_CALL vkDestroyFence( - VkDevice device, - VkFence fence, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( - VkDevice device, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore); - -VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent); - -VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void* pData, - VkDeviceSize stride, - VkQueryResultFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBuffer* pBuffer); - -VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( - VkDevice device, - VkBuffer buffer, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView); - -VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImage* pImage); - -VKAPI_ATTR void VKAPI_CALL vkDestroyImage( - VkDevice device, - VkImage image, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImageView* pView); - -VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( - VkDevice device, - VkImageView imageView, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkShaderModule* pShaderModule); - -VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - size_t* pDataSize, - void* pData); - -VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( - VkDevice device, - VkPipeline pipeline, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler); - -VKAPI_ATTR void VKAPI_CALL vkDestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets); - -VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( - VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer); - -VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); - -VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( - VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( - VkCommandBuffer commandBuffer, - uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( - VkCommandBuffer commandBuffer, - float lineWidth); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( - VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( - VkCommandBuffer commandBuffer, - const float blendConstants[4]); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( - VkCommandBuffer commandBuffer, - float minDepthBounds, - float maxDepthBounds); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t compareMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t writeMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t reference); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdDraw( - VkCommandBuffer commandBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkFilter filter); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment* pAttachments, - uint32_t rectCount, - const VkClearRect* pRects); - -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkSubpassContents contents); - -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( - VkCommandBuffer commandBuffer, - VkSubpassContents contents); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); -#endif - -#define VK_VERSION_1_1 1 -// Vulkan 1.1 version number -#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 - - -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) - -#define VK_MAX_DEVICE_GROUP_SIZE 32 -#define VK_LUID_SIZE 8 -#define VK_QUEUE_FAMILY_EXTERNAL (~0U-1) - - -typedef enum VkPointClippingBehavior { - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, - VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - VK_POINT_CLIPPING_BEHAVIOR_END_RANGE = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, - VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES + 1), - VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPointClippingBehavior; - -typedef enum VkTessellationDomainOrigin { - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT + 1), - VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF -} VkTessellationDomainOrigin; - -typedef enum VkSamplerYcbcrModelConversion { - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY + 1), - VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrModelConversion; - -typedef enum VkSamplerYcbcrRange { - VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, - VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - VK_SAMPLER_YCBCR_RANGE_END_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, - VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - VK_SAMPLER_YCBCR_RANGE_ITU_FULL + 1), - VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrRange; - -typedef enum VkChromaLocation { - VK_CHROMA_LOCATION_COSITED_EVEN = 0, - VK_CHROMA_LOCATION_MIDPOINT = 1, - VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, - VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, - VK_CHROMA_LOCATION_BEGIN_RANGE = VK_CHROMA_LOCATION_COSITED_EVEN, - VK_CHROMA_LOCATION_END_RANGE = VK_CHROMA_LOCATION_MIDPOINT, - VK_CHROMA_LOCATION_RANGE_SIZE = (VK_CHROMA_LOCATION_MIDPOINT - VK_CHROMA_LOCATION_COSITED_EVEN + 1), - VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF -} VkChromaLocation; - -typedef enum VkDescriptorUpdateTemplateType { - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET + 1), - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorUpdateTemplateType; - - -typedef enum VkSubgroupFeatureFlagBits { - VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, - VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, - VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, - VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, - VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, - VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, - VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, - VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, - VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, - VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubgroupFeatureFlagBits; -typedef VkFlags VkSubgroupFeatureFlags; - -typedef enum VkPeerMemoryFeatureFlagBits { - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, - VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPeerMemoryFeatureFlagBits; -typedef VkFlags VkPeerMemoryFeatureFlags; - -typedef enum VkMemoryAllocateFlagBits { - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, - VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryAllocateFlagBits; -typedef VkFlags VkMemoryAllocateFlags; -typedef VkFlags VkCommandPoolTrimFlags; -typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; - -typedef enum VkExternalMemoryHandleTypeFlagBits { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBits; -typedef VkFlags VkExternalMemoryHandleTypeFlags; - -typedef enum VkExternalMemoryFeatureFlagBits { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBits; -typedef VkFlags VkExternalMemoryFeatureFlags; - -typedef enum VkExternalFenceHandleTypeFlagBits { - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceHandleTypeFlagBits; -typedef VkFlags VkExternalFenceHandleTypeFlags; - -typedef enum VkExternalFenceFeatureFlagBits { - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceFeatureFlagBits; -typedef VkFlags VkExternalFenceFeatureFlags; - -typedef enum VkFenceImportFlagBits { - VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, - VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceImportFlagBits; -typedef VkFlags VkFenceImportFlags; - -typedef enum VkSemaphoreImportFlagBits { - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, - VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreImportFlagBits; -typedef VkFlags VkSemaphoreImportFlags; - -typedef enum VkExternalSemaphoreHandleTypeFlagBits { - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreHandleTypeFlagBits; -typedef VkFlags VkExternalSemaphoreHandleTypeFlags; - -typedef enum VkExternalSemaphoreFeatureFlagBits { - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreFeatureFlagBits; -typedef VkFlags VkExternalSemaphoreFeatureFlags; - -typedef struct VkPhysicalDeviceSubgroupProperties { - VkStructureType sType; - void* pNext; - uint32_t subgroupSize; - VkShaderStageFlags supportedStages; - VkSubgroupFeatureFlags supportedOperations; - VkBool32 quadOperationsInAllStages; -} VkPhysicalDeviceSubgroupProperties; - -typedef struct VkBindBufferMemoryInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindBufferMemoryInfo; - -typedef struct VkBindImageMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindImageMemoryInfo; - -typedef struct VkPhysicalDevice16BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; -} VkPhysicalDevice16BitStorageFeatures; - -typedef struct VkMemoryDedicatedRequirements { - VkStructureType sType; - void* pNext; - VkBool32 prefersDedicatedAllocation; - VkBool32 requiresDedicatedAllocation; -} VkMemoryDedicatedRequirements; - -typedef struct VkMemoryDedicatedAllocateInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkMemoryDedicatedAllocateInfo; - -typedef struct VkMemoryAllocateFlagsInfo { - VkStructureType sType; - const void* pNext; - VkMemoryAllocateFlags flags; - uint32_t deviceMask; -} VkMemoryAllocateFlagsInfo; - -typedef struct VkDeviceGroupRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const VkRect2D* pDeviceRenderAreas; -} VkDeviceGroupRenderPassBeginInfo; - -typedef struct VkDeviceGroupCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; -} VkDeviceGroupCommandBufferBeginInfo; - -typedef struct VkDeviceGroupSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; -} VkDeviceGroupSubmitInfo; - -typedef struct VkDeviceGroupBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; -} VkDeviceGroupBindSparseInfo; - -typedef struct VkBindBufferMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindBufferMemoryDeviceGroupInfo; - -typedef struct VkBindImageMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const VkRect2D* pSplitInstanceBindRegions; -} VkBindImageMemoryDeviceGroupInfo; - -typedef struct VkPhysicalDeviceGroupProperties { - VkStructureType sType; - void* pNext; - uint32_t physicalDeviceCount; - VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - VkBool32 subsetAllocation; -} VkPhysicalDeviceGroupProperties; - -typedef struct VkDeviceGroupDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t physicalDeviceCount; - const VkPhysicalDevice* pPhysicalDevices; -} VkDeviceGroupDeviceCreateInfo; - -typedef struct VkBufferMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferMemoryRequirementsInfo2; - -typedef struct VkImageMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageMemoryRequirementsInfo2; - -typedef struct VkImageSparseMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageSparseMemoryRequirementsInfo2; - -typedef struct VkMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkMemoryRequirements memoryRequirements; -} VkMemoryRequirements2; - -typedef struct VkSparseImageMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkSparseImageMemoryRequirements memoryRequirements; -} VkSparseImageMemoryRequirements2; - -typedef struct VkPhysicalDeviceFeatures2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceFeatures features; -} VkPhysicalDeviceFeatures2; - -typedef struct VkPhysicalDeviceProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceProperties properties; -} VkPhysicalDeviceProperties2; - -typedef struct VkFormatProperties2 { - VkStructureType sType; - void* pNext; - VkFormatProperties formatProperties; -} VkFormatProperties2; - -typedef struct VkImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkImageFormatProperties imageFormatProperties; -} VkImageFormatProperties2; - -typedef struct VkPhysicalDeviceImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; -} VkPhysicalDeviceImageFormatInfo2; - -typedef struct VkQueueFamilyProperties2 { - VkStructureType sType; - void* pNext; - VkQueueFamilyProperties queueFamilyProperties; -} VkQueueFamilyProperties2; - -typedef struct VkPhysicalDeviceMemoryProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceMemoryProperties memoryProperties; -} VkPhysicalDeviceMemoryProperties2; - -typedef struct VkSparseImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkSparseImageFormatProperties properties; -} VkSparseImageFormatProperties2; - -typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkSampleCountFlagBits samples; - VkImageUsageFlags usage; - VkImageTiling tiling; -} VkPhysicalDeviceSparseImageFormatInfo2; - -typedef struct VkPhysicalDevicePointClippingProperties { - VkStructureType sType; - void* pNext; - VkPointClippingBehavior pointClippingBehavior; -} VkPhysicalDevicePointClippingProperties; - -typedef struct VkInputAttachmentAspectReference { - uint32_t subpass; - uint32_t inputAttachmentIndex; - VkImageAspectFlags aspectMask; -} VkInputAttachmentAspectReference; - -typedef struct VkRenderPassInputAttachmentAspectCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t aspectReferenceCount; - const VkInputAttachmentAspectReference* pAspectReferences; -} VkRenderPassInputAttachmentAspectCreateInfo; - -typedef struct VkImageViewUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags usage; -} VkImageViewUsageCreateInfo; - -typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkTessellationDomainOrigin domainOrigin; -} VkPipelineTessellationDomainOriginStateCreateInfo; - -typedef struct VkRenderPassMultiviewCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; -} VkRenderPassMultiviewCreateInfo; - -typedef struct VkPhysicalDeviceMultiviewFeatures { - VkStructureType sType; - void* pNext; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; -} VkPhysicalDeviceMultiviewFeatures; - -typedef struct VkPhysicalDeviceMultiviewProperties { - VkStructureType sType; - void* pNext; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; -} VkPhysicalDeviceMultiviewProperties; - -typedef struct VkPhysicalDeviceVariablePointerFeatures { - VkStructureType sType; - void* pNext; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; -} VkPhysicalDeviceVariablePointerFeatures; - -typedef struct VkPhysicalDeviceProtectedMemoryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 protectedMemory; -} VkPhysicalDeviceProtectedMemoryFeatures; - -typedef struct VkPhysicalDeviceProtectedMemoryProperties { - VkStructureType sType; - void* pNext; - VkBool32 protectedNoFault; -} VkPhysicalDeviceProtectedMemoryProperties; - -typedef struct VkDeviceQueueInfo2 { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; -} VkDeviceQueueInfo2; - -typedef struct VkProtectedSubmitInfo { - VkStructureType sType; - const void* pNext; - VkBool32 protectedSubmit; -} VkProtectedSubmitInfo; - -typedef struct VkSamplerYcbcrConversionCreateInfo { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkSamplerYcbcrModelConversion ycbcrModel; - VkSamplerYcbcrRange ycbcrRange; - VkComponentMapping components; - VkChromaLocation xChromaOffset; - VkChromaLocation yChromaOffset; - VkFilter chromaFilter; - VkBool32 forceExplicitReconstruction; -} VkSamplerYcbcrConversionCreateInfo; - -typedef struct VkSamplerYcbcrConversionInfo { - VkStructureType sType; - const void* pNext; - VkSamplerYcbcrConversion conversion; -} VkSamplerYcbcrConversionInfo; - -typedef struct VkBindImagePlaneMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkBindImagePlaneMemoryInfo; - -typedef struct VkImagePlaneMemoryRequirementsInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkImagePlaneMemoryRequirementsInfo; - -typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { - VkStructureType sType; - void* pNext; - VkBool32 samplerYcbcrConversion; -} VkPhysicalDeviceSamplerYcbcrConversionFeatures; - -typedef struct VkSamplerYcbcrConversionImageFormatProperties { - VkStructureType sType; - void* pNext; - uint32_t combinedImageSamplerDescriptorCount; -} VkSamplerYcbcrConversionImageFormatProperties; - -typedef struct VkDescriptorUpdateTemplateEntry { - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - size_t offset; - size_t stride; -} VkDescriptorUpdateTemplateEntry; - -typedef struct VkDescriptorUpdateTemplateCreateInfo { - VkStructureType sType; - void* pNext; - VkDescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - VkDescriptorUpdateTemplateType templateType; - VkDescriptorSetLayout descriptorSetLayout; - VkPipelineBindPoint pipelineBindPoint; - VkPipelineLayout pipelineLayout; - uint32_t set; -} VkDescriptorUpdateTemplateCreateInfo; - -typedef struct VkExternalMemoryProperties { - VkExternalMemoryFeatureFlags externalMemoryFeatures; - VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlags compatibleHandleTypes; -} VkExternalMemoryProperties; - -typedef struct VkPhysicalDeviceExternalImageFormatInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalImageFormatInfo; - -typedef struct VkExternalImageFormatProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalImageFormatProperties; - -typedef struct VkPhysicalDeviceExternalBufferInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkBufferUsageFlags usage; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalBufferInfo; - -typedef struct VkExternalBufferProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalBufferProperties; - -typedef struct VkPhysicalDeviceIDProperties { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; -} VkPhysicalDeviceIDProperties; - -typedef struct VkExternalMemoryImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryImageCreateInfo; - -typedef struct VkExternalMemoryBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryBufferCreateInfo; - -typedef struct VkExportMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExportMemoryAllocateInfo; - -typedef struct VkPhysicalDeviceExternalFenceInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalFenceInfo; - -typedef struct VkExternalFenceProperties { - VkStructureType sType; - void* pNext; - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - VkExternalFenceHandleTypeFlags compatibleHandleTypes; - VkExternalFenceFeatureFlags externalFenceFeatures; -} VkExternalFenceProperties; - -typedef struct VkExportFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlags handleTypes; -} VkExportFenceCreateInfo; - -typedef struct VkExportSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlags handleTypes; -} VkExportSemaphoreCreateInfo; - -typedef struct VkPhysicalDeviceExternalSemaphoreInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalSemaphoreInfo; - -typedef struct VkExternalSemaphoreProperties { - VkStructureType sType; - void* pNext; - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; -} VkExternalSemaphoreProperties; - -typedef struct VkPhysicalDeviceMaintenance3Properties { - VkStructureType sType; - void* pNext; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceMaintenance3Properties; - -typedef struct VkDescriptorSetLayoutSupport { - VkStructureType sType; - void* pNext; - VkBool32 supported; -} VkDescriptorSetLayoutSupport; - -typedef struct VkPhysicalDeviceShaderDrawParameterFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceShaderDrawParameterFeatures; - - -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( - uint32_t* pApiVersion); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( - VkDevice device, - const VkDeviceQueueInfo2* pQueueInfo, - VkQueue* pQueue); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); - -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); -#endif - -#define VK_KHR_surface 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) - -#define VK_KHR_SURFACE_SPEC_VERSION 25 -#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" -#define VK_COLORSPACE_SRGB_NONLINEAR_KHR VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - - -typedef enum VkColorSpaceKHR { - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, - VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, - VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, - VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003, - VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, - VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, - VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, - VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, - VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, - VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, - VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, - VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, - VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, - VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, - VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, - VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), - VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkColorSpaceKHR; - -typedef enum VkPresentModeKHR { - VK_PRESENT_MODE_IMMEDIATE_KHR = 0, - VK_PRESENT_MODE_MAILBOX_KHR = 1, - VK_PRESENT_MODE_FIFO_KHR = 2, - VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, - VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, - VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, - VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, - VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), - VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPresentModeKHR; - - -typedef enum VkSurfaceTransformFlagBitsKHR { - VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, - VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSurfaceTransformFlagBitsKHR; -typedef VkFlags VkSurfaceTransformFlagsKHR; - -typedef enum VkCompositeAlphaFlagBitsKHR { - VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, - VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkCompositeAlphaFlagBitsKHR; -typedef VkFlags VkCompositeAlphaFlagsKHR; - -typedef struct VkSurfaceCapabilitiesKHR { - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; -} VkSurfaceCapabilitiesKHR; - -typedef struct VkSurfaceFormatKHR { - VkFormat format; - VkColorSpaceKHR colorSpace; -} VkSurfaceFormatKHR; - - -typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes); -#endif - -#define VK_KHR_swapchain 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) - -#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 -#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" - - -typedef enum VkSwapchainCreateFlagBitsKHR { - VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, - VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, - VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSwapchainCreateFlagBitsKHR; -typedef VkFlags VkSwapchainCreateFlagsKHR; - -typedef enum VkDeviceGroupPresentModeFlagBitsKHR { - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, - VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, - VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, - VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDeviceGroupPresentModeFlagBitsKHR; -typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; - -typedef struct VkSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainCreateFlagsKHR flags; - VkSurfaceKHR surface; - uint32_t minImageCount; - VkFormat imageFormat; - VkColorSpaceKHR imageColorSpace; - VkExtent2D imageExtent; - uint32_t imageArrayLayers; - VkImageUsageFlags imageUsage; - VkSharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkSurfaceTransformFlagBitsKHR preTransform; - VkCompositeAlphaFlagBitsKHR compositeAlpha; - VkPresentModeKHR presentMode; - VkBool32 clipped; - VkSwapchainKHR oldSwapchain; -} VkSwapchainCreateInfoKHR; - -typedef struct VkPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t swapchainCount; - const VkSwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - VkResult* pResults; -} VkPresentInfoKHR; - -typedef struct VkImageSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; -} VkImageSwapchainCreateInfoKHR; - -typedef struct VkBindImageMemorySwapchainInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint32_t imageIndex; -} VkBindImageMemorySwapchainInfoKHR; - -typedef struct VkAcquireNextImageInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint64_t timeout; - VkSemaphore semaphore; - VkFence fence; - uint32_t deviceMask; -} VkAcquireNextImageInfoKHR; - -typedef struct VkDeviceGroupPresentCapabilitiesKHR { - VkStructureType sType; - const void* pNext; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupPresentCapabilitiesKHR; - -typedef struct VkDeviceGroupPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - VkDeviceGroupPresentModeFlagBitsKHR mode; -} VkDeviceGroupPresentInfoKHR; - -typedef struct VkDeviceGroupSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupSwapchainCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); -typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); -typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain); - -VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pSwapchainImageCount, - VkImage* pSwapchainImages); - -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t timeout, - VkSemaphore semaphore, - VkFence fence, - uint32_t* pImageIndex); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects); - -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - uint32_t* pImageIndex); -#endif - -#define VK_KHR_display 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) - -#define VK_KHR_DISPLAY_SPEC_VERSION 21 -#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" - - -typedef enum VkDisplayPlaneAlphaFlagBitsKHR { - VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, - VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDisplayPlaneAlphaFlagBitsKHR; -typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; -typedef VkFlags VkDisplayModeCreateFlagsKHR; -typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; - -typedef struct VkDisplayPropertiesKHR { - VkDisplayKHR display; - const char* displayName; - VkExtent2D physicalDimensions; - VkExtent2D physicalResolution; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkBool32 planeReorderPossible; - VkBool32 persistentContent; -} VkDisplayPropertiesKHR; - -typedef struct VkDisplayModeParametersKHR { - VkExtent2D visibleRegion; - uint32_t refreshRate; -} VkDisplayModeParametersKHR; - -typedef struct VkDisplayModePropertiesKHR { - VkDisplayModeKHR displayMode; - VkDisplayModeParametersKHR parameters; -} VkDisplayModePropertiesKHR; - -typedef struct VkDisplayModeCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeCreateFlagsKHR flags; - VkDisplayModeParametersKHR parameters; -} VkDisplayModeCreateInfoKHR; - -typedef struct VkDisplayPlaneCapabilitiesKHR { - VkDisplayPlaneAlphaFlagsKHR supportedAlpha; - VkOffset2D minSrcPosition; - VkOffset2D maxSrcPosition; - VkExtent2D minSrcExtent; - VkExtent2D maxSrcExtent; - VkOffset2D minDstPosition; - VkOffset2D maxDstPosition; - VkExtent2D minDstExtent; - VkExtent2D maxDstExtent; -} VkDisplayPlaneCapabilitiesKHR; - -typedef struct VkDisplayPlanePropertiesKHR { - VkDisplayKHR currentDisplay; - uint32_t currentStackIndex; -} VkDisplayPlanePropertiesKHR; - -typedef struct VkDisplaySurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplaySurfaceCreateFlagsKHR flags; - VkDisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - VkSurfaceTransformFlagBitsKHR transform; - float globalAlpha; - VkDisplayPlaneAlphaFlagBitsKHR alphaMode; - VkExtent2D imageExtent; -} VkDisplaySurfaceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPropertiesKHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlanePropertiesKHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( - VkPhysicalDevice physicalDevice, - uint32_t planeIndex, - uint32_t* pDisplayCount, - VkDisplayKHR* pDisplays); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModePropertiesKHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDisplayModeKHR* pMode); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR* pCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#define VK_KHR_display_swapchain 1 -#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 -#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" - -typedef struct VkDisplayPresentInfoKHR { - VkStructureType sType; - const void* pNext; - VkRect2D srcRect; - VkRect2D dstRect; - VkBool32 persistent; -} VkDisplayPresentInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchains); -#endif - -#define VK_KHR_sampler_mirror_clamp_to_edge 1 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" - - -#define VK_KHR_multiview 1 -#define VK_KHR_MULTIVIEW_SPEC_VERSION 1 -#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" - -typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; - -typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; - -typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; - - - -#define VK_KHR_get_physical_device_properties2 1 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" - -typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; - -typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; - -typedef VkFormatProperties2 VkFormatProperties2KHR; - -typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; - -typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; - -typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; - -typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; - -typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; - -typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; - - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); -#endif - -#define VK_KHR_device_group 1 -#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3 -#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" - -typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; - -typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; - -typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; - -typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; - - -typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; - -typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; - -typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; - -typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; - -typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; - -typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; - -typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; - - -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); -#endif - -#define VK_KHR_shader_draw_parameters 1 -#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 -#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" - - -#define VK_KHR_maintenance1 1 -#define VK_KHR_MAINTENANCE1_SPEC_VERSION 2 -#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" - -typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; - - -typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); -#endif - -#define VK_KHR_device_group_creation 1 -#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 -#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" -#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE - -typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; - -typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -#endif - -#define VK_KHR_external_memory_capabilities 1 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" -#define VK_LUID_SIZE_KHR VK_LUID_SIZE - -typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; - -typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; - -typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; - -typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; - - -typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; - -typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; - -typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; - -typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; - -typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; - -typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; - - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); -#endif - -#define VK_KHR_external_memory 1 -#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" -#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL - -typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; - -typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; - -typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; - - - -#define VK_KHR_external_memory_fd 1 -#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" - -typedef struct VkImportMemoryFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - int fd; -} VkImportMemoryFdInfoKHR; - -typedef struct VkMemoryFdPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryFdPropertiesKHR; - -typedef struct VkMemoryGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetFdInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( - VkDevice device, - const VkMemoryGetFdInfoKHR* pGetFdInfo, - int* pFd); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - int fd, - VkMemoryFdPropertiesKHR* pMemoryFdProperties); -#endif - -#define VK_KHR_external_semaphore_capabilities 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" - -typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; - -typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; - -typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; - -typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; - - -typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; - -typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; - - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -#endif - -#define VK_KHR_external_semaphore 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" - -typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; - -typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; - - -typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; - - - -#define VK_KHR_external_semaphore_fd 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" - -typedef struct VkImportSemaphoreFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - int fd; -} VkImportSemaphoreFdInfoKHR; - -typedef struct VkSemaphoreGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkSemaphoreGetFdInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( - VkDevice device, - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( - VkDevice device, - const VkSemaphoreGetFdInfoKHR* pGetFdInfo, - int* pFd); -#endif - -#define VK_KHR_push_descriptor 1 -#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 -#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" - -typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t maxPushDescriptors; -} VkPhysicalDevicePushDescriptorPropertiesKHR; - - -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData); -#endif - -#define VK_KHR_16bit_storage 1 -#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 -#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" - -typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; - - - -#define VK_KHR_incremental_present 1 -#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 -#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" - -typedef struct VkRectLayerKHR { - VkOffset2D offset; - VkExtent2D extent; - uint32_t layer; -} VkRectLayerKHR; - -typedef struct VkPresentRegionKHR { - uint32_t rectangleCount; - const VkRectLayerKHR* pRectangles; -} VkPresentRegionKHR; - -typedef struct VkPresentRegionsKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentRegionKHR* pRegions; -} VkPresentRegionsKHR; - - - -#define VK_KHR_descriptor_update_template 1 -typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; - - -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" - -typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; - - -typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; - - -typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; - -typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); -#endif - -#define VK_KHR_shared_presentable_image 1 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" - -typedef struct VkSharedPresentSurfaceCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkImageUsageFlags sharedPresentSupportedUsageFlags; -} VkSharedPresentSurfaceCapabilitiesKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain); -#endif - -#define VK_KHR_external_fence_capabilities 1 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" - -typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; - -typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; - -typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; - -typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; - - -typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; - -typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; - - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); -#endif - -#define VK_KHR_external_fence 1 -#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" - -typedef VkFenceImportFlags VkFenceImportFlagsKHR; - -typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; - - -typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; - - - -#define VK_KHR_external_fence_fd 1 -#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" - -typedef struct VkImportFenceFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - int fd; -} VkImportFenceFdInfoKHR; - -typedef struct VkFenceGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; -} VkFenceGetFdInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( - VkDevice device, - const VkImportFenceFdInfoKHR* pImportFenceFdInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( - VkDevice device, - const VkFenceGetFdInfoKHR* pGetFdInfo, - int* pFd); -#endif - -#define VK_KHR_maintenance2 1 -#define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" - -typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; - -typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; - - -typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; - -typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; - -typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; - -typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; - -typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; - - - -#define VK_KHR_get_surface_capabilities2 1 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" - -typedef struct VkPhysicalDeviceSurfaceInfo2KHR { - VkStructureType sType; - const void* pNext; - VkSurfaceKHR surface; -} VkPhysicalDeviceSurfaceInfo2KHR; - -typedef struct VkSurfaceCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceCapabilitiesKHR surfaceCapabilities; -} VkSurfaceCapabilities2KHR; - -typedef struct VkSurfaceFormat2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceFormatKHR surfaceFormat; -} VkSurfaceFormat2KHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats); -#endif - -#define VK_KHR_variable_pointers 1 -#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 -#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" - -typedef VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; - - - -#define VK_KHR_get_display_properties2 1 -#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 -#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" - -typedef struct VkDisplayProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPropertiesKHR displayProperties; -} VkDisplayProperties2KHR; - -typedef struct VkDisplayPlaneProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlanePropertiesKHR displayPlaneProperties; -} VkDisplayPlaneProperties2KHR; - -typedef struct VkDisplayModeProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayModePropertiesKHR displayModeProperties; -} VkDisplayModeProperties2KHR; - -typedef struct VkDisplayPlaneInfo2KHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeKHR mode; - uint32_t planeIndex; -} VkDisplayPlaneInfo2KHR; - -typedef struct VkDisplayPlaneCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlaneCapabilitiesKHR capabilities; -} VkDisplayPlaneCapabilities2KHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayProperties2KHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlaneProperties2KHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModeProperties2KHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR* pCapabilities); -#endif - -#define VK_KHR_dedicated_allocation 1 -#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 -#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" - -typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; - -typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; - - - -#define VK_KHR_storage_buffer_storage_class 1 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" - - -#define VK_KHR_relaxed_block_layout 1 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" - - -#define VK_KHR_get_memory_requirements2 1 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" - -typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; - -typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; - -typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; - -typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; - -typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; - - -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -#endif - -#define VK_KHR_image_format_list 1 -#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 -#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" - -typedef struct VkImageFormatListCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkImageFormatListCreateInfoKHR; - - - -#define VK_KHR_sampler_ycbcr_conversion 1 -typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; - - -#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 -#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" - -typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; - -typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; - -typedef VkChromaLocation VkChromaLocationKHR; - - -typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; - -typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; - -typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; - -typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; - -typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; - -typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); - -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); -#endif - -#define VK_KHR_bind_memory2 1 -#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 -#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" - -typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; - -typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); -#endif - -#define VK_KHR_maintenance3 1 -#define VK_KHR_MAINTENANCE3_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3" - -typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; - -typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; - - -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); -#endif - -#define VK_KHR_draw_indirect_count 1 -#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 -#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" - -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif - -#define VK_EXT_debug_report 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) - -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9 -#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" -#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT -#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT - - -typedef enum VkDebugReportObjectTypeEXT { - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, - VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, - VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, - VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, - VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, - VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, - VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, - VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, - VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, - VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, - VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1), - VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportObjectTypeEXT; - - -typedef enum VkDebugReportFlagBitsEXT { - VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, - VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, - VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, - VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, - VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, - VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportFlagBitsEXT; -typedef VkFlags VkDebugReportFlagsEXT; - -typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage, - void* pUserData); - -typedef struct VkDebugReportCallbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; -} VkDebugReportCallbackCreateInfoEXT; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); -typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( - VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugReportCallbackEXT* pCallback); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( - VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( - VkInstance instance, - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage); -#endif - -#define VK_NV_glsl_shader 1 -#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 -#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" - - -#define VK_EXT_depth_range_unrestricted 1 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" - - -#define VK_IMG_filter_cubic 1 -#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 -#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" - - -#define VK_AMD_rasterization_order 1 -#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 -#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" - - -typedef enum VkRasterizationOrderAMD { - VK_RASTERIZATION_ORDER_STRICT_AMD = 0, - VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, - VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, - VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, - VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), - VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF -} VkRasterizationOrderAMD; - -typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { - VkStructureType sType; - const void* pNext; - VkRasterizationOrderAMD rasterizationOrder; -} VkPipelineRasterizationStateRasterizationOrderAMD; - - - -#define VK_AMD_shader_trinary_minmax 1 -#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 -#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" - - -#define VK_AMD_shader_explicit_vertex_parameter 1 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" - - -#define VK_EXT_debug_marker 1 -#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 -#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" - -typedef struct VkDebugMarkerObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; -} VkDebugMarkerObjectNameInfoEXT; - -typedef struct VkDebugMarkerObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugMarkerObjectTagInfoEXT; - -typedef struct VkDebugMarkerMarkerInfoEXT { - VkStructureType sType; - const void* pNext; - const char* pMarkerName; - float color[4]; -} VkDebugMarkerMarkerInfoEXT; - - -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( - VkDevice device, - const VkDebugMarkerObjectTagInfoEXT* pTagInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( - VkDevice device, - const VkDebugMarkerObjectNameInfoEXT* pNameInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -#endif - -#define VK_AMD_gcn_shader 1 -#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 -#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" - - -#define VK_NV_dedicated_allocation 1 -#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 -#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" - -typedef struct VkDedicatedAllocationImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationImageCreateInfoNV; - -typedef struct VkDedicatedAllocationBufferCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationBufferCreateInfoNV; - -typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkDedicatedAllocationMemoryAllocateInfoNV; - - - -#define VK_AMD_draw_indirect_count 1 -#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 -#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" - -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif - -#define VK_AMD_negative_viewport_height 1 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" - - -#define VK_AMD_gpu_shader_half_float 1 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" - - -#define VK_AMD_shader_ballot 1 -#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 -#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" - - -#define VK_AMD_texture_gather_bias_lod 1 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" - -typedef struct VkTextureLODGatherFormatPropertiesAMD { - VkStructureType sType; - void* pNext; - VkBool32 supportsTextureGatherLODBiasAMD; -} VkTextureLODGatherFormatPropertiesAMD; - - - -#define VK_AMD_shader_info 1 -#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 -#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" - - -typedef enum VkShaderInfoTypeAMD { - VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, - VK_SHADER_INFO_TYPE_BINARY_AMD = 1, - VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, - VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD, - VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, - VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1), - VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF -} VkShaderInfoTypeAMD; - -typedef struct VkShaderResourceUsageAMD { - uint32_t numUsedVgprs; - uint32_t numUsedSgprs; - uint32_t ldsSizePerLocalWorkGroup; - size_t ldsUsageSizeInBytes; - size_t scratchMemUsageInBytes; -} VkShaderResourceUsageAMD; - -typedef struct VkShaderStatisticsInfoAMD { - VkShaderStageFlags shaderStageMask; - VkShaderResourceUsageAMD resourceUsage; - uint32_t numPhysicalVgprs; - uint32_t numPhysicalSgprs; - uint32_t numAvailableVgprs; - uint32_t numAvailableSgprs; - uint32_t computeWorkGroupSize[3]; -} VkShaderStatisticsInfoAMD; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( - VkDevice device, - VkPipeline pipeline, - VkShaderStageFlagBits shaderStage, - VkShaderInfoTypeAMD infoType, - size_t* pInfoSize, - void* pInfo); -#endif - -#define VK_AMD_shader_image_load_store_lod 1 -#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 -#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" - - -#define VK_IMG_format_pvrtc 1 -#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 -#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" - - -#define VK_NV_external_memory_capabilities 1 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" - - -typedef enum VkExternalMemoryHandleTypeFlagBitsNV { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBitsNV; -typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; - -typedef enum VkExternalMemoryFeatureFlagBitsNV { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBitsNV; -typedef VkFlags VkExternalMemoryFeatureFlagsNV; - -typedef struct VkExternalImageFormatPropertiesNV { - VkImageFormatProperties imageFormatProperties; - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; -} VkExternalImageFormatPropertiesNV; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); -#endif - -#define VK_NV_external_memory 1 -#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" - -typedef struct VkExternalMemoryImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExternalMemoryImageCreateInfoNV; - -typedef struct VkExportMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExportMemoryAllocateInfoNV; - - - -#define VK_EXT_validation_flags 1 -#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 -#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" - - -typedef enum VkValidationCheckEXT { - VK_VALIDATION_CHECK_ALL_EXT = 0, - VK_VALIDATION_CHECK_SHADERS_EXT = 1, - VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, - VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, - VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), - VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCheckEXT; - -typedef struct VkValidationFlagsEXT { - VkStructureType sType; - const void* pNext; - uint32_t disabledValidationCheckCount; - VkValidationCheckEXT* pDisabledValidationChecks; -} VkValidationFlagsEXT; - - - -#define VK_EXT_shader_subgroup_ballot 1 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" - - -#define VK_EXT_shader_subgroup_vote 1 -#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 -#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" - - -#define VK_NVX_device_generated_commands 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) - -#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 -#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" - - -typedef enum VkIndirectCommandsTokenTypeNVX { - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), - VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF -} VkIndirectCommandsTokenTypeNVX; - -typedef enum VkObjectEntryTypeNVX { - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, - VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, - VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, - VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, - VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, - VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, - VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, - VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), - VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF -} VkObjectEntryTypeNVX; - - -typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX { - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF -} VkIndirectCommandsLayoutUsageFlagBitsNVX; -typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; - -typedef enum VkObjectEntryUsageFlagBitsNVX { - VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, - VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, - VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF -} VkObjectEntryUsageFlagBitsNVX; -typedef VkFlags VkObjectEntryUsageFlagsNVX; - -typedef struct VkDeviceGeneratedCommandsFeaturesNVX { - VkStructureType sType; - const void* pNext; - VkBool32 computeBindingPointSupport; -} VkDeviceGeneratedCommandsFeaturesNVX; - -typedef struct VkDeviceGeneratedCommandsLimitsNVX { - VkStructureType sType; - const void* pNext; - uint32_t maxIndirectCommandsLayoutTokenCount; - uint32_t maxObjectEntryCounts; - uint32_t minSequenceCountBufferOffsetAlignment; - uint32_t minSequenceIndexBufferOffsetAlignment; - uint32_t minCommandsTokenBufferOffsetAlignment; -} VkDeviceGeneratedCommandsLimitsNVX; - -typedef struct VkIndirectCommandsTokenNVX { - VkIndirectCommandsTokenTypeNVX tokenType; - VkBuffer buffer; - VkDeviceSize offset; -} VkIndirectCommandsTokenNVX; - -typedef struct VkIndirectCommandsLayoutTokenNVX { - VkIndirectCommandsTokenTypeNVX tokenType; - uint32_t bindingUnit; - uint32_t dynamicCount; - uint32_t divisor; -} VkIndirectCommandsLayoutTokenNVX; - -typedef struct VkIndirectCommandsLayoutCreateInfoNVX { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkIndirectCommandsLayoutUsageFlagsNVX flags; - uint32_t tokenCount; - const VkIndirectCommandsLayoutTokenNVX* pTokens; -} VkIndirectCommandsLayoutCreateInfoNVX; - -typedef struct VkCmdProcessCommandsInfoNVX { - VkStructureType sType; - const void* pNext; - VkObjectTableNVX objectTable; - VkIndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t indirectCommandsTokenCount; - const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; - uint32_t maxSequencesCount; - VkCommandBuffer targetCommandBuffer; - VkBuffer sequencesCountBuffer; - VkDeviceSize sequencesCountOffset; - VkBuffer sequencesIndexBuffer; - VkDeviceSize sequencesIndexOffset; -} VkCmdProcessCommandsInfoNVX; - -typedef struct VkCmdReserveSpaceForCommandsInfoNVX { - VkStructureType sType; - const void* pNext; - VkObjectTableNVX objectTable; - VkIndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t maxSequencesCount; -} VkCmdReserveSpaceForCommandsInfoNVX; - -typedef struct VkObjectTableCreateInfoNVX { - VkStructureType sType; - const void* pNext; - uint32_t objectCount; - const VkObjectEntryTypeNVX* pObjectEntryTypes; - const uint32_t* pObjectEntryCounts; - const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; - uint32_t maxUniformBuffersPerDescriptor; - uint32_t maxStorageBuffersPerDescriptor; - uint32_t maxStorageImagesPerDescriptor; - uint32_t maxSampledImagesPerDescriptor; - uint32_t maxPipelineLayouts; -} VkObjectTableCreateInfoNVX; - -typedef struct VkObjectTableEntryNVX { - VkObjectEntryTypeNVX type; - VkObjectEntryUsageFlagsNVX flags; -} VkObjectTableEntryNVX; - -typedef struct VkObjectTablePipelineEntryNVX { - VkObjectEntryTypeNVX type; - VkObjectEntryUsageFlagsNVX flags; - VkPipeline pipeline; -} VkObjectTablePipelineEntryNVX; - -typedef struct VkObjectTableDescriptorSetEntryNVX { - VkObjectEntryTypeNVX type; - VkObjectEntryUsageFlagsNVX flags; - VkPipelineLayout pipelineLayout; - VkDescriptorSet descriptorSet; -} VkObjectTableDescriptorSetEntryNVX; - -typedef struct VkObjectTableVertexBufferEntryNVX { - VkObjectEntryTypeNVX type; - VkObjectEntryUsageFlagsNVX flags; - VkBuffer buffer; -} VkObjectTableVertexBufferEntryNVX; - -typedef struct VkObjectTableIndexBufferEntryNVX { - VkObjectEntryTypeNVX type; - VkObjectEntryUsageFlagsNVX flags; - VkBuffer buffer; - VkIndexType indexType; -} VkObjectTableIndexBufferEntryNVX; - -typedef struct VkObjectTablePushConstantEntryNVX { - VkObjectEntryTypeNVX type; - VkObjectEntryUsageFlagsNVX flags; - VkPipelineLayout pipelineLayout; - VkShaderStageFlags stageFlags; -} VkObjectTablePushConstantEntryNVX; - - -typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable); -typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices); -typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX( - VkCommandBuffer commandBuffer, - const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX( - VkCommandBuffer commandBuffer, - const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX( - VkDevice device, - VkIndirectCommandsLayoutNVX indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX( - VkDevice device, - const VkObjectTableCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkObjectTableNVX* pObjectTable); - -VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX( - VkDevice device, - VkObjectTableNVX objectTable, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX( - VkDevice device, - VkObjectTableNVX objectTable, - uint32_t objectCount, - const VkObjectTableEntryNVX* const* ppObjectTableEntries, - const uint32_t* pObjectIndices); - -VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX( - VkDevice device, - VkObjectTableNVX objectTable, - uint32_t objectCount, - const VkObjectEntryTypeNVX* pObjectEntryTypes, - const uint32_t* pObjectIndices); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( - VkPhysicalDevice physicalDevice, - VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, - VkDeviceGeneratedCommandsLimitsNVX* pLimits); -#endif - -#define VK_NV_clip_space_w_scaling 1 -#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 -#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" - -typedef struct VkViewportWScalingNV { - float xcoeff; - float ycoeff; -} VkViewportWScalingNV; - -typedef struct VkPipelineViewportWScalingStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 viewportWScalingEnable; - uint32_t viewportCount; - const VkViewportWScalingNV* pViewportWScalings; -} VkPipelineViewportWScalingStateCreateInfoNV; - - -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportWScalingNV* pViewportWScalings); -#endif - -#define VK_EXT_direct_mode_display 1 -#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 -#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" - -typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); -#endif - -#define VK_EXT_display_surface_counter 1 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" -#define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT - - -typedef enum VkSurfaceCounterFlagBitsEXT { - VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, - VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSurfaceCounterFlagBitsEXT; -typedef VkFlags VkSurfaceCounterFlagsEXT; - -typedef struct VkSurfaceCapabilities2EXT { - VkStructureType sType; - void* pNext; - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; - VkSurfaceCounterFlagsEXT supportedSurfaceCounters; -} VkSurfaceCapabilities2EXT; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities); -#endif - -#define VK_EXT_display_control 1 -#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 -#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" - - -typedef enum VkDisplayPowerStateEXT { - VK_DISPLAY_POWER_STATE_OFF_EXT = 0, - VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, - VK_DISPLAY_POWER_STATE_ON_EXT = 2, - VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT, - VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT, - VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1), - VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayPowerStateEXT; - -typedef enum VkDeviceEventTypeEXT { - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, - VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, - VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, - VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1), - VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceEventTypeEXT; - -typedef enum VkDisplayEventTypeEXT { - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, - VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, - VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, - VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1), - VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayEventTypeEXT; - -typedef struct VkDisplayPowerInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayPowerStateEXT powerState; -} VkDisplayPowerInfoEXT; - -typedef struct VkDeviceEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceEventTypeEXT deviceEvent; -} VkDeviceEventInfoEXT; - -typedef struct VkDisplayEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayEventTypeEXT displayEvent; -} VkDisplayEventInfoEXT; - -typedef struct VkSwapchainCounterCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkSurfaceCounterFlagsEXT surfaceCounters; -} VkSwapchainCounterCreateInfoEXT; - - -typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayPowerInfoEXT* pDisplayPowerInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( - VkDevice device, - const VkDeviceEventInfoEXT* pDeviceEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); - -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT* pDisplayEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - uint64_t* pCounterValue); -#endif - -#define VK_GOOGLE_display_timing 1 -#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 -#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" - -typedef struct VkRefreshCycleDurationGOOGLE { - uint64_t refreshDuration; -} VkRefreshCycleDurationGOOGLE; - -typedef struct VkPastPresentationTimingGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; - uint64_t actualPresentTime; - uint64_t earliestPresentTime; - uint64_t presentMargin; -} VkPastPresentationTimingGOOGLE; - -typedef struct VkPresentTimeGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; -} VkPresentTimeGOOGLE; - -typedef struct VkPresentTimesInfoGOOGLE { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentTimeGOOGLE* pTimes; -} VkPresentTimesInfoGOOGLE; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings); -#endif - -#define VK_NV_sample_mask_override_coverage 1 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" - - -#define VK_NV_geometry_shader_passthrough 1 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" - - -#define VK_NV_viewport_array2 1 -#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 -#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" - - -#define VK_NVX_multiview_per_view_attributes 1 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" - -typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - VkStructureType sType; - void* pNext; - VkBool32 perViewPositionAllComponents; -} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - - - -#define VK_NV_viewport_swizzle 1 -#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 -#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" - - -typedef enum VkViewportCoordinateSwizzleNV { - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, - VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, - VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, - VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1), - VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF -} VkViewportCoordinateSwizzleNV; - -typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; - -typedef struct VkViewportSwizzleNV { - VkViewportCoordinateSwizzleNV x; - VkViewportCoordinateSwizzleNV y; - VkViewportCoordinateSwizzleNV z; - VkViewportCoordinateSwizzleNV w; -} VkViewportSwizzleNV; - -typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const VkViewportSwizzleNV* pViewportSwizzles; -} VkPipelineViewportSwizzleStateCreateInfoNV; - - - -#define VK_EXT_discard_rectangles 1 -#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 -#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" - - -typedef enum VkDiscardRectangleModeEXT { - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, - VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, - VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, - VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, - VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1), - VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDiscardRectangleModeEXT; - -typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; - -typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxDiscardRectangles; -} VkPhysicalDeviceDiscardRectanglePropertiesEXT; - -typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineDiscardRectangleStateCreateFlagsEXT flags; - VkDiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const VkRect2D* pDiscardRectangles; -} VkPipelineDiscardRectangleStateCreateInfoEXT; - - -typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( - VkCommandBuffer commandBuffer, - uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const VkRect2D* pDiscardRectangles); -#endif - -#define VK_EXT_conservative_rasterization 1 -#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 -#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" - - -typedef enum VkConservativeRasterizationModeEXT { - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, - VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, - VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, - VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, - VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, - VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1), - VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConservativeRasterizationModeEXT; - -typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; - -typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { - VkStructureType sType; - void* pNext; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - VkBool32 primitiveUnderestimation; - VkBool32 conservativePointAndLineRasterization; - VkBool32 degenerateTrianglesRasterized; - VkBool32 degenerateLinesRasterized; - VkBool32 fullyCoveredFragmentShaderInputVariable; - VkBool32 conservativeRasterizationPostDepthCoverage; -} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; - -typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; - VkConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; -} VkPipelineRasterizationConservativeStateCreateInfoEXT; - - - -#define VK_EXT_swapchain_colorspace 1 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" - - -#define VK_EXT_hdr_metadata 1 -#define VK_EXT_HDR_METADATA_SPEC_VERSION 1 -#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" - -typedef struct VkXYColorEXT { - float x; - float y; -} VkXYColorEXT; - -typedef struct VkHdrMetadataEXT { - VkStructureType sType; - const void* pNext; - VkXYColorEXT displayPrimaryRed; - VkXYColorEXT displayPrimaryGreen; - VkXYColorEXT displayPrimaryBlue; - VkXYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; -} VkHdrMetadataEXT; - - -typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainKHR* pSwapchains, - const VkHdrMetadataEXT* pMetadata); -#endif - -#define VK_EXT_external_memory_dma_buf 1 -#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" - - -#define VK_EXT_queue_family_foreign 1 -#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 -#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" -#define VK_QUEUE_FAMILY_FOREIGN_EXT (~0U-2) - - -#define VK_EXT_debug_utils 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) - -#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 1 -#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" - -typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; -typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; - -typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageSeverityFlagBitsEXT; -typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; - -typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, - VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, - VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageTypeFlagBitsEXT; -typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; - -typedef struct VkDebugUtilsObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - const char* pObjectName; -} VkDebugUtilsObjectNameInfoEXT; - -typedef struct VkDebugUtilsObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugUtilsObjectTagInfoEXT; - -typedef struct VkDebugUtilsLabelEXT { - VkStructureType sType; - const void* pNext; - const char* pLabelName; - float color[4]; -} VkDebugUtilsLabelEXT; - -typedef struct VkDebugUtilsMessengerCallbackDataEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCallbackDataFlagsEXT flags; - const char* pMessageIdName; - int32_t messageIdNumber; - const char* pMessage; - uint32_t queueLabelCount; - VkDebugUtilsLabelEXT* pQueueLabels; - uint32_t cmdBufLabelCount; - VkDebugUtilsLabelEXT* pCmdBufLabels; - uint32_t objectCount; - VkDebugUtilsObjectNameInfoEXT* pObjects; -} VkDebugUtilsMessengerCallbackDataEXT; - -typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData); - -typedef struct VkDebugUtilsMessengerCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCreateFlagsEXT flags; - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; - VkDebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; - void* pUserData; -} VkDebugUtilsMessengerCreateInfoEXT; - - -typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); -typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); -typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); -typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); -typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( - VkDevice device, - const VkDebugUtilsObjectNameInfoEXT* pNameInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( - VkDevice device, - const VkDebugUtilsObjectTagInfoEXT* pTagInfo); - -VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( - VkQueue queue); - -VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( - VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pMessenger); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( - VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( - VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); -#endif - -#define VK_EXT_sampler_filter_minmax 1 -#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 -#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" - - -typedef enum VkSamplerReductionModeEXT { - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, - VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, - VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, - VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, - VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, - VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), - VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSamplerReductionModeEXT; - -typedef struct VkSamplerReductionModeCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkSamplerReductionModeEXT reductionMode; -} VkSamplerReductionModeCreateInfoEXT; - -typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; -} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; - - - -#define VK_AMD_gpu_shader_int16 1 -#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 -#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" - - -#define VK_AMD_mixed_attachment_samples 1 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" - - -#define VK_AMD_shader_fragment_mask 1 -#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 -#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" - - -#define VK_EXT_shader_stencil_export 1 -#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 -#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" - - -#define VK_EXT_sample_locations 1 -#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 -#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" - -typedef struct VkSampleLocationEXT { - float x; - float y; -} VkSampleLocationEXT; - -typedef struct VkSampleLocationsInfoEXT { - VkStructureType sType; - const void* pNext; - VkSampleCountFlagBits sampleLocationsPerPixel; - VkExtent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const VkSampleLocationEXT* pSampleLocations; -} VkSampleLocationsInfoEXT; - -typedef struct VkAttachmentSampleLocationsEXT { - uint32_t attachmentIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkAttachmentSampleLocationsEXT; - -typedef struct VkSubpassSampleLocationsEXT { - uint32_t subpassIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkSubpassSampleLocationsEXT; - -typedef struct VkRenderPassSampleLocationsBeginInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t attachmentInitialSampleLocationsCount; - const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; -} VkRenderPassSampleLocationsBeginInfoEXT; - -typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 sampleLocationsEnable; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkPipelineSampleLocationsStateCreateInfoEXT; - -typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { - VkStructureType sType; - void* pNext; - VkSampleCountFlags sampleLocationSampleCounts; - VkExtent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - VkBool32 variableSampleLocations; -} VkPhysicalDeviceSampleLocationsPropertiesEXT; - -typedef struct VkMultisamplePropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D maxSampleLocationGridSize; -} VkMultisamplePropertiesEXT; - - -typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( - VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT* pSampleLocationsInfo); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( - VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT* pMultisampleProperties); -#endif - -#define VK_EXT_blend_operation_advanced 1 -#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 -#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" - - -typedef enum VkBlendOverlapEXT { - VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, - VK_BLEND_OVERLAP_DISJOINT_EXT = 1, - VK_BLEND_OVERLAP_CONJOINT_EXT = 2, - VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, - VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, - VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), - VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBlendOverlapEXT; - -typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 advancedBlendCoherentOperations; -} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; - -typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t advancedBlendMaxColorAttachments; - VkBool32 advancedBlendIndependentBlend; - VkBool32 advancedBlendNonPremultipliedSrcColor; - VkBool32 advancedBlendNonPremultipliedDstColor; - VkBool32 advancedBlendCorrelatedOverlap; - VkBool32 advancedBlendAllOperations; -} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; - -typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; -} VkPipelineColorBlendAdvancedStateCreateInfoEXT; - - - -#define VK_NV_fragment_coverage_to_color 1 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" - -typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; - -typedef struct VkPipelineCoverageToColorStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageToColorStateCreateFlagsNV flags; - VkBool32 coverageToColorEnable; - uint32_t coverageToColorLocation; -} VkPipelineCoverageToColorStateCreateInfoNV; - - - -#define VK_NV_framebuffer_mixed_samples 1 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" - - -typedef enum VkCoverageModulationModeNV { - VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, - VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, - VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, - VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, - VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, - VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, - VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), - VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoverageModulationModeNV; - -typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; - -typedef struct VkPipelineCoverageModulationStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageModulationStateCreateFlagsNV flags; - VkCoverageModulationModeNV coverageModulationMode; - VkBool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; -} VkPipelineCoverageModulationStateCreateInfoNV; - - - -#define VK_NV_fill_rectangle 1 -#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 -#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" - - -#define VK_EXT_post_depth_coverage 1 -#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 -#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" - - -#define VK_EXT_validation_cache 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) - -#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 -#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" -#define VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - - -typedef enum VkValidationCacheHeaderVersionEXT { - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, - VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, - VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, - VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1), - VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCacheHeaderVersionEXT; - -typedef VkFlags VkValidationCacheCreateFlagsEXT; - -typedef struct VkValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; -} VkValidationCacheCreateInfoEXT; - -typedef struct VkShaderModuleValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheEXT validationCache; -} VkShaderModuleValidationCacheCreateInfoEXT; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); -typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); -typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( - VkDevice device, - const VkValidationCacheCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkValidationCacheEXT* pValidationCache); - -VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( - VkDevice device, - VkValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const VkValidationCacheEXT* pSrcCaches); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - size_t* pDataSize, - void* pData); -#endif - -#define VK_EXT_descriptor_indexing 1 -#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 -#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" - - -typedef enum VkDescriptorBindingFlagBitsEXT { - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 0x00000001, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 0x00000002, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 0x00000004, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 0x00000008, - VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDescriptorBindingFlagBitsEXT; -typedef VkFlags VkDescriptorBindingFlagsEXT; - -typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t bindingCount; - const VkDescriptorBindingFlagsEXT* pBindingFlags; -} VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; - -typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; -} VkPhysicalDeviceDescriptorIndexingFeaturesEXT; - -typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; -} VkPhysicalDeviceDescriptorIndexingPropertiesEXT; - -typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSetCount; - const uint32_t* pDescriptorCounts; -} VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; - -typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT { - VkStructureType sType; - void* pNext; - uint32_t maxVariableDescriptorCount; -} VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; - - - -#define VK_EXT_shader_viewport_index_layer 1 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" - - -#define VK_EXT_global_priority 1 -#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 -#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" - - -typedef enum VkQueueGlobalPriorityEXT { - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, - VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, - VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, - VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1), - VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF -} VkQueueGlobalPriorityEXT; - -typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkQueueGlobalPriorityEXT globalPriority; -} VkDeviceQueueGlobalPriorityCreateInfoEXT; - - - -#define VK_EXT_external_memory_host 1 -#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" - -typedef struct VkImportMemoryHostPointerInfoEXT { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - void* pHostPointer; -} VkImportMemoryHostPointerInfoEXT; - -typedef struct VkMemoryHostPointerPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryHostPointerPropertiesEXT; - -typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize minImportedHostPointerAlignment; -} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHostPointer, - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); -#endif - -#define VK_AMD_buffer_marker 1 -#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 -#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" - -typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker); -#endif - -#define VK_AMD_shader_core_properties 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" - -typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { - VkStructureType sType; - void* pNext; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; -} VkPhysicalDeviceShaderCorePropertiesAMD; - - - -#define VK_EXT_vertex_attribute_divisor 1 -#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1 -#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" - -typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxVertexAttribDivisor; -} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; - -typedef struct VkVertexInputBindingDivisorDescriptionEXT { - uint32_t binding; - uint32_t divisor; -} VkVertexInputBindingDivisorDescriptionEXT; - -typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfoEXT; - - - -#define VK_NV_shader_subgroup_partitioned 1 -#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 -#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_ios.h b/generator/Vulkan-Headers/include/vulkan/vulkan_ios.h deleted file mode 100644 index a092481..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_ios.h +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef VULKAN_IOS_H_ -#define VULKAN_IOS_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_MVK_ios_surface 1 -#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 -#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" - -typedef VkFlags VkIOSSurfaceCreateFlagsMVK; - -typedef struct VkIOSSurfaceCreateInfoMVK { - VkStructureType sType; - const void* pNext; - VkIOSSurfaceCreateFlagsMVK flags; - const void* pView; -} VkIOSSurfaceCreateInfoMVK; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( - VkInstance instance, - const VkIOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_macos.h b/generator/Vulkan-Headers/include/vulkan/vulkan_macos.h deleted file mode 100644 index ff0b701..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_macos.h +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef VULKAN_MACOS_H_ -#define VULKAN_MACOS_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_MVK_macos_surface 1 -#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 -#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" - -typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; - -typedef struct VkMacOSSurfaceCreateInfoMVK { - VkStructureType sType; - const void* pNext; - VkMacOSSurfaceCreateFlagsMVK flags; - const void* pView; -} VkMacOSSurfaceCreateInfoMVK; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( - VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_mir.h b/generator/Vulkan-Headers/include/vulkan/vulkan_mir.h deleted file mode 100644 index 7d24ed2..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_mir.h +++ /dev/null @@ -1,65 +0,0 @@ -#ifndef VULKAN_MIR_H_ -#define VULKAN_MIR_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_KHR_mir_surface 1 -#define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 -#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" - -typedef VkFlags VkMirSurfaceCreateFlagsKHR; - -typedef struct VkMirSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkMirSurfaceCreateFlagsKHR flags; - MirConnection* connection; - MirSurface* mirSurface; -} VkMirSurfaceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( - VkInstance instance, - const VkMirSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - MirConnection* connection); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_vi.h b/generator/Vulkan-Headers/include/vulkan/vulkan_vi.h deleted file mode 100644 index 015166b..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_vi.h +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef VULKAN_VI_H_ -#define VULKAN_VI_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_NN_vi_surface 1 -#define VK_NN_VI_SURFACE_SPEC_VERSION 1 -#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" - -typedef VkFlags VkViSurfaceCreateFlagsNN; - -typedef struct VkViSurfaceCreateInfoNN { - VkStructureType sType; - const void* pNext; - VkViSurfaceCreateFlagsNN flags; - void* window; -} VkViSurfaceCreateInfoNN; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( - VkInstance instance, - const VkViSurfaceCreateInfoNN* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h b/generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h deleted file mode 100644 index 5ba0827..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_wayland.h +++ /dev/null @@ -1,65 +0,0 @@ -#ifndef VULKAN_WAYLAND_H_ -#define VULKAN_WAYLAND_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_KHR_wayland_surface 1 -#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 -#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" - -typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; - -typedef struct VkWaylandSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkWaylandSurfaceCreateFlagsKHR flags; - struct wl_display* display; - struct wl_surface* surface; -} VkWaylandSurfaceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( - VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display* display); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_win32.h b/generator/Vulkan-Headers/include/vulkan/vulkan_win32.h deleted file mode 100644 index 6a85409..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_win32.h +++ /dev/null @@ -1,276 +0,0 @@ -#ifndef VULKAN_WIN32_H_ -#define VULKAN_WIN32_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_KHR_win32_surface 1 -#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 -#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" - -typedef VkFlags VkWin32SurfaceCreateFlagsKHR; - -typedef struct VkWin32SurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkWin32SurfaceCreateFlagsKHR flags; - HINSTANCE hinstance; - HWND hwnd; -} VkWin32SurfaceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( - VkInstance instance, - const VkWin32SurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex); -#endif - -#define VK_KHR_external_memory_win32 1 -#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" - -typedef struct VkImportMemoryWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportMemoryWin32HandleInfoKHR; - -typedef struct VkExportMemoryWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportMemoryWin32HandleInfoKHR; - -typedef struct VkMemoryWin32HandlePropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryWin32HandlePropertiesKHR; - -typedef struct VkMemoryGetWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetWin32HandleInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( - VkDevice device, - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); -#endif - -#define VK_KHR_win32_keyed_mutex 1 -#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 -#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" - -typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t acquireCount; - const VkDeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeouts; - uint32_t releaseCount; - const VkDeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; -} VkWin32KeyedMutexAcquireReleaseInfoKHR; - - - -#define VK_KHR_external_semaphore_win32 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" - -typedef struct VkImportSemaphoreWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportSemaphoreWin32HandleInfoKHR; - -typedef struct VkExportSemaphoreWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportSemaphoreWin32HandleInfoKHR; - -typedef struct VkD3D12FenceSubmitInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues; -} VkD3D12FenceSubmitInfoKHR; - -typedef struct VkSemaphoreGetWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkSemaphoreGetWin32HandleInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( - VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); -#endif - -#define VK_KHR_external_fence_win32 1 -#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" - -typedef struct VkImportFenceWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportFenceWin32HandleInfoKHR; - -typedef struct VkExportFenceWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportFenceWin32HandleInfoKHR; - -typedef struct VkFenceGetWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; -} VkFenceGetWin32HandleInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( - VkDevice device, - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( - VkDevice device, - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); -#endif - -#define VK_NV_external_memory_win32 1 -#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" - -typedef struct VkImportMemoryWin32HandleInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleType; - HANDLE handle; -} VkImportMemoryWin32HandleInfoNV; - -typedef struct VkExportMemoryWin32HandleInfoNV { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; -} VkExportMemoryWin32HandleInfoNV; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - HANDLE* pHandle); -#endif - -#define VK_NV_win32_keyed_mutex 1 -#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 -#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" - -typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t acquireCount; - const VkDeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeoutMilliseconds; - uint32_t releaseCount; - const VkDeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; -} VkWin32KeyedMutexAcquireReleaseInfoNV; - - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h b/generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h deleted file mode 100644 index ba03600..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_xcb.h +++ /dev/null @@ -1,66 +0,0 @@ -#ifndef VULKAN_XCB_H_ -#define VULKAN_XCB_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_KHR_xcb_surface 1 -#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 -#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" - -typedef VkFlags VkXcbSurfaceCreateFlagsKHR; - -typedef struct VkXcbSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkXcbSurfaceCreateFlagsKHR flags; - xcb_connection_t* connection; - xcb_window_t window; -} VkXcbSurfaceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( - VkInstance instance, - const VkXcbSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t* connection, - xcb_visualid_t visual_id); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h b/generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h deleted file mode 100644 index e1d967e..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_xlib.h +++ /dev/null @@ -1,66 +0,0 @@ -#ifndef VULKAN_XLIB_H_ -#define VULKAN_XLIB_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_KHR_xlib_surface 1 -#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 -#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" - -typedef VkFlags VkXlibSurfaceCreateFlagsKHR; - -typedef struct VkXlibSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkXlibSurfaceCreateFlagsKHR flags; - Display* dpy; - Window window; -} VkXlibSurfaceCreateInfoKHR; - - -typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( - VkInstance instance, - const VkXlibSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); - -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - Display* dpy, - VisualID visualID); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h b/generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h deleted file mode 100644 index 117d017..0000000 --- a/generator/Vulkan-Headers/include/vulkan/vulkan_xlib_xrandr.h +++ /dev/null @@ -1,54 +0,0 @@ -#ifndef VULKAN_XLIB_XRANDR_H_ -#define VULKAN_XLIB_XRANDR_H_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015-2018 The Khronos Group Inc. -** -** 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. -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#define VK_EXT_acquire_xlib_display 1 -#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 -#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" - -typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); -typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - VkDisplayKHR display); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - RROutput rrOutput, - VkDisplayKHR* pDisplay); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/generator/Vulkan-Headers/registry/cgenerator.py b/generator/Vulkan-Headers/registry/cgenerator.py deleted file mode 100644 index a370970..0000000 --- a/generator/Vulkan-Headers/registry/cgenerator.py +++ /dev/null @@ -1,417 +0,0 @@ -#!/usr/bin/python3 -i -# -# Copyright (c) 2013-2018 The Khronos Group Inc. -# -# 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. - -import os,re,sys,pdb -from generator import * - -# CGeneratorOptions - subclass of GeneratorOptions. -# -# Adds options used by COutputGenerator objects during C language header -# generation. -# -# Additional members -# prefixText - list of strings to prefix generated header with -# (usually a copyright statement + calling convention macros). -# protectFile - True if multiple inclusion protection should be -# generated (based on the filename) around the entire header. -# protectFeature - True if #ifndef..#endif protection should be -# generated around a feature interface in the header file. -# genFuncPointers - True if function pointer typedefs should be -# generated -# protectProto - If conditional protection should be generated -# around prototype declarations, set to either '#ifdef' -# to require opt-in (#ifdef protectProtoStr) or '#ifndef' -# to require opt-out (#ifndef protectProtoStr). Otherwise -# set to None. -# protectProtoStr - #ifdef/#ifndef symbol to use around prototype -# declarations, if protectProto is set -# apicall - string to use for the function declaration prefix, -# such as APICALL on Windows. -# apientry - string to use for the calling convention macro, -# in typedefs, such as APIENTRY. -# apientryp - string to use for the calling convention macro -# in function pointer typedefs, such as APIENTRYP. -# directory - directory into which to generate include files -# indentFuncProto - True if prototype declarations should put each -# parameter on a separate line -# indentFuncPointer - True if typedefed function pointers should put each -# parameter on a separate line -# alignFuncParam - if nonzero and parameters are being put on a -# separate line, align parameter names at the specified column -class CGeneratorOptions(GeneratorOptions): - """Represents options during C interface generation for headers""" - def __init__(self, - filename = None, - directory = '.', - apiname = None, - profile = None, - versions = '.*', - emitversions = '.*', - defaultExtensions = None, - addExtensions = None, - removeExtensions = None, - emitExtensions = None, - sortProcedure = regSortFeatures, - prefixText = "", - genFuncPointers = True, - protectFile = True, - protectFeature = True, - protectProto = None, - protectProtoStr = None, - apicall = '', - apientry = '', - apientryp = '', - indentFuncProto = True, - indentFuncPointer = False, - alignFuncParam = 0): - GeneratorOptions.__init__(self, filename, directory, apiname, profile, - versions, emitversions, defaultExtensions, - addExtensions, removeExtensions, - emitExtensions, sortProcedure) - self.prefixText = prefixText - self.genFuncPointers = genFuncPointers - self.protectFile = protectFile - self.protectFeature = protectFeature - self.protectProto = protectProto - self.protectProtoStr = protectProtoStr - self.apicall = apicall - self.apientry = apientry - self.apientryp = apientryp - self.indentFuncProto = indentFuncProto - self.indentFuncPointer = indentFuncPointer - self.alignFuncParam = alignFuncParam - -# COutputGenerator - subclass of OutputGenerator. -# Generates C-language API interfaces. -# -# ---- methods ---- -# COutputGenerator(errFile, warnFile, diagFile) - args as for -# OutputGenerator. Defines additional internal state. -# ---- methods overriding base class ---- -# beginFile(genOpts) -# endFile() -# beginFeature(interface, emit) -# endFeature() -# genType(typeinfo,name) -# genStruct(typeinfo,name) -# genGroup(groupinfo,name) -# genEnum(enuminfo, name) -# genCmd(cmdinfo) -class COutputGenerator(OutputGenerator): - """Generate specified API interfaces in a specific style, such as a C header""" - # This is an ordered list of sections in the header file. - TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum', - 'group', 'bitmask', 'funcpointer', 'struct'] - ALL_SECTIONS = TYPE_SECTIONS + ['commandPointer', 'command'] - def __init__(self, - errFile = sys.stderr, - warnFile = sys.stderr, - diagFile = sys.stdout): - OutputGenerator.__init__(self, errFile, warnFile, diagFile) - # Internal state - accumulators for different inner block text - self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) - # - def beginFile(self, genOpts): - OutputGenerator.beginFile(self, genOpts) - # C-specific - # - # Multiple inclusion protection & C++ wrappers. - if (genOpts.protectFile and self.genOpts.filename): - headerSym = re.sub('\.h', '_h_', - os.path.basename(self.genOpts.filename)).upper() - write('#ifndef', headerSym, file=self.outFile) - write('#define', headerSym, '1', file=self.outFile) - self.newline() - write('#ifdef __cplusplus', file=self.outFile) - write('extern "C" {', file=self.outFile) - write('#endif', file=self.outFile) - self.newline() - # - # User-supplied prefix text, if any (list of strings) - if (genOpts.prefixText): - for s in genOpts.prefixText: - write(s, file=self.outFile) - # - # Some boilerplate describing what was generated - this - # will probably be removed later since the extensions - # pattern may be very long. - # write('/* Generated C header for:', file=self.outFile) - # write(' * API:', genOpts.apiname, file=self.outFile) - # if (genOpts.profile): - # write(' * Profile:', genOpts.profile, file=self.outFile) - # write(' * Versions considered:', genOpts.versions, file=self.outFile) - # write(' * Versions emitted:', genOpts.emitversions, file=self.outFile) - # write(' * Default extensions included:', genOpts.defaultExtensions, file=self.outFile) - # write(' * Additional extensions included:', genOpts.addExtensions, file=self.outFile) - # write(' * Extensions removed:', genOpts.removeExtensions, file=self.outFile) - # write(' * Extensions emitted:', genOpts.emitExtensions, file=self.outFile) - # write(' */', file=self.outFile) - def endFile(self): - # C-specific - # Finish C++ wrapper and multiple inclusion protection - self.newline() - write('#ifdef __cplusplus', file=self.outFile) - write('}', file=self.outFile) - write('#endif', file=self.outFile) - if (self.genOpts.protectFile and self.genOpts.filename): - self.newline() - write('#endif', file=self.outFile) - # Finish processing in superclass - OutputGenerator.endFile(self) - def beginFeature(self, interface, emit): - # Start processing in superclass - OutputGenerator.beginFeature(self, interface, emit) - # C-specific - # Accumulate includes, defines, types, enums, function pointer typedefs, - # end function prototypes separately for this feature. They're only - # printed in endFeature(). - self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) - def endFeature(self): - # C-specific - # Actually write the interface to the output file. - if (self.emit): - self.newline() - if (self.genOpts.protectFeature): - write('#ifndef', self.featureName, file=self.outFile) - # If type declarations are needed by other features based on - # this one, it may be necessary to suppress the ExtraProtect, - # or move it below the 'for section...' loop. - if (self.featureExtraProtect != None): - write('#ifdef', self.featureExtraProtect, file=self.outFile) - write('#define', self.featureName, '1', file=self.outFile) - for section in self.TYPE_SECTIONS: - contents = self.sections[section] - if contents: - write('\n'.join(contents), file=self.outFile) - self.newline() - if (self.genOpts.genFuncPointers and self.sections['commandPointer']): - write('\n'.join(self.sections['commandPointer']), file=self.outFile) - self.newline() - if (self.sections['command']): - if (self.genOpts.protectProto): - write(self.genOpts.protectProto, - self.genOpts.protectProtoStr, file=self.outFile) - write('\n'.join(self.sections['command']), end='', file=self.outFile) - if (self.genOpts.protectProto): - write('#endif', file=self.outFile) - else: - self.newline() - if (self.featureExtraProtect != None): - write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile) - if (self.genOpts.protectFeature): - write('#endif /*', self.featureName, '*/', file=self.outFile) - # Finish processing in superclass - OutputGenerator.endFeature(self) - # - # Append a definition to the specified section - def appendSection(self, section, text): - # self.sections[section].append('SECTION: ' + section + '\n') - self.sections[section].append(text) - # self.logMsg('diag', 'appendSection(section =', section, 'text =', text) - # - # Type generation - def genType(self, typeinfo, name, alias): - OutputGenerator.genType(self, typeinfo, name, alias) - typeElem = typeinfo.elem - - # Determine the category of the type, and the type section to add - # its definition to. - # 'funcpointer' is added to the 'struct' section as a workaround for - # internal issue #877, since structures and function pointer types - # can have cross-dependencies. - category = typeElem.get('category') - if category == 'funcpointer': - section = 'struct' - else: - section = category - - if category == 'struct' or category == 'union': - # If the type is a struct type, generate it using the - # special-purpose generator. - self.genStruct(typeinfo, name, alias) - else: - if alias: - # If the type is an alias, just emit a typedef declaration - body = 'typedef ' + alias + ' ' + name + ';\n' - else: - # Replace tags with an APIENTRY-style string - # (from self.genOpts). Copy other text through unchanged. - # If the resulting text is an empty string, don't emit it. - body = noneStr(typeElem.text) - for elem in typeElem: - if (elem.tag == 'apientry'): - body += self.genOpts.apientry + noneStr(elem.tail) - else: - body += noneStr(elem.text) + noneStr(elem.tail) - - if body: - # Add extra newline after multi-line entries. - if '\n' in body[0:-1]: - body += '\n' - self.appendSection(section, body) - # - # Struct (e.g. C "struct" type) generation. - # This is a special case of the tag where the contents are - # interpreted as a set of tags instead of freeform C - # C type declarations. The tags are just like - # tags - they are a declaration of a struct or union member. - # Only simple member declarations are supported (no nested - # structs etc.) - # If alias != None, then this struct aliases another; just - # generate a typedef of that alias. - def genStruct(self, typeinfo, typeName, alias): - OutputGenerator.genStruct(self, typeinfo, typeName, alias) - - typeElem = typeinfo.elem - - if alias: - body = 'typedef ' + alias + ' ' + typeName + ';\n' - else: - body = 'typedef ' + typeElem.get('category') + ' ' + typeName + ' {\n' - - targetLen = 0; - for member in typeElem.findall('.//member'): - targetLen = max(targetLen, self.getCParamTypeLength(member)) - for member in typeElem.findall('.//member'): - body += self.makeCParamDecl(member, targetLen + 4) - body += ';\n' - body += '} ' + typeName + ';\n' - - self.appendSection('struct', body) - # - # Group (e.g. C "enum" type) generation. - # These are concatenated together with other types. - # If alias != None, it is the name of another group type - # which aliases this type; just generate that alias. - def genGroup(self, groupinfo, groupName, alias = None): - OutputGenerator.genGroup(self, groupinfo, groupName, alias) - groupElem = groupinfo.elem - - if alias: - # If the group name is aliased, just emit a typedef declaration - # for the alias. - body = 'typedef ' + alias + ' ' + groupName + ';\n' - else: - self.logMsg('diag', 'CGenerator.genGroup group =', groupName, 'alias =', alias) - - # Otherwise, emit an actual enumerated type declaration - expandName = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2',groupName).upper() - - expandPrefix = expandName - expandSuffix = '' - expandSuffixMatch = re.search(r'[A-Z][A-Z]+$',groupName) - if expandSuffixMatch: - expandSuffix = '_' + expandSuffixMatch.group() - # Strip off the suffix from the prefix - expandPrefix = expandName.rsplit(expandSuffix, 1)[0] - - # Prefix - body = "\ntypedef enum " + groupName + " {\n" - - # @@ Should use the type="bitmask" attribute instead - isEnum = ('FLAG_BITS' not in expandPrefix) - - # Get a list of nested 'enum' tags. - enums = groupElem.findall('enum') - - # Check for and report duplicates, and return a list with them - # removed. - enums = self.checkDuplicateEnums(enums) - - # Loop over the nested 'enum' tags. Keep track of the minimum and - # maximum numeric values, if they can be determined; but only for - # core API enumerants, not extension enumerants. This is inferred - # by looking for 'extends' attributes. - minName = None - - # Accumulate non-numeric enumerant values separately and append - # them following the numeric values, to allow for aliases. - # NOTE: this doesn't do a topological sort yet, so aliases of - # aliases can still get in the wrong order. - aliasText = "" - - for elem in enums: - # Convert the value to an integer and use that to track min/max. - (numVal,strVal) = self.enumToValue(elem, True) - name = elem.get('name') - - # Extension enumerants are only included if they are required - if self.isEnumRequired(elem): - decl = " " + name + " = " + strVal + ",\n" - if numVal != None: - body += decl - else: - aliasText += decl - - # Don't track min/max for non-numbers (numVal == None) - if isEnum and numVal != None and elem.get('extends') is None: - if minName == None: - minName = maxName = name - minValue = maxValue = numVal - elif numVal < minValue: - minName = name - minValue = numVal - elif numVal > maxValue: - maxName = name - maxValue = numVal - - # Now append the non-numeric enumerant values - body += aliasText - - # Generate min/max value tokens and a range-padding enum. Need some - # additional padding to generate correct names... - if isEnum: - body += " " + expandPrefix + "_BEGIN_RANGE" + expandSuffix + " = " + minName + ",\n" - body += " " + expandPrefix + "_END_RANGE" + expandSuffix + " = " + maxName + ",\n" - body += " " + expandPrefix + "_RANGE_SIZE" + expandSuffix + " = (" + maxName + " - " + minName + " + 1),\n" - - body += " " + expandPrefix + "_MAX_ENUM" + expandSuffix + " = 0x7FFFFFFF\n" - - # Postfix - body += "} " + groupName + ";" - - # After either enumerated type or alias paths, add the declaration - # to the appropriate section for the group being defined. - if groupElem.get('type') == 'bitmask': - section = 'bitmask' - else: - section = 'group' - self.appendSection(section, body) - - # Enumerant generation - # tags may specify their values in several ways, but are usually - # just integers. - def genEnum(self, enuminfo, name, alias): - OutputGenerator.genEnum(self, enuminfo, name, alias) - (numVal,strVal) = self.enumToValue(enuminfo.elem, False) - body = '#define ' + name.ljust(33) + ' ' + strVal - self.appendSection('enum', body) - - # - # Command generation - def genCmd(self, cmdinfo, name, alias): - OutputGenerator.genCmd(self, cmdinfo, name, alias) - - # if alias: - # prefix = '// ' + name + ' is an alias of command ' + alias + '\n' - # else: - # prefix = '' - - prefix = '' - decls = self.makeCDecls(cmdinfo.elem) - self.appendSection('command', prefix + decls[0] + '\n') - if (self.genOpts.genFuncPointers): - self.appendSection('commandPointer', decls[1]) diff --git a/generator/Vulkan-Headers/registry/generator.py b/generator/Vulkan-Headers/registry/generator.py deleted file mode 100644 index a0f79ac..0000000 --- a/generator/Vulkan-Headers/registry/generator.py +++ /dev/null @@ -1,595 +0,0 @@ -#!/usr/bin/python3 -i -# -# Copyright (c) 2013-2018 The Khronos Group Inc. -# -# 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. - -from __future__ import unicode_literals -import io,os,re,sys,pdb - -def write( *args, **kwargs ): - file = kwargs.pop('file',sys.stdout) - end = kwargs.pop('end','\n') - file.write(' '.join([str(arg) for arg in args])) - file.write(end) - -# noneStr - returns string argument, or "" if argument is None. -# Used in converting etree Elements into text. -# str - string to convert -def noneStr(str): - if (str): - return str - else: - return "" - -# enquote - returns string argument with surrounding quotes, -# for serialization into Python code. -def enquote(str): - if (str): - return "'" + str + "'" - else: - return None - -# apiName - returns True if name is a Vulkan name (vk/Vk/VK prefix, or a -# function pointer type), False otherwise. -def apiName(str): - return str[0:2].lower() == 'vk' or str[0:3] == 'PFN' - -# Primary sort key for regSortFeatures. -# Sorts by category of the feature name string: -# Core API features (those defined with a tag) -# ARB/KHR/OES (Khronos extensions) -# other (EXT/vendor extensions) -# This will need changing for Vulkan! -def regSortCategoryKey(feature): - if (feature.elem.tag == 'feature'): - return 0 - elif (feature.category == 'ARB' or - feature.category == 'KHR' or - feature.category == 'OES'): - return 1 - else: - return 2 - -# Secondary sort key for regSortFeatures. -# Sorts by extension name. -def regSortNameKey(feature): - return feature.name - -# Second sort key for regSortFeatures. -# Sorts by feature version. elements all have version number "0" -def regSortFeatureVersionKey(feature): - return float(feature.versionNumber) - -# Tertiary sort key for regSortFeatures. -# Sorts by extension number. elements all have extension number 0. -def regSortExtensionNumberKey(feature): - return int(feature.number) - -# regSortFeatures - default sort procedure for features. -# Sorts by primary key of feature category ('feature' or 'extension') -# then by version number (for features) -# then by extension number (for extensions) -def regSortFeatures(featureList): - featureList.sort(key = regSortExtensionNumberKey) - featureList.sort(key = regSortFeatureVersionKey) - featureList.sort(key = regSortCategoryKey) - -# GeneratorOptions - base class for options used during header production -# These options are target language independent, and used by -# Registry.apiGen() and by base OutputGenerator objects. -# -# Members -# filename - basename of file to generate, or None to write to stdout. -# directory - directory in which to generate filename -# apiname - string matching 'apiname' attribute, e.g. 'gl'. -# profile - string specifying API profile , e.g. 'core', or None. -# versions - regex matching API versions to process interfaces for. -# Normally '.*' or '[0-9]\.[0-9]' to match all defined versions. -# emitversions - regex matching API versions to actually emit -# interfaces for (though all requested versions are considered -# when deciding which interfaces to generate). For GL 4.3 glext.h, -# this might be '1\.[2-5]|[2-4]\.[0-9]'. -# defaultExtensions - If not None, a string which must in its -# entirety match the pattern in the "supported" attribute of -# the . Defaults to None. Usually the same as apiname. -# addExtensions - regex matching names of additional extensions -# to include. Defaults to None. -# removeExtensions - regex matching names of extensions to -# remove (after defaultExtensions and addExtensions). Defaults -# to None. -# emitExtensions - regex matching names of extensions to actually emit -# interfaces for (though all requested versions are considered when -# deciding which interfaces to generate). -# sortProcedure - takes a list of FeatureInfo objects and sorts -# them in place to a preferred order in the generated output. -# Default is core API versions, ARB/KHR/OES extensions, all -# other extensions, alphabetically within each group. -# The regex patterns can be None or empty, in which case they match -# nothing. -class GeneratorOptions: - """Represents options during header production from an API registry""" - def __init__(self, - filename = None, - directory = '.', - apiname = None, - profile = None, - versions = '.*', - emitversions = '.*', - defaultExtensions = None, - addExtensions = None, - removeExtensions = None, - emitExtensions = None, - sortProcedure = regSortFeatures): - self.filename = filename - self.directory = directory - self.apiname = apiname - self.profile = profile - self.versions = self.emptyRegex(versions) - self.emitversions = self.emptyRegex(emitversions) - self.defaultExtensions = defaultExtensions - self.addExtensions = self.emptyRegex(addExtensions) - self.removeExtensions = self.emptyRegex(removeExtensions) - self.emitExtensions = self.emptyRegex(emitExtensions) - self.sortProcedure = sortProcedure - # - # Substitute a regular expression which matches no version - # or extension names for None or the empty string. - def emptyRegex(self,pat): - if (pat == None or pat == ''): - return '_nomatch_^' - else: - return pat - -# OutputGenerator - base class for generating API interfaces. -# Manages basic logic, logging, and output file control -# Derived classes actually generate formatted output. -# -# ---- methods ---- -# OutputGenerator(errFile, warnFile, diagFile) -# errFile, warnFile, diagFile - file handles to write errors, -# warnings, diagnostics to. May be None to not write. -# logMsg(level, *args) - log messages of different categories -# level - 'error', 'warn', or 'diag'. 'error' will also -# raise a UserWarning exception -# *args - print()-style arguments -# setExtMap(map) - specify a dictionary map from extension names to -# numbers, used in creating values for extension enumerants. -# makeDir(directory) - create a directory, if not already done. -# Generally called from derived generators creating hierarchies. -# beginFile(genOpts) - start a new interface file -# genOpts - GeneratorOptions controlling what's generated and how -# endFile() - finish an interface file, closing it when done -# beginFeature(interface, emit) - write interface for a feature -# and tag generated features as having been done. -# interface - element for the / to generate -# emit - actually write to the header only when True -# endFeature() - finish an interface. -# genType(typeinfo,name,alias) - generate interface for a type -# typeinfo - TypeInfo for a type -# genStruct(typeinfo,name,alias) - generate interface for a C "struct" type. -# typeinfo - TypeInfo for a type interpreted as a struct -# genGroup(groupinfo,name,alias) - generate interface for a group of enums (C "enum") -# groupinfo - GroupInfo for a group -# genEnum(enuminfo,name,alias) - generate interface for an enum (constant) -# enuminfo - EnumInfo for an enum -# name - enum name -# genCmd(cmdinfo,name,alias) - generate interface for a command -# cmdinfo - CmdInfo for a command -# isEnumRequired(enumElem) - return True if this element is required -# elem - element to test -# makeCDecls(cmd) - return C prototype and function pointer typedef for a -# Element, as a list of two strings -# cmd - Element for the -# newline() - print a newline to the output file (utility function) -# -class OutputGenerator: - """Generate specified API interfaces in a specific style, such as a C header""" - # - # categoryToPath - map XML 'category' to include file directory name - categoryToPath = { - 'bitmask' : 'flags', - 'enum' : 'enums', - 'funcpointer' : 'funcpointers', - 'handle' : 'handles', - 'define' : 'defines', - 'basetype' : 'basetypes', - } - # - # Constructor - def __init__(self, - errFile = sys.stderr, - warnFile = sys.stderr, - diagFile = sys.stdout): - self.outFile = None - self.errFile = errFile - self.warnFile = warnFile - self.diagFile = diagFile - # Internal state - self.featureName = None - self.genOpts = None - self.registry = None - # Used for extension enum value generation - self.extBase = 1000000000 - self.extBlockSize = 1000 - self.madeDirs = {} - # - # logMsg - write a message of different categories to different - # destinations. - # level - - # 'diag' (diagnostic, voluminous) - # 'warn' (warning) - # 'error' (fatal error - raises exception after logging) - # *args - print()-style arguments to direct to corresponding log - def logMsg(self, level, *args): - """Log a message at the given level. Can be ignored or log to a file""" - if (level == 'error'): - strfile = io.StringIO() - write('ERROR:', *args, file=strfile) - if (self.errFile != None): - write(strfile.getvalue(), file=self.errFile) - raise UserWarning(strfile.getvalue()) - elif (level == 'warn'): - if (self.warnFile != None): - write('WARNING:', *args, file=self.warnFile) - elif (level == 'diag'): - if (self.diagFile != None): - write('DIAG:', *args, file=self.diagFile) - else: - raise UserWarning( - '*** FATAL ERROR in Generator.logMsg: unknown level:' + level) - # - # enumToValue - parses and converts an tag into a value. - # Returns a list - # first element - integer representation of the value, or None - # if needsNum is False. The value must be a legal number - # if needsNum is True. - # second element - string representation of the value - # There are several possible representations of values. - # A 'value' attribute simply contains the value. - # A 'bitpos' attribute defines a value by specifying the bit - # position which is set in that value. - # A 'offset','extbase','extends' triplet specifies a value - # as an offset to a base value defined by the specified - # 'extbase' extension name, which is then cast to the - # typename specified by 'extends'. This requires probing - # the registry database, and imbeds knowledge of the - # Vulkan extension enum scheme in this function. - # A 'alias' attribute contains the name of another enum - # which this is an alias of. The other enum must be - # declared first when emitting this enum. - def enumToValue(self, elem, needsNum): - name = elem.get('name') - numVal = None - if ('value' in elem.keys()): - value = elem.get('value') - # print('About to translate value =', value, 'type =', type(value)) - if (needsNum): - numVal = int(value, 0) - # If there's a non-integer, numeric 'type' attribute (e.g. 'u' or - # 'ull'), append it to the string value. - # t = enuminfo.elem.get('type') - # if (t != None and t != '' and t != 'i' and t != 's'): - # value += enuminfo.type - self.logMsg('diag', 'Enum', name, '-> value [', numVal, ',', value, ']') - return [numVal, value] - if ('bitpos' in elem.keys()): - value = elem.get('bitpos') - numVal = int(value, 0) - numVal = 1 << numVal - value = '0x%08x' % numVal - self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']') - return [numVal, value] - if ('offset' in elem.keys()): - # Obtain values in the mapping from the attributes - enumNegative = False - offset = int(elem.get('offset'),0) - extnumber = int(elem.get('extnumber'),0) - extends = elem.get('extends') - if ('dir' in elem.keys()): - enumNegative = True - self.logMsg('diag', 'Enum', name, 'offset =', offset, - 'extnumber =', extnumber, 'extends =', extends, - 'enumNegative =', enumNegative) - # Now determine the actual enumerant value, as defined - # in the "Layers and Extensions" appendix of the spec. - numVal = self.extBase + (extnumber - 1) * self.extBlockSize + offset - if (enumNegative): - numVal = -numVal - value = '%d' % numVal - # More logic needed! - self.logMsg('diag', 'Enum', name, '-> offset [', numVal, ',', value, ']') - return [numVal, value] - if 'alias' in elem.keys(): - return [None, elem.get('alias')] - return [None, None] - # - # checkDuplicateEnums - sanity check for enumerated values - # enums - list of Elements - # returns the list with duplicates stripped - def checkDuplicateEnums(self, enums): - # Dictionaries indexed by name and numeric value. - # Entries are [ Element, numVal, strVal ] matching name or value - - nameMap = {} - valueMap = {} - - stripped = [] - for elem in enums: - name = elem.get('name') - (numVal, strVal) = self.enumToValue(elem, True) - - if name in nameMap: - # Duplicate name found; check values - (name2, numVal2, strVal2) = nameMap[name] - - # Duplicate enum values for the same name are benign. This - # happens when defining the same enum conditionally in - # several extension blocks. - if (strVal2 == strVal or (numVal != None and - numVal == numVal2)): - True - # self.logMsg('info', 'checkDuplicateEnums: Duplicate enum (' + name + - # ') found with the same value:' + strVal) - else: - self.logMsg('warn', 'checkDuplicateEnums: Duplicate enum (' + name + - ') found with different values:' + strVal + - ' and ' + strVal2) - - # Don't add the duplicate to the returned list - continue - elif numVal in valueMap: - # Duplicate value found (such as an alias); report it, but - # still add this enum to the list. - (name2, numVal2, strVal2) = valueMap[numVal] - - try: - self.logMsg('warn', 'Two enums found with the same value: ' - + name + ' = ' + name2.get('name') + ' = ' + strVal) - except: - pdb.set_trace() - - # Track this enum to detect followon duplicates - nameMap[name] = [ elem, numVal, strVal ] - if numVal != None: - valueMap[numVal] = [ elem, numVal, strVal ] - - # Add this enum to the list - stripped.append(elem) - - # Return the list - return stripped - # - def makeDir(self, path): - self.logMsg('diag', 'OutputGenerator::makeDir(' + path + ')') - if not (path in self.madeDirs.keys()): - # This can get race conditions with multiple writers, see - # https://stackoverflow.com/questions/273192/ - if not os.path.exists(path): - os.makedirs(path) - self.madeDirs[path] = None - # - def beginFile(self, genOpts): - self.genOpts = genOpts - # - # Open specified output file. Not done in constructor since a - # Generator can be used without writing to a file. - if (self.genOpts.filename != None): - filename = self.genOpts.directory + '/' + self.genOpts.filename - self.outFile = io.open(filename, 'w', encoding='utf-8') - else: - self.outFile = sys.stdout - def endFile(self): - self.errFile and self.errFile.flush() - self.warnFile and self.warnFile.flush() - self.diagFile and self.diagFile.flush() - self.outFile.flush() - if (self.outFile != sys.stdout and self.outFile != sys.stderr): - self.outFile.close() - self.genOpts = None - # - def beginFeature(self, interface, emit): - self.emit = emit - self.featureName = interface.get('name') - # If there's an additional 'protect' attribute in the feature, save it - self.featureExtraProtect = interface.get('protect') - def endFeature(self): - # Derived classes responsible for emitting feature - self.featureName = None - self.featureExtraProtect = None - # Utility method to validate we're generating something only inside a - # tag - def validateFeature(self, featureType, featureName): - if (self.featureName == None): - raise UserWarning('Attempt to generate', featureType, - featureName, 'when not in feature') - # - # Type generation - def genType(self, typeinfo, name, alias): - self.validateFeature('type', name) - # - # Struct (e.g. C "struct" type) generation - def genStruct(self, typeinfo, name, alias): - self.validateFeature('struct', name) - - # The mixed-mode tags may contain no-op tags. - # It is convenient to remove them here where all output generators - # will benefit. - for member in typeinfo.elem.findall('.//member'): - for comment in member.findall('comment'): - member.remove(comment) - # - # Group (e.g. C "enum" type) generation - def genGroup(self, groupinfo, name, alias): - self.validateFeature('group', name) - # - # Enumerant (really, constant) generation - def genEnum(self, enuminfo, name, alias): - self.validateFeature('enum', name) - # - # Command generation - def genCmd(self, cmd, name, alias): - self.validateFeature('command', name) - # - # Utility functions - turn a into C-language prototype - # and typedef declarations for that name. - # name - contents of tag - # tail - whatever text follows that tag in the Element - def makeProtoName(self, name, tail): - return self.genOpts.apientry + name + tail - def makeTypedefName(self, name, tail): - return '(' + self.genOpts.apientryp + 'PFN_' + name + tail + ')' - # - # makeCParamDecl - return a string which is an indented, formatted - # declaration for a or block (e.g. function parameter - # or structure/union member). - # param - Element ( or ) to format - # aligncol - if non-zero, attempt to align the nested element - # at this column - def makeCParamDecl(self, param, aligncol): - paramdecl = ' ' + noneStr(param.text) - for elem in param: - text = noneStr(elem.text) - tail = noneStr(elem.tail) - if (elem.tag == 'name' and aligncol > 0): - self.logMsg('diag', 'Aligning parameter', elem.text, 'to column', self.genOpts.alignFuncParam) - # Align at specified column, if possible - paramdecl = paramdecl.rstrip() - oldLen = len(paramdecl) - # This works around a problem where very long type names - - # longer than the alignment column - would run into the tail - # text. - paramdecl = paramdecl.ljust(aligncol-1) + ' ' - newLen = len(paramdecl) - self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl) - paramdecl += text + tail - return paramdecl - # - # getCParamTypeLength - return the length of the type field is an indented, formatted - # declaration for a or block (e.g. function parameter - # or structure/union member). - # param - Element ( or ) to identify - def getCParamTypeLength(self, param): - paramdecl = ' ' + noneStr(param.text) - for elem in param: - text = noneStr(elem.text) - tail = noneStr(elem.tail) - if (elem.tag == 'name'): - # Align at specified column, if possible - newLen = len(paramdecl.rstrip()) - self.logMsg('diag', 'Identifying length of', elem.text, 'as', newLen) - paramdecl += text + tail - return newLen - # - # isEnumRequired(elem) - return True if this element is - # required, False otherwise - # elem - element to test - def isEnumRequired(self, elem): - required = elem.get('required') != None - self.logMsg('diag', 'isEnumRequired:', elem.get('name'), - '->', required) - return required - - #@@@ This code is overridden by equivalent code now run in - #@@@ Registry.generateFeature - - required = False - - extname = elem.get('extname') - if extname is not None: - # 'supported' attribute was injected when the element was - # moved into the group in Registry.parseTree() - if self.genOpts.defaultExtensions == elem.get('supported'): - required = True - elif re.match(self.genOpts.addExtensions, extname) is not None: - required = True - elif elem.get('version') is not None: - required = re.match(self.genOpts.emitversions, elem.get('version')) is not None - else: - required = True - - return required - - # - # makeCDecls - return C prototype and function pointer typedef for a - # command, as a two-element list of strings. - # cmd - Element containing a tag - def makeCDecls(self, cmd): - """Generate C function pointer typedef for Element""" - proto = cmd.find('proto') - params = cmd.findall('param') - # Begin accumulating prototype and typedef strings - pdecl = self.genOpts.apicall - tdecl = 'typedef ' - # - # Insert the function return type/name. - # For prototypes, add APIENTRY macro before the name - # For typedefs, add (APIENTRY *) around the name and - # use the PFN_cmdnameproc naming convention. - # Done by walking the tree for element by element. - # etree has elem.text followed by (elem[i], elem[i].tail) - # for each child element and any following text - # Leading text - pdecl += noneStr(proto.text) - tdecl += noneStr(proto.text) - # For each child element, if it's a wrap in appropriate - # declaration. Otherwise append its contents and tail contents. - for elem in proto: - text = noneStr(elem.text) - tail = noneStr(elem.tail) - if (elem.tag == 'name'): - pdecl += self.makeProtoName(text, tail) - tdecl += self.makeTypedefName(text, tail) - else: - pdecl += text + tail - tdecl += text + tail - # Now add the parameter declaration list, which is identical - # for prototypes and typedefs. Concatenate all the text from - # a node without the tags. No tree walking required - # since all tags are ignored. - # Uses: self.indentFuncProto - # self.indentFuncPointer - # self.alignFuncParam - # Might be able to doubly-nest the joins, e.g. - # ','.join(('_'.join([l[i] for i in range(0,len(l))]) - n = len(params) - # Indented parameters - if n > 0: - indentdecl = '(\n' - for i in range(0,n): - paramdecl = self.makeCParamDecl(params[i], self.genOpts.alignFuncParam) - if (i < n - 1): - paramdecl += ',\n' - else: - paramdecl += ');' - indentdecl += paramdecl - else: - indentdecl = '(void);' - # Non-indented parameters - paramdecl = '(' - if n > 0: - for i in range(0,n): - paramdecl += ''.join([t for t in params[i].itertext()]) - if (i < n - 1): - paramdecl += ', ' - else: - paramdecl += 'void' - paramdecl += ");"; - return [ pdecl + indentdecl, tdecl + paramdecl ] - # - def newline(self): - write('', file=self.outFile) - - def setRegistry(self, registry): - self.registry = registry - # diff --git a/generator/Vulkan-Headers/registry/genvk.py b/generator/Vulkan-Headers/registry/genvk.py deleted file mode 100644 index 6d7760b..0000000 --- a/generator/Vulkan-Headers/registry/genvk.py +++ /dev/null @@ -1,531 +0,0 @@ -#!/usr/bin/python3 -# -# Copyright (c) 2013-2018 The Khronos Group Inc. -# -# 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. - -import argparse, cProfile, pdb, string, sys, time -from reg import * -from generator import write -from cgenerator import CGeneratorOptions, COutputGenerator -from docgenerator import DocGeneratorOptions, DocOutputGenerator -from extensionmetadocgenerator import ExtensionMetaDocGeneratorOptions, ExtensionMetaDocOutputGenerator -from pygenerator import PyOutputGenerator -from validitygenerator import ValidityOutputGenerator -from hostsyncgenerator import HostSynchronizationOutputGenerator -from extensionStubSource import ExtensionStubSourceOutputGenerator - -# Simple timer functions -startTime = None - -def startTimer(timeit): - global startTime - startTime = time.clock() - -def endTimer(timeit, msg): - global startTime - endTime = time.clock() - if (timeit): - write(msg, endTime - startTime, file=sys.stderr) - startTime = None - -# Turn a list of strings into a regexp string matching exactly those strings -def makeREstring(list, default = None): - if len(list) > 0 or default == None: - return '^(' + '|'.join(list) + ')$' - else: - return default - -# Returns a directory of [ generator function, generator options ] indexed -# by specified short names. The generator options incorporate the following -# parameters: -# -# args is an parsed argument object; see below for the fields that are used. -def makeGenOpts(args): - global genOpts - genOpts = {} - - # Default class of extensions to include, or None - defaultExtensions = args.defaultExtensions - - # Additional extensions to include (list of extensions) - extensions = args.extension - - # Extensions to remove (list of extensions) - removeExtensions = args.removeExtensions - - # Extensions to emit (list of extensions) - emitExtensions = args.emitExtensions - - # Features to include (list of features) - features = args.feature - - # Whether to disable inclusion protect in headers - protect = args.protect - - # Output target directory - directory = args.directory - - # Descriptive names for various regexp patterns used to select - # versions and extensions - allFeatures = allExtensions = '.*' - noFeatures = noExtensions = None - - # Turn lists of names/patterns into matching regular expressions - addExtensionsPat = makeREstring(extensions, None) - removeExtensionsPat = makeREstring(removeExtensions, None) - emitExtensionsPat = makeREstring(emitExtensions, allExtensions) - featuresPat = makeREstring(features, allFeatures) - - # Copyright text prefixing all headers (list of strings). - prefixStrings = [ - '/*', - '** Copyright (c) 2015-2018 The Khronos Group Inc.', - '**', - '** 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.', - '*/', - '' - ] - - # Text specific to Vulkan headers - vkPrefixStrings = [ - '/*', - '** This header is generated from the Khronos Vulkan XML API Registry.', - '**', - '*/', - '' - ] - - # Defaults for generating re-inclusion protection wrappers (or not) - protectFile = protect - protectFeature = protect - protectProto = protect - - # API include files for spec and ref pages - # Overwrites include subdirectories in spec source tree - # The generated include files do not include the calling convention - # macros (apientry etc.), unlike the header files. - # Because the 1.0 core branch includes ref pages for extensions, - # all the extension interfaces need to be generated, even though - # none are used by the core spec itself. - genOpts['apiinc'] = [ - DocOutputGenerator, - DocGeneratorOptions( - filename = 'timeMarker', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = featuresPat, - defaultExtensions = None, - addExtensions = addExtensionsPat, - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat, - prefixText = prefixStrings + vkPrefixStrings, - apicall = '', - apientry = '', - apientryp = '*', - alignFuncParam = 48, - expandEnumerants = False) - ] - - # API names to validate man/api spec includes & links - genOpts['vkapi.py'] = [ - PyOutputGenerator, - DocGeneratorOptions( - filename = 'vkapi.py', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = featuresPat, - defaultExtensions = None, - addExtensions = addExtensionsPat, - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat) - ] - - # API validity files for spec - genOpts['validinc'] = [ - ValidityOutputGenerator, - DocGeneratorOptions( - filename = 'timeMarker', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = featuresPat, - defaultExtensions = None, - addExtensions = addExtensionsPat, - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat) - ] - - # API host sync table files for spec - genOpts['hostsyncinc'] = [ - HostSynchronizationOutputGenerator, - DocGeneratorOptions( - filename = 'timeMarker', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = featuresPat, - defaultExtensions = None, - addExtensions = addExtensionsPat, - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat) - ] - - # Extension stub source dispatcher - # This target is no longer maintained and supported. - # See README.adoc for discussion. - genOpts['vulkan_ext.c'] = [ - ExtensionStubSourceOutputGenerator, - CGeneratorOptions( - filename = 'vulkan_ext.c', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = None, - defaultExtensions = None, - addExtensions = '.*', - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat, - prefixText = prefixStrings + vkPrefixStrings, - alignFuncParam = 48) - ] - - # Extension metainformation for spec extension appendices - genOpts['extinc'] = [ - ExtensionMetaDocOutputGenerator, - ExtensionMetaDocGeneratorOptions( - filename = 'timeMarker', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = None, - defaultExtensions = defaultExtensions, - addExtensions = None, - removeExtensions = None, - emitExtensions = emitExtensionsPat) - ] - - # Platform extensions, in their own header files - # Each element of the platforms[] array defines information for - # generating a single platform: - # [0] is the generated header file name - # [1] is the set of platform extensions to generate - # [2] is additional extensions whose interfaces should be considered, - # but suppressed in the output, to avoid duplicate definitions of - # dependent types like VkDisplayKHR and VkSurfaceKHR which come from - # non-platform extensions. - - # Track all platform extensions, for exclusion from vulkan_core.h - allPlatformExtensions = [] - - # Extensions suppressed for all platforms. - # Covers common WSI extension types. - commonSuppressExtensions = [ 'VK_KHR_display', 'VK_KHR_swapchain' ] - - platforms = [ - [ 'vulkan_android.h', [ 'VK_KHR_android_surface', - 'VK_ANDROID_external_memory_android_hardware_buffer' - ], commonSuppressExtensions ], - [ 'vulkan_ios.h', [ 'VK_MVK_ios_surface' ], commonSuppressExtensions ], - [ 'vulkan_macos.h', [ 'VK_MVK_macos_surface' ], commonSuppressExtensions ], - [ 'vulkan_mir.h', [ 'VK_KHR_mir_surface' ], commonSuppressExtensions ], - [ 'vulkan_vi.h', [ 'VK_NN_vi_surface' ], commonSuppressExtensions ], - [ 'vulkan_wayland.h', [ 'VK_KHR_wayland_surface' ], commonSuppressExtensions ], - [ 'vulkan_win32.h', [ 'VK_.*_win32(|_.*)' ], commonSuppressExtensions + [ 'VK_KHR_external_semaphore', 'VK_KHR_external_memory_capabilities', 'VK_KHR_external_fence', 'VK_KHR_external_fence_capabilities', 'VK_NV_external_memory_capabilities' ] ], - [ 'vulkan_xcb.h', [ 'VK_KHR_xcb_surface' ], commonSuppressExtensions ], - [ 'vulkan_xlib.h', [ 'VK_KHR_xlib_surface' ], commonSuppressExtensions ], - [ 'vulkan_xlib_xrandr.h', [ 'VK_EXT_acquire_xlib_display' ], commonSuppressExtensions ], - ] - - for platform in platforms: - headername = platform[0] - - allPlatformExtensions += platform[1] - - addPlatformExtensionsRE = makeREstring(platform[1] + platform[2]) - emitPlatformExtensionsRE = makeREstring(platform[1]) - - opts = CGeneratorOptions( - filename = headername, - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = None, - defaultExtensions = None, - addExtensions = addPlatformExtensionsRE, - removeExtensions = None, - emitExtensions = emitPlatformExtensionsRE, - prefixText = prefixStrings + vkPrefixStrings, - genFuncPointers = True, - protectFile = protectFile, - protectFeature = False, - protectProto = '#ifndef', - protectProtoStr = 'VK_NO_PROTOTYPES', - apicall = 'VKAPI_ATTR ', - apientry = 'VKAPI_CALL ', - apientryp = 'VKAPI_PTR *', - alignFuncParam = 48) - - genOpts[headername] = [ COutputGenerator, opts ] - - # Header for core API + extensions. - # To generate just the core API, - # change to 'defaultExtensions = None' below. - # - # By default this adds all enabled, non-platform extensions. - # It removes all platform extensions (from the platform headers options - # constructed above) as well as any explicitly specified removals. - - removeExtensionsPat = makeREstring(allPlatformExtensions + removeExtensions, None) - - genOpts['vulkan_core.h'] = [ - COutputGenerator, - CGeneratorOptions( - filename = 'vulkan_core.h', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = featuresPat, - defaultExtensions = defaultExtensions, - addExtensions = None, - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat, - prefixText = prefixStrings + vkPrefixStrings, - genFuncPointers = True, - protectFile = protectFile, - protectFeature = False, - protectProto = '#ifndef', - protectProtoStr = 'VK_NO_PROTOTYPES', - apicall = 'VKAPI_ATTR ', - apientry = 'VKAPI_CALL ', - apientryp = 'VKAPI_PTR *', - alignFuncParam = 48) - ] - - # Unused - vulkan10.h target. - # It is possible to generate a header with just the Vulkan 1.0 + - # extension interfaces defined, but since the promoted KHR extensions - # are now defined in terms of the 1.1 interfaces, such a header is very - # similar to vulkan_core.h. - genOpts['vulkan10.h'] = [ - COutputGenerator, - CGeneratorOptions( - filename = 'vulkan10.h', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = 'VK_VERSION_1_0', - emitversions = 'VK_VERSION_1_0', - defaultExtensions = defaultExtensions, - addExtensions = None, - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat, - prefixText = prefixStrings + vkPrefixStrings, - genFuncPointers = True, - protectFile = protectFile, - protectFeature = False, - protectProto = '#ifndef', - protectProtoStr = 'VK_NO_PROTOTYPES', - apicall = 'VKAPI_ATTR ', - apientry = 'VKAPI_CALL ', - apientryp = 'VKAPI_PTR *', - alignFuncParam = 48) - ] - - genOpts['alias.h'] = [ - COutputGenerator, - CGeneratorOptions( - filename = 'alias.h', - directory = directory, - apiname = 'vulkan', - profile = None, - versions = featuresPat, - emitversions = featuresPat, - defaultExtensions = defaultExtensions, - addExtensions = None, - removeExtensions = removeExtensionsPat, - emitExtensions = emitExtensionsPat, - prefixText = None, - genFuncPointers = False, - protectFile = False, - protectFeature = False, - protectProto = '', - protectProtoStr = '', - apicall = '', - apientry = '', - apientryp = '', - alignFuncParam = 36) - ] - -# Generate a target based on the options in the matching genOpts{} object. -# This is encapsulated in a function so it can be profiled and/or timed. -# The args parameter is an parsed argument object containing the following -# fields that are used: -# target - target to generate -# directory - directory to generate it in -# protect - True if re-inclusion wrappers should be created -# extensions - list of additional extensions to include in generated -# interfaces -def genTarget(args): - global genOpts - - # Create generator options with specified parameters - makeGenOpts(args) - - if (args.target in genOpts.keys()): - createGenerator = genOpts[args.target][0] - options = genOpts[args.target][1] - - if not args.quiet: - write('* Building', options.filename, file=sys.stderr) - write('* options.versions =', options.versions, file=sys.stderr) - write('* options.emitversions =', options.emitversions, file=sys.stderr) - write('* options.defaultExtensions =', options.defaultExtensions, file=sys.stderr) - write('* options.addExtensions =', options.addExtensions, file=sys.stderr) - write('* options.removeExtensions =', options.removeExtensions, file=sys.stderr) - write('* options.emitExtensions =', options.emitExtensions, file=sys.stderr) - - startTimer(args.time) - gen = createGenerator(errFile=errWarn, - warnFile=errWarn, - diagFile=diag) - reg.setGenerator(gen) - reg.apiGen(options) - - if not args.quiet: - write('* Generated', options.filename, file=sys.stderr) - endTimer(args.time, '* Time to generate ' + options.filename + ' =') - else: - write('No generator options for unknown target:', - args.target, file=sys.stderr) - -# -feature name -# -extension name -# For both, "name" may be a single name, or a space-separated list -# of names, or a regular expression. -if __name__ == '__main__': - parser = argparse.ArgumentParser() - - parser.add_argument('-defaultExtensions', action='store', - default='vulkan', - help='Specify a single class of extensions to add to targets') - parser.add_argument('-extension', action='append', - default=[], - help='Specify an extension or extensions to add to targets') - parser.add_argument('-removeExtensions', action='append', - default=[], - help='Specify an extension or extensions to remove from targets') - parser.add_argument('-emitExtensions', action='append', - default=[], - help='Specify an extension or extensions to emit in targets') - parser.add_argument('-feature', action='append', - default=[], - help='Specify a core API feature name or names to add to targets') - parser.add_argument('-debug', action='store_true', - help='Enable debugging') - parser.add_argument('-dump', action='store_true', - help='Enable dump to stderr') - parser.add_argument('-diagfile', action='store', - default=None, - help='Write diagnostics to specified file') - parser.add_argument('-errfile', action='store', - default=None, - help='Write errors and warnings to specified file instead of stderr') - parser.add_argument('-noprotect', dest='protect', action='store_false', - help='Disable inclusion protection in output headers') - parser.add_argument('-profile', action='store_true', - help='Enable profiling') - parser.add_argument('-registry', action='store', - default='vk.xml', - help='Use specified registry file instead of vk.xml') - parser.add_argument('-time', action='store_true', - help='Enable timing') - parser.add_argument('-validate', action='store_true', - help='Enable group validation') - parser.add_argument('-o', action='store', dest='directory', - default='.', - help='Create target and related files in specified directory') - parser.add_argument('target', metavar='target', nargs='?', - help='Specify target') - parser.add_argument('-quiet', action='store_true', default=True, - help='Suppress script output during normal execution.') - parser.add_argument('-verbose', action='store_false', dest='quiet', default=True, - help='Enable script output during normal execution.') - - args = parser.parse_args() - - # This splits arguments which are space-separated lists - args.feature = [name for arg in args.feature for name in arg.split()] - args.extension = [name for arg in args.extension for name in arg.split()] - - # Load & parse registry - reg = Registry() - - startTimer(args.time) - tree = etree.parse(args.registry) - endTimer(args.time, '* Time to make ElementTree =') - - if args.debug: - pdb.run('reg.loadElementTree(tree)') - else: - startTimer(args.time) - reg.loadElementTree(tree) - endTimer(args.time, '* Time to parse ElementTree =') - - if (args.validate): - reg.validateGroups() - - if (args.dump): - write('* Dumping registry to regdump.txt', file=sys.stderr) - reg.dumpReg(filehandle = open('regdump.txt', 'w', encoding='utf-8')) - - # create error/warning & diagnostic files - if (args.errfile): - errWarn = open(args.errfile, 'w', encoding='utf-8') - else: - errWarn = sys.stderr - - if (args.diagfile): - diag = open(args.diagfile, 'w', encoding='utf-8') - else: - diag = None - - if (args.debug): - pdb.run('genTarget(args)') - elif (args.profile): - import cProfile, pstats - cProfile.run('genTarget(args)', 'profile.txt') - p = pstats.Stats('profile.txt') - p.strip_dirs().sort_stats('time').print_stats(50) - else: - genTarget(args) diff --git a/generator/Vulkan-Headers/registry/reg.py b/generator/Vulkan-Headers/registry/reg.py deleted file mode 100644 index c9f92db..0000000 --- a/generator/Vulkan-Headers/registry/reg.py +++ /dev/null @@ -1,1066 +0,0 @@ -#!/usr/bin/python3 -i -# -# Copyright (c) 2013-2018 The Khronos Group Inc. -# -# 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. - -import io,os,pdb,re,string,sys,copy -import xml.etree.ElementTree as etree -from collections import defaultdict - -# matchAPIProfile - returns whether an API and profile -# being generated matches an element's profile -# api - string naming the API to match -# profile - string naming the profile to match -# elem - Element which (may) have 'api' and 'profile' -# attributes to match to. -# If a tag is not present in the Element, the corresponding API -# or profile always matches. -# Otherwise, the tag must exactly match the API or profile. -# Thus, if 'profile' = core: -# with no attribute will match -# will match -# will not match -# Possible match conditions: -# Requested Element -# Profile Profile -# --------- -------- -# None None Always matches -# 'string' None Always matches -# None 'string' Does not match. Can't generate multiple APIs -# or profiles, so if an API/profile constraint -# is present, it must be asked for explicitly. -# 'string' 'string' Strings must match -# -# ** In the future, we will allow regexes for the attributes, -# not just strings, so that api="^(gl|gles2)" will match. Even -# this isn't really quite enough, we might prefer something -# like "gl(core)|gles1(common-lite)". -def matchAPIProfile(api, profile, elem): - """Match a requested API & profile name to a api & profile attributes of an Element""" - match = True - # Match 'api', if present - if ('api' in elem.attrib): - if (api == None): - raise UserWarning("No API requested, but 'api' attribute is present with value '" + - elem.get('api') + "'") - elif (api != elem.get('api')): - # Requested API doesn't match attribute - return False - if ('profile' in elem.attrib): - if (profile == None): - raise UserWarning("No profile requested, but 'profile' attribute is present with value '" + - elem.get('profile') + "'") - elif (profile != elem.get('profile')): - # Requested profile doesn't match attribute - return False - return True - -# BaseInfo - base class for information about a registry feature -# (type/group/enum/command/API/extension). -# required - should this feature be defined during header generation -# (has it been removed by a profile or version)? -# declared - has this feature been defined already? -# elem - etree Element for this feature -# resetState() - reset required/declared to initial values. Used -# prior to generating a new API interface. -# compareElem(info) - return True if self.elem and info.elem have the -# same definition. -class BaseInfo: - """Represents the state of a registry feature, used during API generation""" - def __init__(self, elem): - self.required = False - self.declared = False - self.elem = elem - def resetState(self): - self.required = False - self.declared = False - def compareElem(self, info): - # Just compares the tag and attributes. - # @@ This should be virtualized. In particular, comparing - # tags requires special-casing on the attributes, as 'extnumber' is - # only relevant when 'offset' is present. - selfKeys = sorted(self.elem.keys()) - infoKeys = sorted(info.elem.keys()) - - if selfKeys != infoKeys: - return False - - # Ignore value of 'extname' and 'extnumber', as these will inherently - # be different when redefining the same interface in different feature - # and/or extension blocks. - for key in selfKeys: - if (key != 'extname' and key != 'extnumber' and - (self.elem.get(key) != info.elem.get(key))): - return False - - return True - -# TypeInfo - registry information about a type. No additional state -# beyond BaseInfo is required. -class TypeInfo(BaseInfo): - """Represents the state of a registry type""" - def __init__(self, elem): - BaseInfo.__init__(self, elem) - self.additionalValidity = [] - self.removedValidity = [] - def resetState(self): - BaseInfo.resetState(self) - self.additionalValidity = [] - self.removedValidity = [] - -# GroupInfo - registry information about a group of related enums -# in an block, generally corresponding to a C "enum" type. -class GroupInfo(BaseInfo): - """Represents the state of a registry group""" - def __init__(self, elem): - BaseInfo.__init__(self, elem) - -# EnumInfo - registry information about an enum -# type - numeric type of the value of the tag -# ( '' for GLint, 'u' for GLuint, 'ull' for GLuint64 ) -class EnumInfo(BaseInfo): - """Represents the state of a registry enum""" - def __init__(self, elem): - BaseInfo.__init__(self, elem) - self.type = elem.get('type') - if (self.type == None): - self.type = '' - -# CmdInfo - registry information about a command -class CmdInfo(BaseInfo): - """Represents the state of a registry command""" - def __init__(self, elem): - BaseInfo.__init__(self, elem) - self.additionalValidity = [] - self.removedValidity = [] - def resetState(self): - BaseInfo.resetState(self) - self.additionalValidity = [] - self.removedValidity = [] - -# FeatureInfo - registry information about an API -# or -# name - feature name string (e.g. 'VK_KHR_surface') -# version - feature version number (e.g. 1.2). -# features are unversioned and assigned version number 0. -# ** This is confusingly taken from the 'number' attribute of . -# Needs fixing. -# number - extension number, used for ordering and for -# assigning enumerant offsets. features do -# not have extension numbers and are assigned number 0. -# category - category, e.g. VERSION or khr/vendor tag -# emit - has this feature been defined already? -class FeatureInfo(BaseInfo): - """Represents the state of an API feature (version/extension)""" - def __init__(self, elem): - BaseInfo.__init__(self, elem) - self.name = elem.get('name') - # Determine element category (vendor). Only works - # for elements. - if (elem.tag == 'feature'): - self.category = 'VERSION' - self.version = elem.get('name') - self.versionNumber = elem.get('number') - self.number = "0" - self.supported = None - else: - self.category = self.name.split('_', 2)[1] - self.version = "0" - self.versionNumber = "0" - self.number = elem.get('number') - self.supported = elem.get('supported') - self.emit = False - -from generator import write, GeneratorOptions, OutputGenerator - -# Registry - object representing an API registry, loaded from an XML file -# Members -# tree - ElementTree containing the root -# typedict - dictionary of TypeInfo objects keyed by type name -# groupdict - dictionary of GroupInfo objects keyed by group name -# enumdict - dictionary of EnumInfo objects keyed by enum name -# cmddict - dictionary of CmdInfo objects keyed by command name -# apidict - dictionary of Elements keyed by API name -# extensions - list of Elements -# extdict - dictionary of Elements keyed by extension name -# gen - OutputGenerator object used to write headers / messages -# genOpts - GeneratorOptions object used to control which -# fetures to write and how to format them -# emitFeatures - True to actually emit features for a version / extension, -# or False to just treat them as emitted -# breakPat - regexp pattern to break on when generatng names -# Public methods -# loadElementTree(etree) - load registry from specified ElementTree -# loadFile(filename) - load registry from XML file -# setGenerator(gen) - OutputGenerator to use -# breakOnName() - specify a feature name regexp to break on when -# generating features. -# parseTree() - parse the registry once loaded & create dictionaries -# dumpReg(maxlen, filehandle) - diagnostic to dump the dictionaries -# to specified file handle (default stdout). Truncates type / -# enum / command elements to maxlen characters (default 80) -# generator(g) - specify the output generator object -# apiGen(apiname, genOpts) - generate API headers for the API type -# and profile specified in genOpts, but only for the versions and -# extensions specified there. -# apiReset() - call between calls to apiGen() to reset internal state -# Private methods -# addElementInfo(elem,info,infoName,dictionary) - add feature info to dict -# lookupElementInfo(fname,dictionary) - lookup feature info in dict -class Registry: - """Represents an API registry loaded from XML""" - def __init__(self): - self.tree = None - self.typedict = {} - self.groupdict = {} - self.enumdict = {} - self.cmddict = {} - self.apidict = {} - self.extensions = [] - self.requiredextensions = [] # Hack - can remove it after validity generator goes away - self.validextensionstructs = defaultdict(list) - self.extdict = {} - # A default output generator, so commands prior to apiGen can report - # errors via the generator object. - self.gen = OutputGenerator() - self.genOpts = None - self.emitFeatures = False - self.breakPat = None - # self.breakPat = re.compile('VkFenceImportFlagBits.*') - def loadElementTree(self, tree): - """Load ElementTree into a Registry object and parse it""" - self.tree = tree - self.parseTree() - def loadFile(self, file): - """Load an API registry XML file into a Registry object and parse it""" - self.tree = etree.parse(file) - self.parseTree() - def setGenerator(self, gen): - """Specify output generator object. None restores the default generator""" - self.gen = gen - self.gen.setRegistry(self) - - # addElementInfo - add information about an element to the - # corresponding dictionary - # elem - ///// Element - # info - corresponding {Type|Group|Enum|Cmd|Feature}Info object - # infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' - # dictionary - self.{type|group|enum|cmd|api|ext}dict - # If the Element has an 'api' attribute, the dictionary key is the - # tuple (name,api). If not, the key is the name. 'name' is an - # attribute of the Element - def addElementInfo(self, elem, info, infoName, dictionary): - # self.gen.logMsg('diag', 'Adding ElementInfo.required =', - # info.required, 'name =', elem.get('name')) - - if ('api' in elem.attrib): - key = (elem.get('name'),elem.get('api')) - else: - key = elem.get('name') - if key in dictionary: - if not dictionary[key].compareElem(info): - self.gen.logMsg('warn', 'Attempt to redefine', key, - 'with different value (this may be benign)') - #else: - # self.gen.logMsg('warn', 'Benign redefinition of', key, - # 'with identical value') - else: - dictionary[key] = info - # - # lookupElementInfo - find a {Type|Enum|Cmd}Info object by name. - # If an object qualified by API name exists, use that. - # fname - name of type / enum / command - # dictionary - self.{type|enum|cmd}dict - def lookupElementInfo(self, fname, dictionary): - key = (fname, self.genOpts.apiname) - if (key in dictionary): - # self.gen.logMsg('diag', 'Found API-specific element for feature', fname) - return dictionary[key] - elif (fname in dictionary): - # self.gen.logMsg('diag', 'Found generic element for feature', fname) - return dictionary[fname] - else: - return None - def breakOnName(self, regexp): - self.breakPat = re.compile(regexp) - def parseTree(self): - """Parse the registry Element, once created""" - # This must be the Element for the root - self.reg = self.tree.getroot() - # - # Create dictionary of registry types from toplevel tags - # and add 'name' attribute to each tag (where missing) - # based on its element. - # - # There's usually one block; more are OK - # Required attributes: 'name' or nested tag contents - self.typedict = {} - for type in self.reg.findall('types/type'): - # If the doesn't already have a 'name' attribute, set - # it from contents of its tag. - if (type.get('name') == None): - type.attrib['name'] = type.find('name').text - self.addElementInfo(type, TypeInfo(type), 'type', self.typedict) - # - # Create dictionary of registry enum groups from tags. - # - # Required attributes: 'name'. If no name is given, one is - # generated, but that group can't be identified and turned into an - # enum type definition - it's just a container for tags. - self.groupdict = {} - for group in self.reg.findall('enums'): - self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict) - # - # Create dictionary of registry enums from tags - # - # tags usually define different namespaces for the values - # defined in those tags, but the actual names all share the - # same dictionary. - # Required attributes: 'name', 'value' - # For containing which have type="enum" or type="bitmask", - # tag all contained s are required. This is a stopgap until - # a better scheme for tagging core and extension enums is created. - self.enumdict = {} - for enums in self.reg.findall('enums'): - required = (enums.get('type') != None) - for enum in enums.findall('enum'): - enumInfo = EnumInfo(enum) - enumInfo.required = required - self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) - # self.gen.logMsg('diag', 'parseTree: marked req =', - # required, 'for', enum.get('name')) - # - # Create dictionary of registry commands from tags - # and add 'name' attribute to each tag (where missing) - # based on its element. - # - # There's usually only one block; more are OK. - # Required attributes: 'name' or tag contents - self.cmddict = {} - # List of commands which alias others. Contains - # [ aliasName, element ] - # for each alias - cmdAlias = [] - for cmd in self.reg.findall('commands/command'): - # If the doesn't already have a 'name' attribute, set - # it from contents of its tag. - name = cmd.get('name') - if name == None: - name = cmd.attrib['name'] = cmd.find('proto/name').text - ci = CmdInfo(cmd) - self.addElementInfo(cmd, ci, 'command', self.cmddict) - alias = cmd.get('alias') - if alias: - cmdAlias.append([name, alias, cmd]) - # Now loop over aliases, injecting a copy of the aliased command's - # Element with the aliased prototype name replaced with the command - # name - if it exists. - for (name, alias, cmd) in cmdAlias: - if alias in self.cmddict: - #@ pdb.set_trace() - aliasInfo = self.cmddict[alias] - cmdElem = copy.deepcopy(aliasInfo.elem) - cmdElem.find('proto/name').text = name - cmdElem.attrib['name'] = name - cmdElem.attrib['alias'] = alias - ci = CmdInfo(cmdElem) - # Replace the dictionary entry for the CmdInfo element - self.cmddict[name] = ci - - #@ newString = etree.tostring(base, encoding="unicode").replace(aliasValue, aliasName) - #@elem.append(etree.fromstring(replacement)) - else: - self.gen.logMsg('warn', 'No matching found for command', - cmd.get('name'), 'alias', alias) - - # - # Create dictionaries of API and extension interfaces - # from toplevel and tags. - # - self.apidict = {} - for feature in self.reg.findall('feature'): - featureInfo = FeatureInfo(feature) - self.addElementInfo(feature, featureInfo, 'feature', self.apidict) - - # Add additional enums defined only in tags - # to the corresponding core type. - # When seen here, the element, processed to contain the - # numeric enum value, is added to the corresponding - # element, as well as adding to the enum dictionary. It is - # *removed* from the element it is introduced in. - # Not doing this will cause spurious genEnum() - # calls to be made in output generation, and it's easier - # to handle here than in genEnum(). - # - # In lxml.etree, an Element can have only one parent, so the - # append() operation also removes the element. But in Python's - # ElementTree package, an Element can have multiple parents. So - # it must be explicitly removed from the tag, leading - # to the nested loop traversal of / elements - # below. - # - # This code also adds a 'version' attribute containing the - # api version. - # - # For tags which are actually just constants, if there's - # no 'extends' tag but there is a 'value' or 'bitpos' tag, just - # add an EnumInfo record to the dictionary. That works because - # output generation of constants is purely dependency-based, and - # doesn't need to iterate through the XML tags. - # - for elem in feature.findall('require'): - for enum in elem.findall('enum'): - addEnumInfo = False - groupName = enum.get('extends') - if (groupName != None): - # self.gen.logMsg('diag', 'Found extension enum', - # enum.get('name')) - # Add version number attribute to the element - enum.attrib['version'] = featureInfo.version - # Look up the GroupInfo with matching groupName - if (groupName in self.groupdict.keys()): - # self.gen.logMsg('diag', 'Matching group', - # groupName, 'found, adding element...') - gi = self.groupdict[groupName] - gi.elem.append(enum) - # Remove element from parent tag - # This should be a no-op in lxml.etree - elem.remove(enum) - else: - self.gen.logMsg('warn', 'NO matching group', - groupName, 'for enum', enum.get('name'), 'found.') - addEnumInfo = True - elif (enum.get('value') or enum.get('bitpos') or enum.get('alias')): - # self.gen.logMsg('diag', 'Adding extension constant "enum"', - # enum.get('name')) - addEnumInfo = True - if (addEnumInfo): - enumInfo = EnumInfo(enum) - self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) - - self.extensions = self.reg.findall('extensions/extension') - self.extdict = {} - for feature in self.extensions: - featureInfo = FeatureInfo(feature) - self.addElementInfo(feature, featureInfo, 'extension', self.extdict) - - # Add additional enums defined only in tags - # to the corresponding core type. - # Algorithm matches that of enums in a "feature" tag as above. - # - # This code also adds a 'extnumber' attribute containing the - # extension number, used for enumerant value calculation. - # - for elem in feature.findall('require'): - for enum in elem.findall('enum'): - addEnumInfo = False - groupName = enum.get('extends') - if (groupName != None): - # self.gen.logMsg('diag', 'Found extension enum', - # enum.get('name')) - - # Add block's extension number attribute to - # the element unless specified explicitly, such - # as when redefining an enum in another extension. - extnumber = enum.get('extnumber') - if not extnumber: - enum.attrib['extnumber'] = featureInfo.number - - enum.attrib['extname'] = featureInfo.name - enum.attrib['supported'] = featureInfo.supported - # Look up the GroupInfo with matching groupName - if (groupName in self.groupdict.keys()): - # self.gen.logMsg('diag', 'Matching group', - # groupName, 'found, adding element...') - gi = self.groupdict[groupName] - gi.elem.append(enum) - # Remove element from parent tag - # This should be a no-op in lxml.etree - elem.remove(enum) - else: - self.gen.logMsg('warn', 'NO matching group', - groupName, 'for enum', enum.get('name'), 'found.') - addEnumInfo = True - elif (enum.get('value') or enum.get('bitpos') or enum.get('alias')): - # self.gen.logMsg('diag', 'Adding extension constant "enum"', - # enum.get('name')) - addEnumInfo = True - if (addEnumInfo): - enumInfo = EnumInfo(enum) - self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) - - # Construct a "validextensionstructs" list for parent structures - # based on "structextends" tags in child structures - for type in self.reg.findall('types/type'): - parentStructs = type.get('structextends') - if (parentStructs != None): - for parent in parentStructs.split(','): - # self.gen.logMsg('diag', type.get('name'), 'extends', parent) - self.validextensionstructs[parent].append(type.get('name')) - # Sort the lists so they don't depend on the XML order - for parent in self.validextensionstructs: - self.validextensionstructs[parent].sort() - - def dumpReg(self, maxlen = 120, filehandle = sys.stdout): - """Dump all the dictionaries constructed from the Registry object""" - write('***************************************', file=filehandle) - write(' ** Dumping Registry contents **', file=filehandle) - write('***************************************', file=filehandle) - write('// Types', file=filehandle) - for name in self.typedict: - tobj = self.typedict[name] - write(' Type', name, '->', etree.tostring(tobj.elem)[0:maxlen], file=filehandle) - write('// Groups', file=filehandle) - for name in self.groupdict: - gobj = self.groupdict[name] - write(' Group', name, '->', etree.tostring(gobj.elem)[0:maxlen], file=filehandle) - write('// Enums', file=filehandle) - for name in self.enumdict: - eobj = self.enumdict[name] - write(' Enum', name, '->', etree.tostring(eobj.elem)[0:maxlen], file=filehandle) - write('// Commands', file=filehandle) - for name in self.cmddict: - cobj = self.cmddict[name] - write(' Command', name, '->', etree.tostring(cobj.elem)[0:maxlen], file=filehandle) - write('// APIs', file=filehandle) - for key in self.apidict: - write(' API Version ', key, '->', - etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle) - write('// Extensions', file=filehandle) - for key in self.extdict: - write(' Extension', key, '->', - etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle) - # write('***************************************', file=filehandle) - # write(' ** Dumping XML ElementTree **', file=filehandle) - # write('***************************************', file=filehandle) - # write(etree.tostring(self.tree.getroot(),pretty_print=True), file=filehandle) - # - # typename - name of type - # required - boolean (to tag features as required or not) - def markTypeRequired(self, typename, required): - """Require (along with its dependencies) or remove (but not its dependencies) a type""" - self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required) - # Get TypeInfo object for tag corresponding to typename - type = self.lookupElementInfo(typename, self.typedict) - if (type != None): - if (required): - # Tag type dependencies in 'alias' and 'required' attributes as - # required. This DOES NOT un-tag dependencies in a - # tag. See comments in markRequired() below for the reason. - for attrib in [ 'requires', 'alias' ]: - depname = type.elem.get(attrib) - if depname: - self.gen.logMsg('diag', 'Generating dependent type', - depname, 'for', attrib, 'type', typename) - # Don't recurse on self-referential structures. - if (typename != depname): - self.markTypeRequired(depname, required) - else: - self.gen.logMsg('diag', 'type', typename, 'is self-referential') - # Tag types used in defining this type (e.g. in nested - # tags) - # Look for in entire tree, - # not just immediate children - for subtype in type.elem.findall('.//type'): - self.gen.logMsg('diag', 'markRequired: type requires dependent ', subtype.text) - if (typename != subtype.text): - self.markTypeRequired(subtype.text, required) - else: - self.gen.logMsg('diag', 'type', typename, 'is self-referential') - # Tag enums used in defining this type, for example in - # member[MEMBER_SIZE] - for subenum in type.elem.findall('.//enum'): - self.gen.logMsg('diag', 'markRequired: type requires dependent ', subenum.text) - self.markEnumRequired(subenum.text, required) - type.required = required - else: - self.gen.logMsg('warn', 'type:', typename , 'IS NOT DEFINED') - # - # enumname - name of enum - # required - boolean (to tag features as required or not) - def markEnumRequired(self, enumname, required): - self.gen.logMsg('diag', 'tagging enum:', enumname, '-> required =', required) - enum = self.lookupElementInfo(enumname, self.enumdict) - if (enum != None): - enum.required = required - # Tag enum dependencies in 'alias' attribute as required - depname = enum.elem.get('alias') - if depname: - self.gen.logMsg('diag', 'Generating dependent enum', - depname, 'for alias', enumname, 'required =', enum.required) - self.markEnumRequired(depname, required) - else: - self.gen.logMsg('warn', 'enum:', enumname , 'IS NOT DEFINED') - # - # cmdname - name of command - # required - boolean (to tag features as required or not) - def markCmdRequired(self, cmdname, required): - self.gen.logMsg('diag', 'tagging command:', cmdname, '-> required =', required) - cmd = self.lookupElementInfo(cmdname, self.cmddict) - if (cmd != None): - cmd.required = required - # Tag command dependencies in 'alias' attribute as required - depname = cmd.elem.get('alias') - if depname: - self.gen.logMsg('diag', 'Generating dependent command', - depname, 'for alias', cmdname) - self.markCmdRequired(depname, required) - # Tag all parameter types of this command as required. - # This DOES NOT remove types of commands in a - # tag, because many other commands may use the same type. - # We could be more clever and reference count types, - # instead of using a boolean. - if (required): - # Look for in entire tree, - # not just immediate children - for type in cmd.elem.findall('.//type'): - self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type.text) - self.markTypeRequired(type.text, required) - else: - self.gen.logMsg('warn', 'command:', name, 'IS NOT DEFINED') - # - # features - Element for or tag - # required - boolean (to tag features as required or not) - def markRequired(self, features, required): - """Require or remove features specified in the Element""" - self.gen.logMsg('diag', 'markRequired (features = , required =', required, ')') - # Loop over types, enums, and commands in the tag - # @@ It would be possible to respect 'api' and 'profile' attributes - # in individual features, but that's not done yet. - for typeElem in features.findall('type'): - self.markTypeRequired(typeElem.get('name'), required) - for enumElem in features.findall('enum'): - self.markEnumRequired(enumElem.get('name'), required) - for cmdElem in features.findall('command'): - self.markCmdRequired(cmdElem.get('name'), required) - # - # interface - Element for or , containing - # and tags - # api - string specifying API name being generated - # profile - string specifying API profile being generated - def requireAndRemoveFeatures(self, interface, api, profile): - """Process and tags for a or """ - # marks things that are required by this version/profile - for feature in interface.findall('require'): - if (matchAPIProfile(api, profile, feature)): - self.markRequired(feature,True) - # marks things that are removed by this version/profile - for feature in interface.findall('remove'): - if (matchAPIProfile(api, profile, feature)): - self.markRequired(feature,False) - - def assignAdditionalValidity(self, interface, api, profile): - # - # Loop over all usage inside all tags. - for feature in interface.findall('require'): - if (matchAPIProfile(api, profile, feature)): - for v in feature.findall('usage'): - if v.get('command'): - self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v)) - if v.get('struct'): - self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v)) - - # - # Loop over all usage inside all tags. - for feature in interface.findall('remove'): - if (matchAPIProfile(api, profile, feature)): - for v in feature.findall('usage'): - if v.get('command'): - self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v)) - if v.get('struct'): - self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v)) - - # - # generateFeature - generate a single type / enum group / enum / command, - # and all its dependencies as needed. - # fname - name of feature (//) - # ftype - type of feature, 'type' | 'enum' | 'command' - # dictionary - of *Info objects - self.{type|enum|cmd}dict - def generateFeature(self, fname, ftype, dictionary): - #@ # Break to debugger on matching name pattern - #@ if self.breakPat and re.match(self.breakPat, fname): - #@ pdb.set_trace() - - self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname) - f = self.lookupElementInfo(fname, dictionary) - if (f == None): - # No such feature. This is an error, but reported earlier - self.gen.logMsg('diag', 'No entry found for feature', fname, - 'returning!') - return - # - # If feature isn't required, or has already been declared, return - if (not f.required): - self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)') - return - if (f.declared): - self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)') - return - # Always mark feature declared, as though actually emitted - f.declared = True - - # Determine if this is an alias, and of what, if so - alias = f.elem.get('alias') - if alias: - self.gen.logMsg('diag', fname, 'is an alias of', alias) - - # - # Pull in dependent declaration(s) of the feature. - # For types, there may be one type in the 'required' attribute of - # the element, one in the 'alias' attribute, and many in - # imbedded and tags within the element. - # For commands, there may be many in tags within the element. - # For enums, no dependencies are allowed (though perhaps if you - # have a uint64 enum, it should require that type). - genProc = None - if (ftype == 'type'): - genProc = self.gen.genType - - # Generate type dependencies in 'alias' and 'required' attributes - if alias: - self.generateFeature(alias, 'type', self.typedict) - requires = f.elem.get('requires') - if requires: - self.generateFeature(requires, 'type', self.typedict) - - # Generate types used in defining this type (e.g. in nested - # tags) - # Look for in entire tree, - # not just immediate children - for subtype in f.elem.findall('.//type'): - self.gen.logMsg('diag', 'Generating required dependent ', - subtype.text) - self.generateFeature(subtype.text, 'type', self.typedict) - - # Generate enums used in defining this type, for example in - # member[MEMBER_SIZE] - for subtype in f.elem.findall('.//enum'): - self.gen.logMsg('diag', 'Generating required dependent ', - subtype.text) - self.generateFeature(subtype.text, 'enum', self.enumdict) - - # If the type is an enum group, look up the corresponding - # group in the group dictionary and generate that instead. - if (f.elem.get('category') == 'enum'): - self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead') - group = self.lookupElementInfo(fname, self.groupdict) - if alias != None: - # An alias of another group name. - # Pass to genGroup with 'alias' parameter = aliased name - self.gen.logMsg('diag', 'Generating alias', fname, - 'for enumerated type', alias) - # Now, pass the *aliased* GroupInfo to the genGroup, but - # with an additional parameter which is the alias name. - genProc = self.gen.genGroup - f = self.lookupElementInfo(alias, self.groupdict) - elif group == None: - self.gen.logMsg('warn', 'Skipping enum type', fname, - ': No matching enumerant group') - return - else: - genProc = self.gen.genGroup - f = group - - #@ The enum group is not ready for generation. At this - #@ point, it contains all tags injected by - #@ tags without any verification of whether - #@ they're required or not. It may also contain - #@ duplicates injected by multiple consistent - #@ definitions of an . - - #@ Pass over each enum, marking its enumdict[] entry as - #@ required or not. Mark aliases of enums as required, - #@ too. - - enums = group.elem.findall('enum') - - self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname) - - # Check for required enums, including aliases - # LATER - Check for, report, and remove duplicates? - enumAliases = [] - for elem in enums: - name = elem.get('name') - - required = False - - extname = elem.get('extname') - version = elem.get('version') - if extname is not None: - # 'supported' attribute was injected when the element was - # moved into the group in Registry.parseTree() - if self.genOpts.defaultExtensions == elem.get('supported'): - required = True - elif re.match(self.genOpts.addExtensions, extname) is not None: - required = True - elif version is not None: - required = re.match(self.genOpts.emitversions, version) is not None - else: - required = True - - self.gen.logMsg('diag', '* required =', required, 'for', name) - if required: - # Mark this element as required (in the element, not the EnumInfo) - elem.attrib['required'] = 'true' - # If it's an alias, track that for later use - enumAlias = elem.get('alias') - if enumAlias: - enumAliases.append(enumAlias) - for elem in enums: - name = elem.get('name') - if name in enumAliases: - elem.attrib['required'] = 'true' - self.gen.logMsg('diag', '* also need to require alias', name) - elif (ftype == 'command'): - # Generate command dependencies in 'alias' attribute - if alias: - self.generateFeature(alias, 'command', self.cmddict) - - genProc = self.gen.genCmd - for type in f.elem.findall('.//type'): - depname = type.text - self.gen.logMsg('diag', 'Generating required parameter type', - depname) - self.generateFeature(depname, 'type', self.typedict) - elif (ftype == 'enum'): - # Generate enum dependencies in 'alias' attribute - if alias: - self.generateFeature(alias, 'enum', self.enumdict) - genProc = self.gen.genEnum - - # Actually generate the type only if emitting declarations - if self.emitFeatures: - self.gen.logMsg('diag', 'Emitting', ftype, fname, 'declaration') - genProc(f, fname, alias) - else: - self.gen.logMsg('diag', 'Skipping', ftype, fname, - '(should not be emitted)') - # - # generateRequiredInterface - generate all interfaces required - # by an API version or extension - # interface - Element for or - def generateRequiredInterface(self, interface): - """Generate required C interface for specified API version/extension""" - - # - # Loop over all features inside all tags. - for features in interface.findall('require'): - for t in features.findall('type'): - self.generateFeature(t.get('name'), 'type', self.typedict) - for e in features.findall('enum'): - self.generateFeature(e.get('name'), 'enum', self.enumdict) - for c in features.findall('command'): - self.generateFeature(c.get('name'), 'command', self.cmddict) - - # - # apiGen(genOpts) - generate interface for specified versions - # genOpts - GeneratorOptions object with parameters used - # by the Generator object. - def apiGen(self, genOpts): - """Generate interfaces for the specified API type and range of versions""" - # - self.gen.logMsg('diag', '*******************************************') - self.gen.logMsg('diag', ' Registry.apiGen file:', genOpts.filename, - 'api:', genOpts.apiname, - 'profile:', genOpts.profile) - self.gen.logMsg('diag', '*******************************************') - # - self.genOpts = genOpts - # Reset required/declared flags for all features - self.apiReset() - # - # Compile regexps used to select versions & extensions - regVersions = re.compile(self.genOpts.versions) - regEmitVersions = re.compile(self.genOpts.emitversions) - regAddExtensions = re.compile(self.genOpts.addExtensions) - regRemoveExtensions = re.compile(self.genOpts.removeExtensions) - regEmitExtensions = re.compile(self.genOpts.emitExtensions) - # - # Get all matching API feature names & add to list of FeatureInfo - # Note we used to select on feature version attributes, not names. - features = [] - apiMatch = False - for key in self.apidict: - fi = self.apidict[key] - api = fi.elem.get('api') - if (api == self.genOpts.apiname): - apiMatch = True - if (regVersions.match(fi.name)): - # Matches API & version #s being generated. Mark for - # emission and add to the features[] list . - # @@ Could use 'declared' instead of 'emit'? - fi.emit = (regEmitVersions.match(fi.name) != None) - features.append(fi) - if (not fi.emit): - self.gen.logMsg('diag', 'NOT tagging feature api =', api, - 'name =', fi.name, 'version =', fi.version, - 'for emission (does not match emitversions pattern)') - else: - self.gen.logMsg('diag', 'Including feature api =', api, - 'name =', fi.name, 'version =', fi.version, - 'for emission (matches emitversions pattern)') - else: - self.gen.logMsg('diag', 'NOT including feature api =', api, - 'name =', fi.name, 'version =', fi.version, - '(does not match requested versions)') - else: - self.gen.logMsg('diag', 'NOT including feature api =', api, - 'name =', fi.name, - '(does not match requested API)') - if (not apiMatch): - self.gen.logMsg('warn', 'No matching API versions found!') - # - # Get all matching extensions, in order by their extension number, - # and add to the list of features. - # Start with extensions tagged with 'api' pattern matching the API - # being generated. Add extensions matching the pattern specified in - # regExtensions, then remove extensions matching the pattern - # specified in regRemoveExtensions - for (extName,ei) in sorted(self.extdict.items(),key = lambda x : x[1].number): - extName = ei.name - include = False - # - # Include extension if defaultExtensions is not None and if the - # 'supported' attribute matches defaultExtensions. The regexp in - # 'supported' must exactly match defaultExtensions, so bracket - # it with ^(pat)$. - pat = '^(' + ei.elem.get('supported') + ')$' - if (self.genOpts.defaultExtensions and - re.match(pat, self.genOpts.defaultExtensions)): - self.gen.logMsg('diag', 'Including extension', - extName, "(defaultExtensions matches the 'supported' attribute)") - include = True - # - # Include additional extensions if the extension name matches - # the regexp specified in the generator options. This allows - # forcing extensions into an interface even if they're not - # tagged appropriately in the registry. - if (regAddExtensions.match(extName) != None): - self.gen.logMsg('diag', 'Including extension', - extName, '(matches explicitly requested extensions to add)') - include = True - # Remove extensions if the name matches the regexp specified - # in generator options. This allows forcing removal of - # extensions from an interface even if they're tagged that - # way in the registry. - if (regRemoveExtensions.match(extName) != None): - self.gen.logMsg('diag', 'Removing extension', - extName, '(matches explicitly requested extensions to remove)') - include = False - # - # If the extension is to be included, add it to the - # extension features list. - if (include): - ei.emit = (regEmitExtensions.match(extName) != None) - features.append(ei) - if (not ei.emit): - self.gen.logMsg('diag', 'NOT tagging extension', - extName, - 'for emission (does not match emitextensions pattern)') - # Hack - can be removed when validity generator goes away - # (Jon) I'm not sure what this does, or if it should respect - # the ei.emit flag above. - self.requiredextensions.append(extName) - else: - self.gen.logMsg('diag', 'NOT including extension', - extName, '(does not match api attribute or explicitly requested extensions)') - # - # Sort the extension features list, if a sort procedure is defined - if (self.genOpts.sortProcedure): - self.genOpts.sortProcedure(features) - # - # Pass 1: loop over requested API versions and extensions tagging - # types/commands/features as required (in an block) or no - # longer required (in an block). It is possible to remove - # a feature in one version and restore it later by requiring it in - # a later version. - # If a profile other than 'None' is being generated, it must - # match the profile attribute (if any) of the and - # tags. - self.gen.logMsg('diag', '*******PASS 1: TAG FEATURES **********') - for f in features: - self.gen.logMsg('diag', 'PASS 1: Tagging required and removed features for', - f.name) - self.requireAndRemoveFeatures(f.elem, self.genOpts.apiname, self.genOpts.profile) - self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile) - # - # Pass 2: loop over specified API versions and extensions printing - # declarations for required things which haven't already been - # generated. - self.gen.logMsg('diag', '*******PASS 2: GENERATE INTERFACES FOR FEATURES **********') - self.gen.beginFile(self.genOpts) - for f in features: - self.gen.logMsg('diag', 'PASS 2: Generating interface for', - f.name) - emit = self.emitFeatures = f.emit - if (not emit): - self.gen.logMsg('diag', 'PASS 2: NOT declaring feature', - f.elem.get('name'), 'because it is not tagged for emission') - # Generate the interface (or just tag its elements as having been - # emitted, if they haven't been). - self.gen.beginFeature(f.elem, emit) - self.generateRequiredInterface(f.elem) - self.gen.endFeature() - self.gen.endFile() - # - # apiReset - use between apiGen() calls to reset internal state - # - def apiReset(self): - """Reset type/enum/command dictionaries before generating another API""" - for type in self.typedict: - self.typedict[type].resetState() - for enum in self.enumdict: - self.enumdict[enum].resetState() - for cmd in self.cmddict: - self.cmddict[cmd].resetState() - for cmd in self.apidict: - self.apidict[cmd].resetState() - # - # validateGroups - check that group= attributes match actual groups - # - def validateGroups(self): - """Validate group= attributes on and tags""" - # Keep track of group names not in tags - badGroup = {} - self.gen.logMsg('diag', 'VALIDATING GROUP ATTRIBUTES ***') - for cmd in self.reg.findall('commands/command'): - proto = cmd.find('proto') - funcname = cmd.find('proto/name').text - if ('group' in proto.attrib.keys()): - group = proto.get('group') - # self.gen.logMsg('diag', 'Command ', funcname, ' has return group ', group) - if (group not in self.groupdict.keys()): - # self.gen.logMsg('diag', 'Command ', funcname, ' has UNKNOWN return group ', group) - if (group not in badGroup.keys()): - badGroup[group] = 1 - else: - badGroup[group] = badGroup[group] + 1 - for param in cmd.findall('param'): - pname = param.find('name') - if (pname != None): - pname = pname.text - else: - pname = type.get('name') - if ('group' in param.attrib.keys()): - group = param.get('group') - if (group not in self.groupdict.keys()): - # self.gen.logMsg('diag', 'Command ', funcname, ' param ', pname, ' has UNKNOWN group ', group) - if (group not in badGroup.keys()): - badGroup[group] = 1 - else: - badGroup[group] = badGroup[group] + 1 - if (len(badGroup.keys()) > 0): - self.gen.logMsg('diag', 'SUMMARY OF UNRECOGNIZED GROUPS ***') - for key in sorted(badGroup.keys()): - self.gen.logMsg('diag', ' ', key, ' occurred ', badGroup[key], ' times') diff --git a/generator/Vulkan-Headers/registry/validusage.json b/generator/Vulkan-Headers/registry/validusage.json deleted file mode 100644 index 1bd6b30..0000000 --- a/generator/Vulkan-Headers/registry/validusage.json +++ /dev/null @@ -1,19076 +0,0 @@ -{ - "version info": { - "schema version": 2, - "api version": "1.1.79", - "comment": "from git branch: master commit: ff9357a4bad5fa49b99b9d3f69d254e2a3f0f575", - "date": "2018-07-02 20:23:28Z" - }, - "validation": { - "vkGetInstanceProcAddr": { - "core": [ - { - "vuid": "VUID-vkGetInstanceProcAddr-instance-parameter", - "text": " If instance is not NULL, instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkGetInstanceProcAddr-pName-parameter", - "text": " pName must be a null-terminated UTF-8 string" - } - ] - }, - "vkGetDeviceProcAddr": { - "core": [ - { - "vuid": "VUID-vkGetDeviceProcAddr-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDeviceProcAddr-pName-parameter", - "text": " pName must be a null-terminated UTF-8 string" - } - ] - }, - "vkEnumerateInstanceVersion": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkEnumerateInstanceVersion-pApiVersion-parameter", - "text": " pApiVersion must be a valid pointer to a uint32_t value" - } - ] - }, - "vkCreateInstance": { - "core": [ - { - "vuid": "VUID-vkCreateInstance-ppEnabledExtensionNames-01388", - "text": " All &amp;lt;&amp;lt;extended-functionality-extensions-dependencies, required extensions&amp;gt;&amp;gt; for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list." - }, - { - "vuid": "VUID-vkCreateInstance-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateInstance-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateInstance-pInstance-parameter", - "text": " pInstance must be a valid pointer to a VkInstance handle" - } - ] - }, - "VkInstanceCreateInfo": { - "core": [ - { - "vuid": "VUID-VkInstanceCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO" - }, - { - "vuid": "VUID-VkInstanceCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT, VkDebugUtilsMessengerCreateInfoEXT, or VkValidationFlagsEXT" - }, - { - "vuid": "VUID-VkInstanceCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkInstanceCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkInstanceCreateInfo-pApplicationInfo-parameter", - "text": " If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid VkApplicationInfo structure" - }, - { - "vuid": "VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter", - "text": " If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings" - }, - { - "vuid": "VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter", - "text": " If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings" - } - ] - }, - "VkValidationFlagsEXT": { - "(VK_EXT_validation_flags)": [ - { - "vuid": "VUID-VkValidationFlagsEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT" - }, - { - "vuid": "VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter", - "text": " pDisabledValidationChecks must be a valid pointer to an array of disabledValidationCheckCount VkValidationCheckEXT values" - }, - { - "vuid": "VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength", - "text": " disabledValidationCheckCount must be greater than 0" - } - ] - }, - "VkApplicationInfo": { - "core": [ - { - "vuid": "VUID-VkApplicationInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO" - }, - { - "vuid": "VUID-VkApplicationInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkApplicationInfo-pApplicationName-parameter", - "text": " If pApplicationName is not NULL, pApplicationName must be a null-terminated UTF-8 string" - }, - { - "vuid": "VUID-VkApplicationInfo-pEngineName-parameter", - "text": " If pEngineName is not NULL, pEngineName must be a null-terminated UTF-8 string" - } - ] - }, - "vkDestroyInstance": { - "core": [ - { - "vuid": "VUID-vkDestroyInstance-instance-00629", - "text": " All child objects created using instance must have been destroyed prior to destroying instance" - }, - { - "vuid": "VUID-vkDestroyInstance-instance-00630", - "text": " If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyInstance-instance-00631", - "text": " If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyInstance-instance-parameter", - "text": " If instance is not NULL, instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkDestroyInstance-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - } - ] - }, - "vkEnumeratePhysicalDevices": { - "core": [ - { - "vuid": "VUID-vkEnumeratePhysicalDevices-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter", - "text": " pPhysicalDeviceCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter", - "text": " If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles" - } - ] - }, - "vkGetPhysicalDeviceProperties": { - "core": [ - { - "vuid": "VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceProperties-pProperties-parameter", - "text": " pProperties must be a valid pointer to a VkPhysicalDeviceProperties structure" - } - ] - }, - "vkGetPhysicalDeviceProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter", - "text": " pProperties must be a valid pointer to a VkPhysicalDeviceProperties2 structure" - } - ] - }, - "VkPhysicalDeviceProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkPhysicalDeviceProperties2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2" - }, - { - "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceSubgroupProperties, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" - }, - { - "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - } - ] - }, - "VkPhysicalDeviceIDProperties": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities,VK_KHR_external_semaphore_capabilities,VK_KHR_external_fence_capabilities)": [ - { - "vuid": "VUID-VkPhysicalDeviceIDProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES" - } - ] - }, - "vkGetPhysicalDeviceQueueFamilyProperties": { - "core": [ - { - "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter", - "text": " pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter", - "text": " If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures" - } - ] - }, - "vkGetPhysicalDeviceQueueFamilyProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter", - "text": " pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter", - "text": " If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties2 structures" - } - ] - }, - "VkQueueFamilyProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkQueueFamilyProperties2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2" - }, - { - "vuid": "VUID-VkQueueFamilyProperties2-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkEnumeratePhysicalDeviceGroups": { - "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ - { - "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter", - "text": " pPhysicalDeviceGroupCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter", - "text": " If the value referenced by pPhysicalDeviceGroupCount is not 0, and pPhysicalDeviceGroupProperties is not NULL, pPhysicalDeviceGroupProperties must be a valid pointer to an array of pPhysicalDeviceGroupCount VkPhysicalDeviceGroupProperties structures" - } - ] - }, - "vkCreateDevice": { - "core": [ - { - "vuid": "VUID-vkCreateDevice-ppEnabledExtensionNames-01387", - "text": " All &amp;lt;&amp;lt;extended-functionality-extensions-dependencies, required extensions&amp;gt;&amp;gt; for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list." - }, - { - "vuid": "VUID-vkCreateDevice-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkCreateDevice-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateDevice-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDevice-pDevice-parameter", - "text": " pDevice must be a valid pointer to a VkDevice handle" - } - ] - }, - "VkDeviceCreateInfo": { - "core": [ - { - "vuid": "VUID-VkDeviceCreateInfo-queueFamilyIndex-00372", - "text": "" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceSamplerYcbcrConversionFeatures, or VkPhysicalDeviceVariablePointerFeatures" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter", - "text": " pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter", - "text": " If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter", - "text": " If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter", - "text": " If pEnabledFeatures is not NULL, pEnabledFeatures must be a valid pointer to a valid VkPhysicalDeviceFeatures structure" - }, - { - "vuid": "VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength", - "text": " queueCreateInfoCount must be greater than 0" - } - ], - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkDeviceCreateInfo-pNext-00373", - "text": " If the pNext chain includes a VkPhysicalDeviceFeatures2 structure, then pEnabledFeatures must be NULL" - } - ], - "(VK_AMD_negative_viewport_height)+(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840", - "text": " ppEnabledExtensionNames must not contain VK_AMD_negative_viewport_height" - } - ], - "(VK_AMD_negative_viewport_height)+!(VK_VERSION_1_1)+(VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374", - "text": " ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height" - } - ] - }, - "VkDeviceGroupDeviceCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ - { - "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375", - "text": " Each element of pPhysicalDevices must be unique" - }, - { - "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376", - "text": " All elements of pPhysicalDevices must be in the same device group as enumerated by vkEnumeratePhysicalDeviceGroups" - }, - { - "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377", - "text": " If physicalDeviceCount is not 0, the physicalDevice parameter of vkCreateDevice must be an element of pPhysicalDevices." - }, - { - "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO" - }, - { - "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter", - "text": " If physicalDeviceCount is not 0, pPhysicalDevices must be a valid pointer to an array of physicalDeviceCount valid VkPhysicalDevice handles" - } - ] - }, - "vkDestroyDevice": { - "core": [ - { - "vuid": "VUID-vkDestroyDevice-device-00378", - "text": " All child objects created on device must have been destroyed prior to destroying device" - }, - { - "vuid": "VUID-vkDestroyDevice-device-00379", - "text": " If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyDevice-device-00380", - "text": " If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyDevice-device-parameter", - "text": " If device is not NULL, device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyDevice-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - } - ] - }, - "VkDeviceQueueCreateInfo": { - "core": [ - { - "vuid": "VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties" - }, - { - "vuid": "VUID-VkDeviceQueueCreateInfo-queueCount-00382", - "text": " queueCount must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]" - }, - { - "vuid": "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383", - "text": " Each element of pQueuePriorities must be between 0.0 and 1.0 inclusive" - }, - { - "vuid": "VUID-VkDeviceQueueCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO" - }, - { - "vuid": "VUID-VkDeviceQueueCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceQueueGlobalPriorityCreateInfoEXT" - }, - { - "vuid": "VUID-VkDeviceQueueCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkDeviceQueueCreateFlagBits values" - }, - { - "vuid": "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter", - "text": " pQueuePriorities must be a valid pointer to an array of queueCount float values" - }, - { - "vuid": "VUID-VkDeviceQueueCreateInfo-queueCount-arraylength", - "text": " queueCount must be greater than 0" - } - ] - }, - "VkDeviceQueueGlobalPriorityCreateInfoEXT": { - "(VK_EXT_global_priority)": [ - { - "vuid": "VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter", - "text": " globalPriority must be a valid VkQueueGlobalPriorityEXT value" - } - ] - }, - "vkGetDeviceQueue": { - "core": [ - { - "vuid": "VUID-vkGetDeviceQueue-queueFamilyIndex-00384", - "text": " queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure" - }, - { - "vuid": "VUID-vkGetDeviceQueue-queueIndex-00385", - "text": " queueIndex must be less than the number of queues created for the specified queue family index when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure" - }, - { - "vuid": "VUID-vkGetDeviceQueue-flags-01841", - "text": " VkDeviceQueueCreateInfo::flags must have been set to zero when device was created" - }, - { - "vuid": "VUID-vkGetDeviceQueue-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDeviceQueue-pQueue-parameter", - "text": " pQueue must be a valid pointer to a VkQueue handle" - } - ] - }, - "vkGetDeviceQueue2": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkGetDeviceQueue2-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDeviceQueue2-pQueueInfo-parameter", - "text": " pQueueInfo must be a valid pointer to a valid VkDeviceQueueInfo2 structure" - }, - { - "vuid": "VUID-vkGetDeviceQueue2-pQueue-parameter", - "text": " pQueue must be a valid pointer to a VkQueue handle" - } - ] - }, - "VkDeviceQueueInfo2": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842", - "text": " queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure" - }, - { - "vuid": "VUID-VkDeviceQueueInfo2-queueIndex-01843", - "text": " queueIndex must be less than the number of queues created for the specified queue family index and VkDeviceQueueCreateFlags member flags equal to this flags value when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure" - }, - { - "vuid": "VUID-VkDeviceQueueInfo2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2" - }, - { - "vuid": "VUID-VkDeviceQueueInfo2-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDeviceQueueInfo2-flags-parameter", - "text": " flags must be a valid combination of VkDeviceQueueCreateFlagBits values" - }, - { - "vuid": "VUID-VkDeviceQueueInfo2-flags-requiredbitmask", - "text": " flags must not be 0" - } - ] - }, - "vkCreateCommandPool": { - "core": [ - { - "vuid": "VUID-vkCreateCommandPool-queueFamilyIndex-01937", - "text": " pCreateInfo::queueFamilyIndex must be the index of a queue family available in the logical device device." - }, - { - "vuid": "VUID-vkCreateCommandPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateCommandPool-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkCommandPoolCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateCommandPool-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateCommandPool-pCommandPool-parameter", - "text": " pCommandPool must be a valid pointer to a VkCommandPool handle" - } - ] - }, - "VkCommandPoolCreateInfo": { - "core": [ - { - "vuid": "VUID-VkCommandPoolCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO" - }, - { - "vuid": "VUID-VkCommandPoolCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkCommandPoolCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkCommandPoolCreateFlagBits values" - } - ] - }, - "vkTrimCommandPool": { - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-vkTrimCommandPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkTrimCommandPool-commandPool-parameter", - "text": " commandPool must be a valid VkCommandPool handle" - }, - { - "vuid": "VUID-vkTrimCommandPool-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-vkTrimCommandPool-commandPool-parent", - "text": " commandPool must have been created, allocated, or retrieved from device" - } - ] - }, - "vkResetCommandPool": { - "core": [ - { - "vuid": "VUID-vkResetCommandPool-commandPool-00040", - "text": " All VkCommandBuffer objects allocated from commandPool must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkResetCommandPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkResetCommandPool-commandPool-parameter", - "text": " commandPool must be a valid VkCommandPool handle" - }, - { - "vuid": "VUID-vkResetCommandPool-flags-parameter", - "text": " flags must be a valid combination of VkCommandPoolResetFlagBits values" - }, - { - "vuid": "VUID-vkResetCommandPool-commandPool-parent", - "text": " commandPool must have been created, allocated, or retrieved from device" - } - ] - }, - "vkDestroyCommandPool": { - "core": [ - { - "vuid": "VUID-vkDestroyCommandPool-commandPool-00041", - "text": " All VkCommandBuffer objects allocated from commandPool must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkDestroyCommandPool-commandPool-00042", - "text": " If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyCommandPool-commandPool-00043", - "text": " If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyCommandPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyCommandPool-commandPool-parameter", - "text": " If commandPool is not VK_NULL_HANDLE, commandPool must be a valid VkCommandPool handle" - }, - { - "vuid": "VUID-vkDestroyCommandPool-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyCommandPool-commandPool-parent", - "text": " If commandPool is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkAllocateCommandBuffers": { - "core": [ - { - "vuid": "VUID-vkAllocateCommandBuffers-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter", - "text": " pAllocateInfo must be a valid pointer to a valid VkCommandBufferAllocateInfo structure" - }, - { - "vuid": "VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter", - "text": " pCommandBuffers must be a valid pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles" - } - ] - }, - "VkCommandBufferAllocateInfo": { - "core": [ - { - "vuid": "VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044", - "text": " commandBufferCount must be greater than 0" - }, - { - "vuid": "VUID-VkCommandBufferAllocateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO" - }, - { - "vuid": "VUID-VkCommandBufferAllocateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkCommandBufferAllocateInfo-commandPool-parameter", - "text": " commandPool must be a valid VkCommandPool handle" - }, - { - "vuid": "VUID-VkCommandBufferAllocateInfo-level-parameter", - "text": " level must be a valid VkCommandBufferLevel value" - } - ] - }, - "vkResetCommandBuffer": { - "core": [ - { - "vuid": "VUID-vkResetCommandBuffer-commandBuffer-00045", - "text": " commandBuffer must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkResetCommandBuffer-commandBuffer-00046", - "text": " commandBuffer must have been allocated from a pool that was created with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT" - }, - { - "vuid": "VUID-vkResetCommandBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkResetCommandBuffer-flags-parameter", - "text": " flags must be a valid combination of VkCommandBufferResetFlagBits values" - } - ] - }, - "vkFreeCommandBuffers": { - "core": [ - { - "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-00047", - "text": " All elements of pCommandBuffers must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-00048", - "text": " pCommandBuffers must be a valid pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL" - }, - { - "vuid": "VUID-vkFreeCommandBuffers-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkFreeCommandBuffers-commandPool-parameter", - "text": " commandPool must be a valid VkCommandPool handle" - }, - { - "vuid": "VUID-vkFreeCommandBuffers-commandBufferCount-arraylength", - "text": " commandBufferCount must be greater than 0" - }, - { - "vuid": "VUID-vkFreeCommandBuffers-commandPool-parent", - "text": " commandPool must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-parent", - "text": " Each element of pCommandBuffers that is a valid handle must have been created, allocated, or retrieved from commandPool" - } - ] - }, - "vkBeginCommandBuffer": { - "core": [ - { - "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00049", - "text": " commandBuffer must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording or pending state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00050", - "text": " If commandBuffer was allocated from a VkCommandPool which did not have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, initial state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00051", - "text": " If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure" - }, - { - "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00052", - "text": " If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is VK_FALSE, or the precise occlusion queries feature is not enabled, the queryFlags member of the pInheritanceInfo member pBeginInfo must not contain VK_QUERY_CONTROL_PRECISE_BIT" - }, - { - "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkBeginCommandBuffer-pBeginInfo-parameter", - "text": " pBeginInfo must be a valid pointer to a valid VkCommandBufferBeginInfo structure" - } - ] - }, - "VkCommandBufferBeginInfo": { - "core": [ - { - "vuid": "VUID-VkCommandBufferBeginInfo-flags-00053", - "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo must be a valid VkRenderPass" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-flags-00054", - "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-flags-00055", - "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo" - }, - { - "vuid": "VUID-VkCommandBufferBeginInfo-flags-parameter", - "text": " flags must be a valid combination of VkCommandBufferUsageFlagBits values" - } - ] - }, - "VkCommandBufferInheritanceInfo": { - "core": [ - { - "vuid": "VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056", - "text": " If the &amp;lt;&amp;lt;features-features-inheritedQueries,inherited queries&amp;gt;&amp;gt; feature is not enabled, occlusionQueryEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkCommandBufferInheritanceInfo-queryFlags-00057", - "text": " If the &amp;lt;&amp;lt;features-features-inheritedQueries,inherited queries&amp;gt;&amp;gt; feature is enabled, queryFlags must be a valid combination of VkQueryControlFlagBits values" - }, - { - "vuid": "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058", - "text": " If the &amp;lt;&amp;lt;features-features-pipelineStatisticsQuery,pipeline statistics queries&amp;gt;&amp;gt; feature is not enabled, pipelineStatistics must be 0" - }, - { - "vuid": "VUID-VkCommandBufferInheritanceInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO" - }, - { - "vuid": "VUID-VkCommandBufferInheritanceInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkCommandBufferInheritanceInfo-commonparent", - "text": " Both of framebuffer, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkEndCommandBuffer": { - "core": [ - { - "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00059", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00060", - "text": " If commandBuffer is a primary command buffer, there must not be an active render pass instance" - }, - { - "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00061", - "text": " All queries made &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt; during the recording of commandBuffer must have been made inactive" - }, - { - "vuid": "VUID-vkEndCommandBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - } - ], - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkEndCommandBuffer-commandBuffer-01815", - "text": " If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT." - } - ], - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00062", - "text": " If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT." - } - ] - }, - "vkQueueSubmit": { - "core": [ - { - "vuid": "VUID-vkQueueSubmit-fence-00063", - "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" - }, - { - "vuid": "VUID-vkQueueSubmit-fence-00064", - "text": " If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue" - }, - { - "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00065", - "text": " Any calls to vkCmdSetEvent, vkCmdResetEvent or vkCmdWaitEvents that have been recorded into any of the command buffer elements of the pCommandBuffers member of any element of pSubmits, must not reference any VkEvent that is referenced by any of those commands in a command buffer that has been submitted to another queue and is still in the pending state." - }, - { - "vuid": "VUID-vkQueueSubmit-pWaitDstStageMask-00066", - "text": " Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the &amp;lt;&amp;lt;synchronization-pipeline-stages-supported, table of supported pipeline stages&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkQueueSubmit-pSignalSemaphores-00067", - "text": " Each element of the pSignalSemaphores member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device" - }, - { - "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00068", - "text": " When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, no other queue must be waiting on the same semaphore." - }, - { - "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00069", - "text": " All elements of the pWaitSemaphores member of all elements of pSubmits must be semaphores that are signaled, or have &amp;lt;&amp;lt;synchronization-semaphores-signaling, semaphore signal operations&amp;gt;&amp;gt; previously submitted for execution." - }, - { - "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00070", - "text": " Each element of the pCommandBuffers member of each element of pSubmits must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending or executable state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00071", - "text": " If any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00072", - "text": " Any &amp;lt;&amp;lt;commandbuffers-secondary, secondary command buffers recorded&amp;gt;&amp;gt; into any element of the pCommandBuffers member of any element of pSubmits must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending or executable state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00073", - "text": " If any &amp;lt;&amp;lt;commandbuffers-secondary, secondary command buffers recorded&amp;gt;&amp;gt; into any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00074", - "text": " Each element of the pCommandBuffers member of each element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to." - }, - { - "vuid": "VUID-vkQueueSubmit-queue-parameter", - "text": " queue must be a valid VkQueue handle" - }, - { - "vuid": "VUID-vkQueueSubmit-pSubmits-parameter", - "text": " If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures" - }, - { - "vuid": "VUID-vkQueueSubmit-fence-parameter", - "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-vkQueueSubmit-commonparent", - "text": " Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkSubmitInfo": { - "core": [ - { - "vuid": "VUID-VkSubmitInfo-pCommandBuffers-00075", - "text": " Each element of pCommandBuffers must not have been allocated with VK_COMMAND_BUFFER_LEVEL_SECONDARY" - }, - { - "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00076", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00077", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, each element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00078", - "text": " Each element of pWaitDstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT." - }, - { - "vuid": "VUID-VkSubmitInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SUBMIT_INFO" - }, - { - "vuid": "VUID-VkSubmitInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfo, VkProtectedSubmitInfo, VkWin32KeyedMutexAcquireReleaseInfoKHR, or VkWin32KeyedMutexAcquireReleaseInfoNV" - }, - { - "vuid": "VUID-VkSubmitInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkSubmitInfo-pWaitSemaphores-parameter", - "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" - }, - { - "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-parameter", - "text": " If waitSemaphoreCount is not 0, pWaitDstStageMask must be a valid pointer to an array of waitSemaphoreCount valid combinations of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask", - "text": " Each element of pWaitDstStageMask must not be 0" - }, - { - "vuid": "VUID-VkSubmitInfo-pCommandBuffers-parameter", - "text": " If commandBufferCount is not 0, pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles" - }, - { - "vuid": "VUID-VkSubmitInfo-pSignalSemaphores-parameter", - "text": " If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles" - }, - { - "vuid": "VUID-VkSubmitInfo-commonparent", - "text": " Each of the elements of pCommandBuffers, the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkD3D12FenceSubmitInfoKHR": { - "(VK_KHR_external_semaphore_win32)": [ - { - "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079", - "text": " waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure." - }, - { - "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080", - "text": " signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure." - }, - { - "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR" - }, - { - "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter", - "text": " If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a valid pointer to an array of waitSemaphoreValuesCount uint64_t values" - }, - { - "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter", - "text": " If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a valid pointer to an array of signalSemaphoreValuesCount uint64_t values" - } - ] - }, - "VkWin32KeyedMutexAcquireReleaseInfoKHR": { - "(VK_KHR_win32_keyed_mutex)": [ - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081", - "text": " Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHR::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT." - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter", - "text": " If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter", - "text": " If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter", - "text": " If acquireCount is not 0, pAcquireTimeouts must be a valid pointer to an array of acquireCount uint32_t values" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter", - "text": " If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter", - "text": " If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent", - "text": " Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkWin32KeyedMutexAcquireReleaseInfoNV": { - "(VK_NV_win32_keyed_mutex)": [ - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter", - "text": " If acquireCount is not 0, pAcquireSyncs must be a valid pointer to an array of acquireCount valid VkDeviceMemory handles" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter", - "text": " If acquireCount is not 0, pAcquireKeys must be a valid pointer to an array of acquireCount uint64_t values" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireTimeoutMilliseconds-parameter", - "text": " If acquireCount is not 0, pAcquireTimeoutMilliseconds must be a valid pointer to an array of acquireCount uint32_t values" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseSyncs-parameter", - "text": " If releaseCount is not 0, pReleaseSyncs must be a valid pointer to an array of releaseCount valid VkDeviceMemory handles" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pReleaseKeys-parameter", - "text": " If releaseCount is not 0, pReleaseKeys must be a valid pointer to an array of releaseCount uint64_t values" - }, - { - "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent", - "text": " Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkProtectedSubmitInfo": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01816", - "text": " If the protected memory feature is not enabled, protectedSubmit must not be VK_TRUE." - }, - { - "vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01817", - "text": " If protectedSubmit is VK_TRUE, then each element of the pCommandBuffers array must be a protected command buffer." - }, - { - "vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01818", - "text": " If protectedSubmit is VK_FALSE, then each element of the pCommandBuffers array must be an unprotected command buffer." - }, - { - "vuid": "VUID-VkProtectedSubmitInfo-pNext-01819", - "text": " If the VkSubmitInfo::pNext chain does not include a VkProtectedSubmitInfo structure, then each element of the command buffer of the pCommandBuffers array must be an unprotected command buffer." - }, - { - "vuid": "VUID-VkProtectedSubmitInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO" - } - ] - }, - "VkDeviceGroupSubmitInfo": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082", - "text": " waitSemaphoreCount must equal VkSubmitInfo::waitSemaphoreCount" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083", - "text": " commandBufferCount must equal VkSubmitInfo::commandBufferCount" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084", - "text": " signalSemaphoreCount must equal VkSubmitInfo::signalSemaphoreCount" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085", - "text": " All elements of pWaitSemaphoreDeviceIndices and pSignalSemaphoreDeviceIndices must be valid device indices" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086", - "text": " All elements of pCommandBufferDeviceMasks must be valid device masks" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter", - "text": " If waitSemaphoreCount is not 0, pWaitSemaphoreDeviceIndices must be a valid pointer to an array of waitSemaphoreCount uint32_t values" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter", - "text": " If commandBufferCount is not 0, pCommandBufferDeviceMasks must be a valid pointer to an array of commandBufferCount uint32_t values" - }, - { - "vuid": "VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter", - "text": " If signalSemaphoreCount is not 0, pSignalSemaphoreDeviceIndices must be a valid pointer to an array of signalSemaphoreCount uint32_t values" - } - ] - }, - "vkCmdExecuteCommands": { - "core": [ - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00087", - "text": " commandBuffer must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_PRIMARY" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00088", - "text": " Each element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00089", - "text": " Each element of pCommandBuffers must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending or executable state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00090", - "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, and it was recorded into any other primary command buffer, that primary command buffer must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00091", - "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00092", - "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not have already been recorded to commandBuffer." - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00093", - "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not appear more than once in pCommandBuffers." - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00094", - "text": " Each element of pCommandBuffers must have been allocated from a VkCommandPool that was created for the same queue family as the VkCommandPool from which commandBuffer was allocated" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-contents-00095", - "text": " If vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of vkCmdBeginRenderPass set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00096", - "text": " If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00097", - "text": " If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pInheritanceInfo-00098", - "text": " If vkCmdExecuteCommands is being called within a render pass instance, the render passes specified in the pBeginInfo::pInheritanceInfo::renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the current render pass." - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00099", - "text": " If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00100", - "text": " If vkCmdExecuteCommands is not being called within a render pass instance, each element of pCommandBuffers must not have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00101", - "text": " If the &amp;lt;&amp;lt;features-features-inheritedQueries,inherited queries&amp;gt;&amp;gt; feature is not enabled, commandBuffer must not have any queries &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00102", - "text": " If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to VK_TRUE" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00103", - "text": " If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00104", - "text": " If commandBuffer has a VK_QUERY_TYPE_PIPELINE_STATISTICS query &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00105", - "text": " Each element of pCommandBuffers must not begin any query types that are &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt; in commandBuffer" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-parameter", - "text": " pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-bufferlevel", - "text": " commandBuffer must be a primary VkCommandBuffer" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBufferCount-arraylength", - "text": " commandBufferCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commonparent", - "text": " Both of commandBuffer, and the elements of pCommandBuffers must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01820", - "text": " If commandBuffer is a protected command buffer, then each element of pCommandBuffers must be a protected command buffer." - }, - { - "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01821", - "text": " If commandBuffer is an unprotected command buffer, then each element of pCommandBuffers must be an unprotected command buffer." - } - ] - }, - "VkDeviceGroupCommandBufferBeginInfo": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106", - "text": " deviceMask must be a valid device mask value" - }, - { - "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107", - "text": " deviceMask must not be zero" - }, - { - "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO" - } - ] - }, - "vkCmdSetDeviceMask": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00108", - "text": " deviceMask must be a valid device mask value" - }, - { - "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00109", - "text": " deviceMask must not be zero" - }, - { - "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00110", - "text": " deviceMask must not include any set bits that were not in the VkDeviceGroupCommandBufferBeginInfo::deviceMask value when the command buffer began recording." - }, - { - "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00111", - "text": " If vkCmdSetDeviceMask is called inside a render pass instance, deviceMask must not include any set bits that were not in the VkDeviceGroupRenderPassBeginInfo::deviceMask value when the render pass instance began recording." - }, - { - "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations" - } - ] - }, - "vkCreateFence": { - "core": [ - { - "vuid": "VUID-vkCreateFence-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateFence-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkFenceCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateFence-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateFence-pFence-parameter", - "text": " pFence must be a valid pointer to a VkFence handle" - } - ] - }, - "VkFenceCreateInfo": { - "core": [ - { - "vuid": "VUID-VkFenceCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO" - }, - { - "vuid": "VUID-VkFenceCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportFenceCreateInfo or VkExportFenceWin32HandleInfoKHR" - }, - { - "vuid": "VUID-VkFenceCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkFenceCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkFenceCreateFlagBits values" - } - ] - }, - "VkExportFenceCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_external_fence)": [ - { - "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-01446", - "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalFenceProperties." - }, - { - "vuid": "VUID-VkExportFenceCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO" - }, - { - "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-parameter", - "text": " handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBits values" - } - ] - }, - "VkExportFenceWin32HandleInfoKHR": { - "(VK_KHR_external_fence_win32)": [ - { - "vuid": "VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447", - "text": " If VkExportFenceCreateInfo::handleTypes does not include VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, VkExportFenceWin32HandleInfoKHR must not be in the pNext chain of VkFenceCreateInfo." - }, - { - "vuid": "VUID-VkExportFenceWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter", - "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" - } - ] - }, - "vkGetFenceWin32HandleKHR": { - "(VK_KHR_external_fence_win32)": [ - { - "vuid": "VUID-vkGetFenceWin32HandleKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter", - "text": " pGetWin32HandleInfo must be a valid pointer to a valid VkFenceGetWin32HandleInfoKHR structure" - }, - { - "vuid": "VUID-vkGetFenceWin32HandleKHR-pHandle-parameter", - "text": " pHandle must be a valid pointer to a HANDLE value" - } - ] - }, - "VkFenceGetWin32HandleInfoKHR": { - "(VK_KHR_external_fence_win32)": [ - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448", - "text": " handleType must have been included in VkExportFenceCreateInfo::handleTypes when the fence’s current payload was created." - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449", - "text": " If handleType is defined as an NT handle, vkGetFenceWin32HandleKHR must be called no more than once for each valid unique combination of fence and handleType." - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-fence-01450", - "text": " fence must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-fences-importing,Importing Fence Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType." - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451", - "text": " If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-fences-signaling,fence signal operation&amp;gt;&amp;gt; pending execution." - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452", - "text": " handleType must be defined as an NT handle or a global share handle." - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter", - "text": " fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" - } - ] - }, - "vkGetFenceFdKHR": { - "(VK_KHR_external_fence_fd)": [ - { - "vuid": "VUID-vkGetFenceFdKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetFenceFdKHR-pGetFdInfo-parameter", - "text": " pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure" - }, - { - "vuid": "VUID-vkGetFenceFdKHR-pFd-parameter", - "text": " pFd must be a valid pointer to a int value" - } - ] - }, - "VkFenceGetFdInfoKHR": { - "(VK_KHR_external_fence_fd)": [ - { - "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01453", - "text": " handleType must have been included in VkExportFenceCreateInfo::handleTypes when fence’s current payload was created." - }, - { - "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01454", - "text": " If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-fences-signaling,fence signal operation&amp;gt;&amp;gt; pending execution." - }, - { - "vuid": "VUID-VkFenceGetFdInfoKHR-fence-01455", - "text": " fence must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-fences-importing,Importing Fence Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType." - }, - { - "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01456", - "text": " handleType must be defined as a POSIX file descriptor handle." - }, - { - "vuid": "VUID-VkFenceGetFdInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR" - }, - { - "vuid": "VUID-VkFenceGetFdInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkFenceGetFdInfoKHR-fence-parameter", - "text": " fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" - } - ] - }, - "vkDestroyFence": { - "core": [ - { - "vuid": "VUID-vkDestroyFence-fence-01120", - "text": " All &amp;lt;&amp;lt;devsandqueues-submission, queue submission&amp;gt;&amp;gt; commands that refer to fence must have completed execution" - }, - { - "vuid": "VUID-vkDestroyFence-fence-01121", - "text": " If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyFence-fence-01122", - "text": " If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyFence-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyFence-fence-parameter", - "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-vkDestroyFence-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyFence-fence-parent", - "text": " If fence is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetFenceStatus": { - "core": [ - { - "vuid": "VUID-vkGetFenceStatus-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetFenceStatus-fence-parameter", - "text": " fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-vkGetFenceStatus-fence-parent", - "text": " fence must have been created, allocated, or retrieved from device" - } - ] - }, - "vkResetFences": { - "core": [ - { - "vuid": "VUID-vkResetFences-pFences-01123", - "text": " Each element of pFences must not be currently associated with any queue command that has not yet completed execution on that queue" - }, - { - "vuid": "VUID-vkResetFences-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkResetFences-pFences-parameter", - "text": " pFences must be a valid pointer to an array of fenceCount valid VkFence handles" - }, - { - "vuid": "VUID-vkResetFences-fenceCount-arraylength", - "text": " fenceCount must be greater than 0" - }, - { - "vuid": "VUID-vkResetFences-pFences-parent", - "text": " Each element of pFences must have been created, allocated, or retrieved from device" - } - ] - }, - "vkWaitForFences": { - "core": [ - { - "vuid": "VUID-vkWaitForFences-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkWaitForFences-pFences-parameter", - "text": " pFences must be a valid pointer to an array of fenceCount valid VkFence handles" - }, - { - "vuid": "VUID-vkWaitForFences-fenceCount-arraylength", - "text": " fenceCount must be greater than 0" - }, - { - "vuid": "VUID-vkWaitForFences-pFences-parent", - "text": " Each element of pFences must have been created, allocated, or retrieved from device" - } - ] - }, - "vkRegisterDeviceEventEXT": { - "(VK_EXT_display_control)": [ - { - "vuid": "VUID-vkRegisterDeviceEventEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter", - "text": " pDeviceEventInfo must be a valid pointer to a valid VkDeviceEventInfoEXT structure" - }, - { - "vuid": "VUID-vkRegisterDeviceEventEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkRegisterDeviceEventEXT-pFence-parameter", - "text": " pFence must be a valid pointer to a VkFence handle" - } - ] - }, - "VkDeviceEventInfoEXT": { - "(VK_EXT_display_control)": [ - { - "vuid": "VUID-VkDeviceEventInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT" - }, - { - "vuid": "VUID-VkDeviceEventInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDeviceEventInfoEXT-deviceEvent-parameter", - "text": " deviceEvent must be a valid VkDeviceEventTypeEXT value" - } - ] - }, - "vkRegisterDisplayEventEXT": { - "(VK_EXT_display_control)": [ - { - "vuid": "VUID-vkRegisterDisplayEventEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkRegisterDisplayEventEXT-display-parameter", - "text": " display must be a valid VkDisplayKHR handle" - }, - { - "vuid": "VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter", - "text": " pDisplayEventInfo must be a valid pointer to a valid VkDisplayEventInfoEXT structure" - }, - { - "vuid": "VUID-vkRegisterDisplayEventEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkRegisterDisplayEventEXT-pFence-parameter", - "text": " pFence must be a valid pointer to a VkFence handle" - } - ] - }, - "VkDisplayEventInfoEXT": { - "(VK_EXT_display_control)": [ - { - "vuid": "VUID-VkDisplayEventInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT" - }, - { - "vuid": "VUID-VkDisplayEventInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDisplayEventInfoEXT-displayEvent-parameter", - "text": " displayEvent must be a valid VkDisplayEventTypeEXT value" - } - ] - }, - "vkImportFenceWin32HandleKHR": { - "(VK_KHR_external_fence_win32)": [ - { - "vuid": "VUID-vkImportFenceWin32HandleKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter", - "text": " pImportFenceWin32HandleInfo must be a valid pointer to a valid VkImportFenceWin32HandleInfoKHR structure" - } - ] - }, - "VkImportFenceWin32HandleInfoKHR": { - "(VK_KHR_external_fence_win32)": [ - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457", - "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-fence-handletypes-win32, Handle Types Supported by VkImportFenceWin32HandleInfoKHR&amp;gt;&amp;gt; table." - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459", - "text": " If handleType is not VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, name must be NULL." - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460", - "text": " If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType." - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461", - "text": " If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType." - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01462", - "text": " If handle is not NULL, name must be NULL." - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01539", - "text": " If handle is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility." - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-name-01540", - "text": " If name is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility." - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter", - "text": " fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter", - "text": " flags must be a valid combination of VkFenceImportFlagBits values" - }, - { - "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter", - "text": " If handleType is not 0, handleType must be a valid VkExternalFenceHandleTypeFlagBits value" - } - ] - }, - "vkImportFenceFdKHR": { - "(VK_KHR_external_fence_fd)": [ - { - "vuid": "VUID-vkImportFenceFdKHR-fence-01463", - "text": " fence must not be associated with any queue command that has not yet completed execution on that queue" - }, - { - "vuid": "VUID-vkImportFenceFdKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter", - "text": " pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure" - } - ] - }, - "VkImportFenceFdInfoKHR": { - "(VK_KHR_external_fence_fd)": [ - { - "vuid": "VUID-VkImportFenceFdInfoKHR-handleType-01464", - "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-fence-handletypes-fd, Handle Types Supported by VkImportFenceFdInfoKHR&amp;gt;&amp;gt; table." - }, - { - "vuid": "VUID-VkImportFenceFdInfoKHR-fd-01541", - "text": " fd must obey any requirements listed for handleType in &amp;lt;&amp;lt;external-fence-handle-types-compatibility,external fence handle types compatibility&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkImportFenceFdInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR" - }, - { - "vuid": "VUID-VkImportFenceFdInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkImportFenceFdInfoKHR-fence-parameter", - "text": " fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-VkImportFenceFdInfoKHR-flags-parameter", - "text": " flags must be a valid combination of VkFenceImportFlagBits values" - }, - { - "vuid": "VUID-VkImportFenceFdInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" - } - ] - }, - "vkCreateSemaphore": { - "core": [ - { - "vuid": "VUID-vkCreateSemaphore-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateSemaphore-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkSemaphoreCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateSemaphore-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateSemaphore-pSemaphore-parameter", - "text": " pSemaphore must be a valid pointer to a VkSemaphore handle" - } - ] - }, - "VkSemaphoreCreateInfo": { - "core": [ - { - "vuid": "VUID-VkSemaphoreCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO" - }, - { - "vuid": "VUID-VkSemaphoreCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportSemaphoreCreateInfo or VkExportSemaphoreWin32HandleInfoKHR" - }, - { - "vuid": "VUID-VkSemaphoreCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkSemaphoreCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "VkExportSemaphoreCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_external_semaphore)": [ - { - "vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-01124", - "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphoreProperties." - }, - { - "vuid": "VUID-VkExportSemaphoreCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO" - }, - { - "vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter", - "text": " handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values" - } - ] - }, - "VkExportSemaphoreWin32HandleInfoKHR": { - "(VK_KHR_external_semaphore_win32)": [ - { - "vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125", - "text": " If VkExportSemaphoreCreateInfo::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, VkExportSemaphoreWin32HandleInfoKHR must not be in the pNext chain of VkSemaphoreCreateInfo." - }, - { - "vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter", - "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" - } - ] - }, - "vkGetSemaphoreWin32HandleKHR": { - "(VK_KHR_external_semaphore_win32)": [ - { - "vuid": "VUID-vkGetSemaphoreWin32HandleKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter", - "text": " pGetWin32HandleInfo must be a valid pointer to a valid VkSemaphoreGetWin32HandleInfoKHR structure" - }, - { - "vuid": "VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter", - "text": " pHandle must be a valid pointer to a HANDLE value" - } - ] - }, - "VkSemaphoreGetWin32HandleInfoKHR": { - "(VK_KHR_external_semaphore_win32)": [ - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126", - "text": " handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when the semaphore’s current payload was created." - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127", - "text": " If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHR must be called no more than once for each valid unique combination of semaphore and handleType." - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128", - "text": " semaphore must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType." - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129", - "text": " If handleType refers to a handle type with copy payload transference semantics, as defined below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt;, there must be no queue waiting on semaphore." - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130", - "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-semaphores-signaling,semaphore signal operation&amp;gt;&amp;gt; pending execution." - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131", - "text": " handleType must be defined as an NT handle or a global share handle." - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter", - "text": " semaphore must be a valid VkSemaphore handle" - }, - { - "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" - } - ] - }, - "vkGetSemaphoreFdKHR": { - "(VK_KHR_external_semaphore_fd)": [ - { - "vuid": "VUID-vkGetSemaphoreFdKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter", - "text": " pGetFdInfo must be a valid pointer to a valid VkSemaphoreGetFdInfoKHR structure" - }, - { - "vuid": "VUID-vkGetSemaphoreFdKHR-pFd-parameter", - "text": " pFd must be a valid pointer to a int value" - } - ] - }, - "VkSemaphoreGetFdInfoKHR": { - "(VK_KHR_external_semaphore_fd)": [ - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01132", - "text": " handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when semaphore’s current payload was created." - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133", - "text": " semaphore must not currently have its payload replaced by an imported payload as described below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt; unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType." - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01134", - "text": " If handleType refers to a handle type with copy payload transference semantics, as defined below in &amp;lt;&amp;lt;synchronization-semaphores-importing,Importing Semaphore Payloads&amp;gt;&amp;gt;, there must be no queue waiting on semaphore." - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01135", - "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated &amp;lt;&amp;lt;synchronization-semaphores-signaling,semaphore signal operation&amp;gt;&amp;gt; pending execution." - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01136", - "text": " handleType must be defined as a POSIX file descriptor handle." - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR" - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter", - "text": " semaphore must be a valid VkSemaphore handle" - }, - { - "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" - } - ] - }, - "vkDestroySemaphore": { - "core": [ - { - "vuid": "VUID-vkDestroySemaphore-semaphore-01137", - "text": " All submitted batches that refer to semaphore must have completed execution" - }, - { - "vuid": "VUID-vkDestroySemaphore-semaphore-01138", - "text": " If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroySemaphore-semaphore-01139", - "text": " If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroySemaphore-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroySemaphore-semaphore-parameter", - "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" - }, - { - "vuid": "VUID-vkDestroySemaphore-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroySemaphore-semaphore-parent", - "text": " If semaphore is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkImportSemaphoreWin32HandleKHR": { - "(VK_KHR_external_semaphore_win32)": [ - { - "vuid": "VUID-vkImportSemaphoreWin32HandleKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter", - "text": " pImportSemaphoreWin32HandleInfo must be a valid pointer to a valid VkImportSemaphoreWin32HandleInfoKHR structure" - } - ] - }, - "VkImportSemaphoreWin32HandleInfoKHR": { - "(VK_KHR_external_semaphore_win32)": [ - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140", - "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-semaphore-handletypes-win32,Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR&amp;gt;&amp;gt; table." - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466", - "text": " If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, name must be NULL." - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467", - "text": " If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType." - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468", - "text": " If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType." - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469", - "text": " If handle is not NULL, name must be NULL." - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542", - "text": " If handle is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility." - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543", - "text": " If name is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility." - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter", - "text": " semaphore must be a valid VkSemaphore handle" - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter", - "text": " flags must be a valid combination of VkSemaphoreImportFlagBits values" - }, - { - "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter", - "text": " If handleType is not 0, handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" - } - ] - }, - "vkImportSemaphoreFdKHR": { - "(VK_KHR_external_semaphore_fd)": [ - { - "vuid": "VUID-vkImportSemaphoreFdKHR-semaphore-01142", - "text": " semaphore must not be associated with any queue command that has not yet completed execution on that queue" - }, - { - "vuid": "VUID-vkImportSemaphoreFdKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter", - "text": " pImportSemaphoreFdInfo must be a valid pointer to a valid VkImportSemaphoreFdInfoKHR structure" - } - ] - }, - "VkImportSemaphoreFdInfoKHR": { - "(VK_KHR_external_semaphore_fd)": [ - { - "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-01143", - "text": " handleType must be a value included in the &amp;lt;&amp;lt;synchronization-semaphore-handletypes-fd,Handle Types Supported by VkImportSemaphoreFdInfoKHR&amp;gt;&amp;gt; table." - }, - { - "vuid": "VUID-VkImportSemaphoreFdInfoKHR-fd-01544", - "text": " fd must obey any requirements listed for handleType in &amp;lt;&amp;lt;external-semaphore-handle-types-compatibility,external semaphore handle types compatibility&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkImportSemaphoreFdInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR" - }, - { - "vuid": "VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter", - "text": " semaphore must be a valid VkSemaphore handle" - }, - { - "vuid": "VUID-VkImportSemaphoreFdInfoKHR-flags-parameter", - "text": " flags must be a valid combination of VkSemaphoreImportFlagBits values" - }, - { - "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" - } - ] - }, - "vkCreateEvent": { - "core": [ - { - "vuid": "VUID-vkCreateEvent-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateEvent-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkEventCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateEvent-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateEvent-pEvent-parameter", - "text": " pEvent must be a valid pointer to a VkEvent handle" - } - ] - }, - "VkEventCreateInfo": { - "core": [ - { - "vuid": "VUID-VkEventCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO" - }, - { - "vuid": "VUID-VkEventCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkEventCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkDestroyEvent": { - "core": [ - { - "vuid": "VUID-vkDestroyEvent-event-01145", - "text": " All submitted commands that refer to event must have completed execution" - }, - { - "vuid": "VUID-vkDestroyEvent-event-01146", - "text": " If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyEvent-event-01147", - "text": " If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyEvent-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyEvent-event-parameter", - "text": " If event is not VK_NULL_HANDLE, event must be a valid VkEvent handle" - }, - { - "vuid": "VUID-vkDestroyEvent-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyEvent-event-parent", - "text": " If event is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetEventStatus": { - "core": [ - { - "vuid": "VUID-vkGetEventStatus-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetEventStatus-event-parameter", - "text": " event must be a valid VkEvent handle" - }, - { - "vuid": "VUID-vkGetEventStatus-event-parent", - "text": " event must have been created, allocated, or retrieved from device" - } - ] - }, - "vkSetEvent": { - "core": [ - { - "vuid": "VUID-vkSetEvent-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkSetEvent-event-parameter", - "text": " event must be a valid VkEvent handle" - }, - { - "vuid": "VUID-vkSetEvent-event-parent", - "text": " event must have been created, allocated, or retrieved from device" - } - ] - }, - "vkResetEvent": { - "core": [ - { - "vuid": "VUID-vkResetEvent-event-01148", - "text": " event must not be waited on by a vkCmdWaitEvents command that is currently executing" - }, - { - "vuid": "VUID-vkResetEvent-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkResetEvent-event-parameter", - "text": " event must be a valid VkEvent handle" - }, - { - "vuid": "VUID-vkResetEvent-event-parent", - "text": " event must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCmdSetEvent": { - "core": [ - { - "vuid": "VUID-vkCmdSetEvent-stageMask-01149", - "text": " stageMask must not include VK_PIPELINE_STAGE_HOST_BIT" - }, - { - "vuid": "VUID-vkCmdSetEvent-stageMask-01150", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdSetEvent-stageMask-01151", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdSetEvent-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetEvent-event-parameter", - "text": " event must be a valid VkEvent handle" - }, - { - "vuid": "VUID-vkCmdSetEvent-stageMask-parameter", - "text": " stageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-vkCmdSetEvent-stageMask-requiredbitmask", - "text": " stageMask must not be 0" - }, - { - "vuid": "VUID-vkCmdSetEvent-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetEvent-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdSetEvent-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdSetEvent-commonparent", - "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkCmdSetEvent-commandBuffer-01152", - "text": " commandBuffer’s current device mask must include exactly one physical device." - } - ] - }, - "vkCmdResetEvent": { - "core": [ - { - "vuid": "VUID-vkCmdResetEvent-stageMask-01153", - "text": " stageMask must not include VK_PIPELINE_STAGE_HOST_BIT" - }, - { - "vuid": "VUID-vkCmdResetEvent-stageMask-01154", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdResetEvent-stageMask-01155", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdResetEvent-event-01156", - "text": " When this command executes, event must not be waited on by a vkCmdWaitEvents command that is currently executing" - }, - { - "vuid": "VUID-vkCmdResetEvent-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdResetEvent-event-parameter", - "text": " event must be a valid VkEvent handle" - }, - { - "vuid": "VUID-vkCmdResetEvent-stageMask-parameter", - "text": " stageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-vkCmdResetEvent-stageMask-requiredbitmask", - "text": " stageMask must not be 0" - }, - { - "vuid": "VUID-vkCmdResetEvent-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdResetEvent-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdResetEvent-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdResetEvent-commonparent", - "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkCmdResetEvent-commandBuffer-01157", - "text": " commandBuffer’s current device mask must include exactly one physical device." - } - ] - }, - "vkCmdWaitEvents": { - "core": [ - { - "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01158", - "text": " srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the members of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the members of pEvents was set using vkSetEvent" - }, - { - "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01159", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdWaitEvents-dstStageMask-01160", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01161", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdWaitEvents-dstStageMask-01162", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdWaitEvents-pEvents-01163", - "text": " If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents must not be called inside a render pass instance" - }, - { - "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01164", - "text": " Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the &amp;lt;&amp;lt;synchronization-pipeline-stages-supported, table of supported pipeline stages&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-01165", - "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-01166", - "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdWaitEvents-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdWaitEvents-pEvents-parameter", - "text": " pEvents must be a valid pointer to an array of eventCount valid VkEvent handles" - }, - { - "vuid": "VUID-vkCmdWaitEvents-srcStageMask-parameter", - "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask", - "text": " srcStageMask must not be 0" - }, - { - "vuid": "VUID-vkCmdWaitEvents-dstStageMask-parameter", - "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask", - "text": " dstStageMask must not be 0" - }, - { - "vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-parameter", - "text": " If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures" - }, - { - "vuid": "VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter", - "text": " If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures" - }, - { - "vuid": "VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter", - "text": " If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures" - }, - { - "vuid": "VUID-vkCmdWaitEvents-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdWaitEvents-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdWaitEvents-eventCount-arraylength", - "text": " eventCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdWaitEvents-commonparent", - "text": " Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkCmdWaitEvents-commandBuffer-01167", - "text": " commandBuffer’s current device mask must include exactly one physical device." - } - ] - }, - "vkCmdPipelineBarrier": { - "core": [ - { - "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01168", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-01169", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01170", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-01171", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-pDependencies-01172", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with a VkSubpassDependency instance in pDependencies that expresses a dependency from the current subpass to itself." - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01173", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, srcStageMask must contain a subset of the bit values in the srcStageMask member of that instance of VkSubpassDependency" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-01174", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, dstStageMask must contain a subset of the bit values in the dstStageMask member of that instance of VkSubpassDependency" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-srcAccessMask-01175", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the srcAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the srcAccessMask member of that instance of VkSubpassDependency" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dstAccessMask-01176", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the dstAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the dstAccessMask member of that instance of VkSubpassDependency" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-01177", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, dependencyFlags must be equal to the dependencyFlags member of that instance of VkSubpassDependency" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, bufferMemoryBarrierCount must be 0" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-image-01179", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the image member of any element of pImageMemoryBarriers must be equal to one of the elements of pAttachments that the current framebuffer was created with, that is also referred to by one of the elements of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-oldLayout-01180", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any element of pImageMemoryBarriers must be equal to the layout member of an element of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with, that refers to the same image" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-oldLayout-01181", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of an element of pImageMemoryBarriers must be equal" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182", - "text": " If vkCmdPipelineBarrier is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pImageMemoryBarriers must be VK_QUEUE_FAMILY_IGNORED" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01183", - "text": " Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the &amp;lt;&amp;lt;synchronization-pipeline-stages-supported, table of supported pipeline stages&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184", - "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185", - "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-parameter", - "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask", - "text": " srcStageMask must not be 0" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-parameter", - "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask", - "text": " dstStageMask must not be 0" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-parameter", - "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter", - "text": " If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter", - "text": " If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter", - "text": " If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-01186", - "text": " If vkCmdPipelineBarrier is called outside of a render pass instance, dependencyFlags must not include VK_DEPENDENCY_VIEW_LOCAL_BIT" - } - ] - }, - "VkMemoryBarrier": { - "core": [ - { - "vuid": "VUID-VkMemoryBarrier-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER" - }, - { - "vuid": "VUID-VkMemoryBarrier-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkMemoryBarrier-srcAccessMask-parameter", - "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkMemoryBarrier-dstAccessMask-parameter", - "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" - } - ] - }, - "VkBufferMemoryBarrier": { - "core": [ - { - "vuid": "VUID-VkBufferMemoryBarrier-offset-01187", - "text": " offset must be less than the size of buffer" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-size-01188", - "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-size-01189", - "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01196", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01931", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter", - "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter", - "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - } - ], - "!(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01190", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01192", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see &amp;lt;&amp;lt;devsandqueues-queueprops&amp;gt;&amp;gt;)" - } - ], - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01191", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01763", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory ownership transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01193", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01764", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-buffer-01765", - "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." - } - ] - }, - "VkImageMemoryBarrier": { - "core": [ - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01197", - "text": " oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-newLayout-01198", - "text": " newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01205", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01486", - "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01724", - "text": " If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01488", - "text": " subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01725", - "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01207", - "text": " If image has a depth/stencil format with both depth and stencil components, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01208", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01209", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01210", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01211", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01212", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01213", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01932", - "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-srcAccessMask-parameter", - "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-dstAccessMask-parameter", - "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-parameter", - "text": " oldLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-newLayout-parameter", - "text": " newLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-parameter", - "text": " subresourceRange must be a valid VkImageSubresourceRange structure" - } - ], - "!(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkImageMemoryBarrier-image-01199", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01200", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see &amp;lt;&amp;lt;devsandqueues-queueprops&amp;gt;&amp;gt;)." - } - ], - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkImageMemoryBarrier-image-01381", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01766", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01201", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED." - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01767", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01768", - "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or a special queue family reserved for external memory transfers, as described in &amp;lt;&amp;lt;synchronization-queue-transfers&amp;gt;&amp;gt;." - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageMemoryBarrier-image-01671", - "text": " If image has a single-plane color format or is not disjoint, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01672", - "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01673", - "text": " If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01658", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01659", - "text": " If either oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - } - ] - }, - "vkQueueWaitIdle": { - "core": [ - { - "vuid": "VUID-vkQueueWaitIdle-queue-parameter", - "text": " queue must be a valid VkQueue handle" - } - ] - }, - "vkDeviceWaitIdle": { - "core": [ - { - "vuid": "VUID-vkDeviceWaitIdle-device-parameter", - "text": " device must be a valid VkDevice handle" - } - ] - }, - "vkCreateRenderPass": { - "core": [ - { - "vuid": "VUID-vkCreateRenderPass-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateRenderPass-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateRenderPass-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateRenderPass-pRenderPass-parameter", - "text": " pRenderPass must be a valid pointer to a VkRenderPass handle" - } - ] - }, - "VkRenderPassCreateInfo": { - "core": [ - { - "vuid": "VUID-VkRenderPassCreateInfo-None-00832", - "text": " If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-attachment-00833", - "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-attachment-00834", - "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pPreserveAttachments-00835", - "text": " The value of each element of the pPreserveAttachments member in each element of pSubpasses must not be VK_ATTACHMENT_UNUSED" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-00836", - "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL." - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00837", - "text": " For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the &amp;lt;&amp;lt;synchronization-pipeline-stages-types, pipeline&amp;gt;&amp;gt; identified by the pipelineBindPoint member of the source subpass." - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00838", - "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the &amp;lt;&amp;lt;synchronization-pipeline-stages-types, pipeline&amp;gt;&amp;gt; identified by the pipelineBindPoint member of the source subpass." - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassInputAttachmentAspectCreateInfo or VkRenderPassMultiviewCreateInfo" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-parameter", - "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pSubpasses-parameter", - "text": " pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-parameter", - "text": " If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-subpassCount-arraylength", - "text": " subpassCount must be greater than 0" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01566", - "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL." - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01567", - "text": " For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL." - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pNext-01926", - "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the subpass member of each element of its pAspectReferences member must be less than subpassCount" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pNext-01927", - "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the member of pSubpasses identified by its subpass member" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pNext-01963", - "text": " If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the aspectMask member of any element of pAspectReferences must only include aspects that are present in images of the format of the input attachment specified by the subpass and inputAttachment of the same element of pAspectReferences" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-VkRenderPassCreateInfo-pNext-01928", - "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, and its subpassCount member is not zero, that member must be equal to the value of subpassCount" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pNext-01929", - "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, if its dependencyCount member is not zero, it must be equal to dependencyCount" - }, - { - "vuid": "VUID-VkRenderPassCreateInfo-pNext-01930", - "text": " If the pNext chain includes an instance of VkRenderPassMultiviewCreateInfo, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal" - } - ] - }, - "VkRenderPassMultiviewCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841", - "text": " Each view index must not be set in more than one element of pCorrelationMasks" - }, - { - "vuid": "VUID-VkRenderPassMultiviewCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO" - }, - { - "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter", - "text": " If subpassCount is not 0, pViewMasks must be a valid pointer to an array of subpassCount uint32_t values" - }, - { - "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter", - "text": " If dependencyCount is not 0, pViewOffsets must be a valid pointer to an array of dependencyCount int32_t values" - }, - { - "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter", - "text": " If correlationMaskCount is not 0, pCorrelationMasks must be a valid pointer to an array of correlationMaskCount uint32_t values" - } - ] - }, - "VkAttachmentDescription": { - "core": [ - { - "vuid": "VUID-VkAttachmentDescription-finalLayout-00843", - "text": " finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" - }, - { - "vuid": "VUID-VkAttachmentDescription-flags-parameter", - "text": " flags must be a valid combination of VkAttachmentDescriptionFlagBits values" - }, - { - "vuid": "VUID-VkAttachmentDescription-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-VkAttachmentDescription-samples-parameter", - "text": " samples must be a valid VkSampleCountFlagBits value" - }, - { - "vuid": "VUID-VkAttachmentDescription-loadOp-parameter", - "text": " loadOp must be a valid VkAttachmentLoadOp value" - }, - { - "vuid": "VUID-VkAttachmentDescription-storeOp-parameter", - "text": " storeOp must be a valid VkAttachmentStoreOp value" - }, - { - "vuid": "VUID-VkAttachmentDescription-stencilLoadOp-parameter", - "text": " stencilLoadOp must be a valid VkAttachmentLoadOp value" - }, - { - "vuid": "VUID-VkAttachmentDescription-stencilStoreOp-parameter", - "text": " stencilStoreOp must be a valid VkAttachmentStoreOp value" - }, - { - "vuid": "VUID-VkAttachmentDescription-initialLayout-parameter", - "text": " initialLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-VkAttachmentDescription-finalLayout-parameter", - "text": " finalLayout must be a valid VkImageLayout value" - } - ] - }, - "VkRenderPassInputAttachmentAspectCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO" - }, - { - "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter", - "text": " pAspectReferences must be a valid pointer to an array of aspectReferenceCount valid VkInputAttachmentAspectReference structures" - }, - { - "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength", - "text": " aspectReferenceCount must be greater than 0" - } - ] - }, - "VkInputAttachmentAspectReference": { - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-01964", - "text": " aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT" - }, - { - "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-parameter", - "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" - }, - { - "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask", - "text": " aspectMask must not be 0" - } - ] - }, - "VkSubpassDescription": { - "core": [ - { - "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-00844", - "text": " pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-VkSubpassDescription-colorAttachmentCount-00845", - "text": " colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments" - }, - { - "vuid": "VUID-VkSubpassDescription-loadOp-00846", - "text": " If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR" - }, - { - "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00847", - "text": " If pResolveAttachments is not NULL, for each resolve attachment that does not have the value VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have the value VK_ATTACHMENT_UNUSED" - }, - { - "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00848", - "text": " If pResolveAttachments is not NULL, the sample count of each element of pColorAttachments must be anything other than VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00849", - "text": " Each element of pResolveAttachments must have a sample count of VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00850", - "text": " Each element of pResolveAttachments must have the same VkFormat as its corresponding color attachment" - }, - { - "vuid": "VUID-VkSubpassDescription-pColorAttachments-01417", - "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count" - }, - { - "vuid": "VUID-VkSubpassDescription-None-00852", - "text": " If any input attachments are VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass must not access those input attachments from the fragment shader" - }, - { - "vuid": "VUID-VkSubpassDescription-attachment-00853", - "text": " The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED" - }, - { - "vuid": "VUID-VkSubpassDescription-pPreserveAttachments-00854", - "text": " Each element of pPreserveAttachments must not also be an element of any other member of the subpass description" - }, - { - "vuid": "VUID-VkSubpassDescription-layout-00855", - "text": " If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same layout" - }, - { - "vuid": "VUID-VkSubpassDescription-flags-parameter", - "text": " flags must be a valid combination of VkSubpassDescriptionFlagBits values" - }, - { - "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-parameter", - "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" - }, - { - "vuid": "VUID-VkSubpassDescription-pInputAttachments-parameter", - "text": " If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures" - }, - { - "vuid": "VUID-VkSubpassDescription-pColorAttachments-parameter", - "text": " If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures" - }, - { - "vuid": "VUID-VkSubpassDescription-pResolveAttachments-parameter", - "text": " If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures" - }, - { - "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-parameter", - "text": " If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure" - }, - { - "vuid": "VUID-VkSubpassDescription-pPreserveAttachments-parameter", - "text": " If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values" - } - ], - "(VK_AMD_mixed_attachment_samples)": [ - { - "vuid": "VUID-VkSubpassDescription-pColorAttachments-01506", - "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED" - } - ], - "!(VK_AMD_mixed_attachment_samples)+!(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-01418", - "text": " If pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count" - } - ], - "(VK_NVX_multiview_per_view_attributes)": [ - { - "vuid": "VUID-VkSubpassDescription-flags-00856", - "text": " If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX." - } - ] - }, - "VkAttachmentReference": { - "core": [ - { - "vuid": "VUID-VkAttachmentReference-layout-00857", - "text": " layout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" - }, - { - "vuid": "VUID-VkAttachmentReference-layout-parameter", - "text": " layout must be a valid VkImageLayout value" - } - ] - }, - "VkSubpassDependency": { - "core": [ - { - "vuid": "VUID-VkSubpassDependency-srcSubpass-00858", - "text": " If srcSubpass is not VK_SUBPASS_EXTERNAL, srcStageMask must not include VK_PIPELINE_STAGE_HOST_BIT" - }, - { - "vuid": "VUID-VkSubpassDependency-dstSubpass-00859", - "text": " If dstSubpass is not VK_SUBPASS_EXTERNAL, dstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT" - }, - { - "vuid": "VUID-VkSubpassDependency-srcStageMask-00860", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-VkSubpassDependency-dstStageMask-00861", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" - }, - { - "vuid": "VUID-VkSubpassDependency-srcStageMask-00862", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-VkSubpassDependency-dstStageMask-00863", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" - }, - { - "vuid": "VUID-VkSubpassDependency-srcSubpass-00864", - "text": " srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order" - }, - { - "vuid": "VUID-VkSubpassDependency-srcSubpass-00865", - "text": " srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL" - }, - { - "vuid": "VUID-VkSubpassDependency-srcSubpass-00866", - "text": " If srcSubpass is equal to dstSubpass, srcStageMask and dstStageMask must only contain one of VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, or VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT" - }, - { - "vuid": "VUID-VkSubpassDependency-srcSubpass-00867", - "text": " If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are &amp;lt;&amp;lt;synchronization-framebuffer-regions,framebuffer-space stages&amp;gt;&amp;gt;, the &amp;lt;&amp;lt;synchronization-pipeline-stages-order, logically latest&amp;gt;&amp;gt; pipeline stage in srcStageMask must be &amp;lt;&amp;lt;synchronization-pipeline-stages-order, logically earlier&amp;gt;&amp;gt; than or equal to the &amp;lt;&amp;lt;synchronization-pipeline-stages-order, logically earliest&amp;gt;&amp;gt; pipeline stage in dstStageMask" - }, - { - "vuid": "VUID-VkSubpassDependency-srcAccessMask-00868", - "text": " Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkSubpassDependency-dstAccessMask-00869", - "text": " Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the &amp;lt;&amp;lt;synchronization-access-types-supported, table of supported access types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkSubpassDependency-srcStageMask-parameter", - "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-VkSubpassDependency-srcStageMask-requiredbitmask", - "text": " srcStageMask must not be 0" - }, - { - "vuid": "VUID-VkSubpassDependency-dstStageMask-parameter", - "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" - }, - { - "vuid": "VUID-VkSubpassDependency-dstStageMask-requiredbitmask", - "text": " dstStageMask must not be 0" - }, - { - "vuid": "VUID-VkSubpassDependency-srcAccessMask-parameter", - "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkSubpassDependency-dstAccessMask-parameter", - "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkSubpassDependency-dependencyFlags-parameter", - "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-VkSubpassDependency-dependencyFlags-00870", - "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then both srcSubpass and dstSubpass must not equal VK_SUBPASS_EXTERNAL" - }, - { - "vuid": "VUID-VkSubpassDependency-dependencyFlags-00871", - "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then the render pass must have multiview enabled" - }, - { - "vuid": "VUID-VkSubpassDependency-srcSubpass-00872", - "text": " If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT" - } - ] - }, - "vkDestroyRenderPass": { - "core": [ - { - "vuid": "VUID-vkDestroyRenderPass-renderPass-00873", - "text": " All submitted commands that refer to renderPass must have completed execution" - }, - { - "vuid": "VUID-vkDestroyRenderPass-renderPass-00874", - "text": " If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyRenderPass-renderPass-00875", - "text": " If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyRenderPass-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyRenderPass-renderPass-parameter", - "text": " If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle" - }, - { - "vuid": "VUID-vkDestroyRenderPass-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyRenderPass-renderPass-parent", - "text": " If renderPass is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateFramebuffer": { - "core": [ - { - "vuid": "VUID-vkCreateFramebuffer-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateFramebuffer-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateFramebuffer-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateFramebuffer-pFramebuffer-parameter", - "text": " pFramebuffer must be a valid pointer to a VkFramebuffer handle" - } - ] - }, - "VkFramebufferCreateInfo": { - "core": [ - { - "vuid": "VUID-VkFramebufferCreateInfo-attachmentCount-00876", - "text": " attachmentCount must be equal to the attachment count specified in renderPass" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00877", - "text": " Each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00878", - "text": " Each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00879", - "text": " Each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00880", - "text": " Each element of pAttachments must have been created with an VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00881", - "text": " Each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00882", - "text": " Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00883", - "text": " Each element of pAttachments must only specify a single mip level" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00884", - "text": " Each element of pAttachments must have been created with the identity swizzle" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-width-00885", - "text": " width must be greater than 0." - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-width-00886", - "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-height-00887", - "text": " height must be greater than 0." - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-height-00888", - "text": " height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-layers-00889", - "text": " layers must be greater than 0." - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-layers-00890", - "text": " layers must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-renderPass-parameter", - "text": " renderPass must be a valid VkRenderPass handle" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-parameter", - "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles" - }, - { - "vuid": "VUID-VkFramebufferCreateInfo-commonparent", - "text": " Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00891", - "text": " Each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format" - } - ] - }, - "vkDestroyFramebuffer": { - "core": [ - { - "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00892", - "text": " All submitted commands that refer to framebuffer must have completed execution" - }, - { - "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00893", - "text": " If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00894", - "text": " If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyFramebuffer-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyFramebuffer-framebuffer-parameter", - "text": " If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle" - }, - { - "vuid": "VUID-vkDestroyFramebuffer-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyFramebuffer-framebuffer-parent", - "text": " If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCmdBeginRenderPass": { - "core": [ - { - "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00895", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00897", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00898", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00899", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00900", - "text": " If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-srcStageMask-00901", - "text": " The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from." - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter", - "text": " pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-contents-parameter", - "text": " contents must be a valid VkSubpassContents value" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdBeginRenderPass-bufferlevel", - "text": " commandBuffer must be a primary VkCommandBuffer" - } - ], - "!(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00896", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-01758", - "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" - } - ] - }, - "VkRenderPassBeginInfo": { - "core": [ - { - "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-00902", - "text": " clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR" - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-00903", - "text": " If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount valid VkClearValue unions" - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-renderPass-00904", - "text": " renderPass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer." - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO" - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo or VkRenderPassSampleLocationsBeginInfoEXT" - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-renderPass-parameter", - "text": " renderPass must be a valid VkRenderPass handle" - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-parameter", - "text": " framebuffer must be a valid VkFramebuffer handle" - }, - { - "vuid": "VUID-VkRenderPassBeginInfo-commonparent", - "text": " Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkRenderPassSampleLocationsBeginInfoEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT" - }, - { - "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter", - "text": " If attachmentInitialSampleLocationsCount is not 0, pAttachmentInitialSampleLocations must be a valid pointer to an array of attachmentInitialSampleLocationsCount valid VkAttachmentSampleLocationsEXT structures" - }, - { - "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter", - "text": " If postSubpassSampleLocationsCount is not 0, pPostSubpassSampleLocations must be a valid pointer to an array of postSubpassSampleLocationsCount valid VkSubpassSampleLocationsEXT structures" - } - ] - }, - "VkAttachmentSampleLocationsEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531", - "text": " attachmentIndex must be less than the attachmentCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with" - }, - { - "vuid": "VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter", - "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" - } - ] - }, - "VkSubpassSampleLocationsEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532", - "text": " subpassIndex must be less than the subpassCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with" - }, - { - "vuid": "VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter", - "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" - } - ] - }, - "VkDeviceGroupRenderPassBeginInfo": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905", - "text": " deviceMask must be a valid device mask value" - }, - { - "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906", - "text": " deviceMask must not be zero" - }, - { - "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907", - "text": " deviceMask must be a subset of the command buffer’s initial device mask" - }, - { - "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908", - "text": " deviceRenderAreaCount must either be zero or equal to the number of physical devices in the logical device." - }, - { - "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO" - }, - { - "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter", - "text": " If deviceRenderAreaCount is not 0, pDeviceRenderAreas must be a valid pointer to an array of deviceRenderAreaCount VkRect2D structures" - } - ] - }, - "vkGetRenderAreaGranularity": { - "core": [ - { - "vuid": "VUID-vkGetRenderAreaGranularity-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetRenderAreaGranularity-renderPass-parameter", - "text": " renderPass must be a valid VkRenderPass handle" - }, - { - "vuid": "VUID-vkGetRenderAreaGranularity-pGranularity-parameter", - "text": " pGranularity must be a valid pointer to a VkExtent2D structure" - }, - { - "vuid": "VUID-vkGetRenderAreaGranularity-renderPass-parent", - "text": " renderPass must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCmdNextSubpass": { - "core": [ - { - "vuid": "VUID-vkCmdNextSubpass-None-00909", - "text": " The current subpass index must be less than the number of subpasses in the render pass minus one" - }, - { - "vuid": "VUID-vkCmdNextSubpass-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdNextSubpass-contents-parameter", - "text": " contents must be a valid VkSubpassContents value" - }, - { - "vuid": "VUID-vkCmdNextSubpass-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdNextSubpass-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdNextSubpass-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdNextSubpass-bufferlevel", - "text": " commandBuffer must be a primary VkCommandBuffer" - } - ] - }, - "vkCmdEndRenderPass": { - "core": [ - { - "vuid": "VUID-vkCmdEndRenderPass-None-00910", - "text": " The current subpass index must be equal to the number of subpasses in the render pass minus one" - }, - { - "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdEndRenderPass-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdEndRenderPass-bufferlevel", - "text": " commandBuffer must be a primary VkCommandBuffer" - } - ] - }, - "vkCreateShaderModule": { - "core": [ - { - "vuid": "VUID-vkCreateShaderModule-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateShaderModule-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkShaderModuleCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateShaderModule-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateShaderModule-pShaderModule-parameter", - "text": " pShaderModule must be a valid pointer to a VkShaderModule handle" - } - ] - }, - "VkShaderModuleCreateInfo": { - "core": [ - { - "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-01085", - "text": " codeSize must be greater than 0" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01089", - "text": " pCode must declare the Shader capability for SPIR-V code" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01090", - "text": " pCode must not declare any capability that is not supported by the API, as described by the &amp;lt;&amp;lt;spirvenv-module-validation, Capabilities&amp;gt;&amp;gt; section of the &amp;lt;&amp;lt;spirvenv-capabilities,SPIR-V Environment&amp;gt;&amp;gt; appendix" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01091", - "text": " If pCode declares any of the capabilities listed as optional in the &amp;lt;&amp;lt;spirvenv-capabilities-table,SPIR-V Environment&amp;gt;&amp;gt; appendix, the corresponding feature(s) must be enabled." - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkShaderModuleValidationCacheCreateInfoEXT" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-parameter", - "text": " pCode must be a valid pointer to an array of \\(codeSize \\over 4\\) uint32_t values" - } - ], - "!(VK_NV_glsl_shader)": [ - { - "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-01086", - "text": " codeSize must be a multiple of 4" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01087", - "text": " pCode must point to valid SPIR-V code, formatted and packed as described by the &amp;lt;&amp;lt;spirv-spec,Khronos SPIR-V Specification&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01088", - "text": " pCode must adhere to the validation rules described by the &amp;lt;&amp;lt;spirvenv-module-validation, Validation Rules within a Module&amp;gt;&amp;gt; section of the &amp;lt;&amp;lt;spirvenv-capabilities,SPIR-V Environment&amp;gt;&amp;gt; appendix" - } - ], - "(VK_NV_glsl_shader)": [ - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01376", - "text": " If pCode points to SPIR-V code, codeSize must be a multiple of 4" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01377", - "text": " pCode must point to either valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification or valid GLSL code which must be written to the GL_KHR_vulkan_glsl extension specification" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01378", - "text": " If pCode points to SPIR-V code, that code must adhere to the validation rules described by the &amp;lt;&amp;lt;spirvenv-module-validation, Validation Rules within a Module&amp;gt;&amp;gt; section of the &amp;lt;&amp;lt;spirvenv-capabilities,SPIR-V Environment&amp;gt;&amp;gt; appendix" - }, - { - "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01379", - "text": " If pCode points to GLSL code, it must be valid GLSL code written to the GL_KHR_vulkan_glsl GLSL extension specification" - } - ] - }, - "VkShaderModuleValidationCacheCreateInfoEXT": { - "(VK_EXT_validation_cache)": [ - { - "vuid": "VUID-VkShaderModuleValidationCacheCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkShaderModuleValidationCacheCreateInfoEXT-validationCache-parameter", - "text": " validationCache must be a valid VkValidationCacheEXT handle" - } - ] - }, - "vkDestroyShaderModule": { - "core": [ - { - "vuid": "VUID-vkDestroyShaderModule-shaderModule-01092", - "text": " If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyShaderModule-shaderModule-01093", - "text": " If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyShaderModule-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyShaderModule-shaderModule-parameter", - "text": " If shaderModule is not VK_NULL_HANDLE, shaderModule must be a valid VkShaderModule handle" - }, - { - "vuid": "VUID-vkDestroyShaderModule-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyShaderModule-shaderModule-parent", - "text": " If shaderModule is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateValidationCacheEXT": { - "(VK_EXT_validation_cache)": [ - { - "vuid": "VUID-vkCreateValidationCacheEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateValidationCacheEXT-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkValidationCacheCreateInfoEXT structure" - }, - { - "vuid": "VUID-vkCreateValidationCacheEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateValidationCacheEXT-pValidationCache-parameter", - "text": " pValidationCache must be a valid pointer to a VkValidationCacheEXT handle" - } - ] - }, - "VkValidationCacheCreateInfoEXT": { - "(VK_EXT_validation_cache)": [ - { - "vuid": "VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534", - "text": " If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetValidationCacheDataEXT when pInitialData was originally retrieved" - }, - { - "vuid": "VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535", - "text": " If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetValidationCacheDataEXT" - }, - { - "vuid": "VUID-VkValidationCacheCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkValidationCacheCreateInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkValidationCacheCreateInfoEXT-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkValidationCacheCreateInfoEXT-pInitialData-parameter", - "text": " If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes" - } - ] - }, - "vkMergeValidationCachesEXT": { - "(VK_EXT_validation_cache)": [ - { - "vuid": "VUID-vkMergeValidationCachesEXT-dstCache-01536", - "text": " dstCache must not appear in the list of source caches" - }, - { - "vuid": "VUID-vkMergeValidationCachesEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkMergeValidationCachesEXT-dstCache-parameter", - "text": " dstCache must be a valid VkValidationCacheEXT handle" - }, - { - "vuid": "VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter", - "text": " pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkValidationCacheEXT handles" - }, - { - "vuid": "VUID-vkMergeValidationCachesEXT-srcCacheCount-arraylength", - "text": " srcCacheCount must be greater than 0" - }, - { - "vuid": "VUID-vkMergeValidationCachesEXT-dstCache-parent", - "text": " dstCache must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkMergeValidationCachesEXT-pSrcCaches-parent", - "text": " Each element of pSrcCaches must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetValidationCacheDataEXT": { - "(VK_EXT_validation_cache)": [ - { - "vuid": "VUID-vkGetValidationCacheDataEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetValidationCacheDataEXT-validationCache-parameter", - "text": " validationCache must be a valid VkValidationCacheEXT handle" - }, - { - "vuid": "VUID-vkGetValidationCacheDataEXT-pDataSize-parameter", - "text": " pDataSize must be a valid pointer to a size_t value" - }, - { - "vuid": "VUID-vkGetValidationCacheDataEXT-pData-parameter", - "text": " If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes" - }, - { - "vuid": "VUID-vkGetValidationCacheDataEXT-validationCache-parent", - "text": " validationCache must have been created, allocated, or retrieved from device" - } - ] - }, - "vkDestroyValidationCacheEXT": { - "(VK_EXT_validation_cache)": [ - { - "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-01537", - "text": " If VkAllocationCallbacks were provided when validationCache was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-01538", - "text": " If no VkAllocationCallbacks were provided when validationCache was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyValidationCacheEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-parameter", - "text": " If validationCache is not VK_NULL_HANDLE, validationCache must be a valid VkValidationCacheEXT handle" - }, - { - "vuid": "VUID-vkDestroyValidationCacheEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-parent", - "text": " If validationCache is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateComputePipelines": { - "core": [ - { - "vuid": "VUID-vkCreateComputePipelines-flags-00695", - "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" - }, - { - "vuid": "VUID-vkCreateComputePipelines-flags-00696", - "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" - }, - { - "vuid": "VUID-vkCreateComputePipelines-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateComputePipelines-pipelineCache-parameter", - "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" - }, - { - "vuid": "VUID-vkCreateComputePipelines-pCreateInfos-parameter", - "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures" - }, - { - "vuid": "VUID-vkCreateComputePipelines-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateComputePipelines-pPipelines-parameter", - "text": " pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles" - }, - { - "vuid": "VUID-vkCreateComputePipelines-createInfoCount-arraylength", - "text": " createInfoCount must be greater than 0" - }, - { - "vuid": "VUID-vkCreateComputePipelines-pipelineCache-parent", - "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "VkComputePipelineCreateInfo": { - "core": [ - { - "vuid": "VUID-VkComputePipelineCreateInfo-flags-00697", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-flags-00698", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-flags-00699", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-flags-00700", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-stage-00701", - "text": " The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-stage-00702", - "text": " The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the &amp;lt;&amp;lt;interfaces,Shader Interfaces&amp;gt;&amp;gt; chapter" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-layout-00703", - "text": " layout must be &amp;lt;&amp;lt;descriptorsets-pipelinelayout-consistency,consistent&amp;gt;&amp;gt; with the layout of the compute shader specified in stage" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-layout-01687", - "text": " The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkPipelineCreateFlagBits values" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-stage-parameter", - "text": " stage must be a valid VkPipelineShaderStageCreateInfo structure" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-layout-parameter", - "text": " layout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-VkComputePipelineCreateInfo-commonparent", - "text": " Both of basePipelineHandle, and layout that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkPipelineShaderStageCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00704", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00705", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00706", - "text": " stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-00707", - "text": " pName must be the name of an OpEntryPoint in module with an execution model that matches stage" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708", - "text": " If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709", - "text": " If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710", - "text": " If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711", - "text": " If the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00712", - "text": " If stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00713", - "text": " If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction that specifies a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00714", - "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00715", - "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00716", - "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00717", - "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00718", - "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00719", - "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, it must write to FragDepth in all execution paths" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-parameter", - "text": " stage must be a valid VkShaderStageFlagBits value" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-module-parameter", - "text": " module must be a valid VkShaderModule handle" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-parameter", - "text": " pName must be a null-terminated UTF-8 string" - }, - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter", - "text": " If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure" - } - ], - "(VK_EXT_shader_stencil_export)": [ - { - "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-01511", - "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragStencilRefEXT in any execution path, it must write to FragStencilRefEXT in all execution paths" - } - ] - }, - "vkCreateGraphicsPipelines": { - "core": [ - { - "vuid": "VUID-vkCreateGraphicsPipelines-flags-00720", - "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-flags-00721", - "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-parameter", - "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter", - "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-pPipelines-parameter", - "text": " pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength", - "text": " createInfoCount must be greater than 0" - }, - { - "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-parent", - "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "VkGraphicsPipelineCreateInfo": { - "core": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00722", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00723", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00724", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00725", - "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00726", - "text": " The stage member of each element of pStages must be unique" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00727", - "text": " The stage member of one element of pStages must be VK_SHADER_STAGE_VERTEX_BIT" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00728", - "text": " The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00729", - "text": " If pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00730", - "text": " If pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00731", - "text": " If pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pTessellationState must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00732", - "text": " If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00733", - "text": " If pStages includes tessellation shader stages, and the shader code of both stages contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline, they must both specify the same subdivision mode" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00734", - "text": " If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the output patch size in the pipeline" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00735", - "text": " If pStages includes tessellation shader stages, and the shader code of both contain an OpExecutionMode instruction that specifies the out patch size in the pipeline, they must both specify the same patch size" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00736", - "text": " If pStages includes tessellation shader stages, the topology member of pInputAssembly must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-topology-00737", - "text": " If the topology member of pInputAssembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, pStages must include tessellation shader stages" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00738", - "text": " If pStages includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is &amp;lt;&amp;lt;shaders-geometry-execution, compatible&amp;gt;&amp;gt; with the primitive topology specified in pInputAssembly" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00739", - "text": " If pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is &amp;lt;&amp;lt;shaders-geometry-execution, compatible&amp;gt;&amp;gt; with the primitive topology that is output by the tessellation stages" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00740", - "text": " If pStages includes a fragment shader stage and a geometry shader stage, and the fragment shader code reads from an input variable that is decorated with PrimitiveID, then the geometry shader code must write to a matching output variable, decorated with PrimitiveID, in all execution paths" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00741", - "text": " If pStages includes a fragment shader stage, its shader code must not read from any input attachment that is defined as VK_ATTACHMENT_UNUSED in subpass" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00742", - "text": " The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the &amp;lt;&amp;lt;interfaces,Shader Interfaces&amp;gt;&amp;gt; chapter" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00745", - "text": " If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the blendEnable member of the corresponding element of the pAttachment member of pColorBlendState must be VK_FALSE if the format of the attachment does not support color blend operations, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746", - "text": " If rasterization is not disabled and the subpass uses color attachments, the attachmentCount member of pColorBlendState must be equal to the colorAttachmentCount used to create subpass" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747", - "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState::viewportCount VkViewport structures" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748", - "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState::scissorCount VkRect2D structures" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749", - "text": " If the wide lines feature is not enabled, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_WIDTH, the lineWidth member of pRasterizationState must be 1.0" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750", - "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751", - "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752", - "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses a depth/stencil attachment, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753", - "text": " If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754", - "text": " If the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-00756", - "text": " layout must be &amp;lt;&amp;lt;descriptorsets-pipelinelayout-consistency,consistent&amp;gt;&amp;gt; with all shaders specified in pStages" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00758", - "text": " If subpass does not use any color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must follow the rules for a &amp;lt;&amp;lt;renderpass-noattachments, zero-attachment subpass&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00759", - "text": " subpass must be a valid subpass within renderPass" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-01688", - "text": " The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkPipelineCreateFlagBits values" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-parameter", - "text": " pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter", - "text": " pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter", - "text": " pInputAssemblyState must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter", - "text": " pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter", - "text": " If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-parameter", - "text": " layout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter", - "text": " renderPass must be a valid VkRenderPass handle" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength", - "text": " stageCount must be greater than 0" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-commonparent", - "text": " Each of basePipelineHandle, layout, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00743", - "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00744", - "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01756", - "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01757", - "text": " If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-01565", - "text": " If pStages includes a fragment shader stage and an input attachment was referenced by the VkRenderPassInputAttachmentAspectCreateInfo at renderPass create time, its shader code must not read from any aspect that was not specified in the aspectMask of the corresponding VkInputAttachmentAspectReference structure." - } - ], - "!(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755", - "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive" - } - ], - "(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755", - "text": " If the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive" - } - ], - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521", - "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.width must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.width as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522", - "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.height must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.height as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523", - "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524", - "text": " If the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample" - } - ], - "!(VK_AMD_mixed_attachment_samples)+!(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00757", - "text": " If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must be the same as the sample count for those subpass attachments" - } - ], - "(VK_AMD_mixed_attachment_samples)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01505", - "text": " If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must equal the maximum of the sample counts of those subpass attachments" - } - ], - "(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01411", - "text": " If subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the rasterizationSamples member of pMultisampleState must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01412", - "text": " If subpass has any color attachments, then the rasterizationSamples member of pMultisampleState must be greater than or equal to the sample count for those subpass attachments" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00760", - "text": " If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewTessellationShader is not enabled, then pStages must not include tessellation shaders." - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00761", - "text": " If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewGeometryShader is not enabled, then pStages must not include a geometry shader." - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00762", - "text": " If the renderPass has multiview enabled and subpass has more than one bit set in the view mask, shaders in the pipeline must not write to the Layer built-in output" - }, - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00763", - "text": " If the renderPass has multiview enabled, then all shaders must not include variables decorated with the Layer built-in decoration in their interfaces." - } - ], - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00764", - "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag." - } - ], - "(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715", - "text": " If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, chained to the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures" - } - ] - }, - "VkPipelineDynamicStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442", - "text": " Each element of pDynamicStates must be unique" - }, - { - "vuid": "VUID-VkPipelineDynamicStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter", - "text": " pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values" - }, - { - "vuid": "VUID-VkPipelineDynamicStateCreateInfo-dynamicStateCount-arraylength", - "text": " dynamicStateCount must be greater than 0" - } - ] - }, - "vkDestroyPipeline": { - "core": [ - { - "vuid": "VUID-vkDestroyPipeline-pipeline-00765", - "text": " All submitted commands that refer to pipeline must have completed execution" - }, - { - "vuid": "VUID-vkDestroyPipeline-pipeline-00766", - "text": " If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyPipeline-pipeline-00767", - "text": " If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyPipeline-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyPipeline-pipeline-parameter", - "text": " If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle" - }, - { - "vuid": "VUID-vkDestroyPipeline-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyPipeline-pipeline-parent", - "text": " If pipeline is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreatePipelineCache": { - "core": [ - { - "vuid": "VUID-vkCreatePipelineCache-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreatePipelineCache-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkPipelineCacheCreateInfo structure" - }, - { - "vuid": "VUID-vkCreatePipelineCache-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreatePipelineCache-pPipelineCache-parameter", - "text": " pPipelineCache must be a valid pointer to a VkPipelineCache handle" - } - ] - }, - "VkPipelineCacheCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00768", - "text": " If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved" - }, - { - "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00769", - "text": " If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData" - }, - { - "vuid": "VUID-VkPipelineCacheCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineCacheCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPipelineCacheCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineCacheCreateInfo-pInitialData-parameter", - "text": " If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes" - } - ] - }, - "vkMergePipelineCaches": { - "core": [ - { - "vuid": "VUID-vkMergePipelineCaches-dstCache-00770", - "text": " dstCache must not appear in the list of source caches" - }, - { - "vuid": "VUID-vkMergePipelineCaches-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkMergePipelineCaches-dstCache-parameter", - "text": " dstCache must be a valid VkPipelineCache handle" - }, - { - "vuid": "VUID-vkMergePipelineCaches-pSrcCaches-parameter", - "text": " pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkPipelineCache handles" - }, - { - "vuid": "VUID-vkMergePipelineCaches-srcCacheCount-arraylength", - "text": " srcCacheCount must be greater than 0" - }, - { - "vuid": "VUID-vkMergePipelineCaches-dstCache-parent", - "text": " dstCache must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkMergePipelineCaches-pSrcCaches-parent", - "text": " Each element of pSrcCaches must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetPipelineCacheData": { - "core": [ - { - "vuid": "VUID-vkGetPipelineCacheData-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetPipelineCacheData-pipelineCache-parameter", - "text": " pipelineCache must be a valid VkPipelineCache handle" - }, - { - "vuid": "VUID-vkGetPipelineCacheData-pDataSize-parameter", - "text": " pDataSize must be a valid pointer to a size_t value" - }, - { - "vuid": "VUID-vkGetPipelineCacheData-pData-parameter", - "text": " If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes" - }, - { - "vuid": "VUID-vkGetPipelineCacheData-pipelineCache-parent", - "text": " pipelineCache must have been created, allocated, or retrieved from device" - } - ] - }, - "vkDestroyPipelineCache": { - "core": [ - { - "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00771", - "text": " If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00772", - "text": " If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyPipelineCache-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-parameter", - "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" - }, - { - "vuid": "VUID-vkDestroyPipelineCache-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-parent", - "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "VkSpecializationInfo": { - "core": [ - { - "vuid": "VUID-VkSpecializationInfo-offset-00773", - "text": " The offset member of each element of pMapEntries must be less than dataSize" - }, - { - "vuid": "VUID-VkSpecializationInfo-pMapEntries-00774", - "text": " The size member of each element of pMapEntries must be less than or equal to dataSize minus offset" - }, - { - "vuid": "VUID-VkSpecializationInfo-mapEntryCount-00775", - "text": " If mapEntryCount is not 0, pMapEntries must be a valid pointer to an array of mapEntryCount valid VkSpecializationMapEntry structures" - }, - { - "vuid": "VUID-VkSpecializationInfo-pData-parameter", - "text": " If dataSize is not 0, pData must be a valid pointer to an array of dataSize bytes" - } - ] - }, - "VkSpecializationMapEntry": { - "core": [ - { - "vuid": "VUID-VkSpecializationMapEntry-constantID-00776", - "text": " For a constantID specialization constant declared in a shader, size must match the byte size of the constantID. If the specialization constant is of type boolean, size must be the byte size of VkBool32" - } - ] - }, - "vkCmdBindPipeline": { - "core": [ - { - "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00777", - "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations" - }, - { - "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00778", - "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00779", - "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline" - }, - { - "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00780", - "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline" - }, - { - "vuid": "VUID-vkCmdBindPipeline-pipeline-00781", - "text": " If the &amp;lt;&amp;lt;features-features-variableMultisampleRate,variable multisample rate&amp;gt;&amp;gt; feature is not supported, pipeline is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline" - }, - { - "vuid": "VUID-vkCmdBindPipeline-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-parameter", - "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" - }, - { - "vuid": "VUID-vkCmdBindPipeline-pipeline-parameter", - "text": " pipeline must be a valid VkPipeline handle" - }, - { - "vuid": "VUID-vkCmdBindPipeline-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBindPipeline-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdBindPipeline-commonparent", - "text": " Both of commandBuffer, and pipeline must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdBindPipeline-variableSampleLocations-01525", - "text": " If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, and pipeline is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its sampleLocationsEnable member set to VK_TRUE but without VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sampleLocationsInfo specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created" - } - ] - }, - "vkGetShaderInfoAMD": { - "(VK_AMD_shader_info)": [ - { - "vuid": "VUID-vkGetShaderInfoAMD-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetShaderInfoAMD-pipeline-parameter", - "text": " pipeline must be a valid VkPipeline handle" - }, - { - "vuid": "VUID-vkGetShaderInfoAMD-shaderStage-parameter", - "text": " shaderStage must be a valid VkShaderStageFlagBits value" - }, - { - "vuid": "VUID-vkGetShaderInfoAMD-infoType-parameter", - "text": " infoType must be a valid VkShaderInfoTypeAMD value" - }, - { - "vuid": "VUID-vkGetShaderInfoAMD-pInfoSize-parameter", - "text": " pInfoSize must be a valid pointer to a size_t value" - }, - { - "vuid": "VUID-vkGetShaderInfoAMD-pInfo-parameter", - "text": " If the value referenced by pInfoSize is not 0, and pInfo is not NULL, pInfo must be a valid pointer to an array of pInfoSize bytes" - }, - { - "vuid": "VUID-vkGetShaderInfoAMD-pipeline-parent", - "text": " pipeline must have been created, allocated, or retrieved from device" - } - ] - }, - "VkAllocationCallbacks": { - "core": [ - { - "vuid": "VUID-VkAllocationCallbacks-pfnAllocation-00632", - "text": " pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction" - }, - { - "vuid": "VUID-VkAllocationCallbacks-pfnReallocation-00633", - "text": " pfnReallocation must be a valid pointer to a valid user-defined PFN_vkReallocationFunction" - }, - { - "vuid": "VUID-VkAllocationCallbacks-pfnFree-00634", - "text": " pfnFree must be a valid pointer to a valid user-defined PFN_vkFreeFunction" - }, - { - "vuid": "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635", - "text": " If either of pfnInternalAllocation or pfnInternalFree is not NULL, both must be valid callbacks" - } - ] - }, - "vkGetPhysicalDeviceMemoryProperties": { - "core": [ - { - "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter", - "text": " pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties structure" - } - ] - }, - "vkGetPhysicalDeviceMemoryProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter", - "text": " pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties2 structure" - } - ] - }, - "VkPhysicalDeviceMemoryProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2" - }, - { - "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkAllocateMemory": { - "core": [ - { - "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01713", - "text": " pAllocateInfo\\-&amp;gt;allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[pAllocateInfo\\-&amp;gt;memoryTypeIndex].size as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from." - }, - { - "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01714", - "text": " pAllocateInfo\\-&amp;gt;memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from." - }, - { - "vuid": "VUID-vkAllocateMemory-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkAllocateMemory-pAllocateInfo-parameter", - "text": " pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure" - }, - { - "vuid": "VUID-vkAllocateMemory-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkAllocateMemory-pMemory-parameter", - "text": " pMemory must be a valid pointer to a VkDeviceMemory handle" - } - ] - }, - "VkMemoryAllocateInfo": { - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00638", - "text": " allocationSize must be greater than 0" - } - ], - "(VK_KHR_external_memory)+(VK_KHR_dedicated_allocation,VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-pNext-00639", - "text": " If the pNext chain contains an instance of VkExportMemoryAllocateInfo, and any of the handle types specified in VkExportMemoryAllocateInfo::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2 in VkExternalImageFormatProperties::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferProperties::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of ifdef::VK_KHR_dedicated_allocation[VkMemoryDedicatedAllocateInfo]" - } - ], - "(VK_KHR_external_memory)+(VK_NV_external_memory)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-pNext-00640", - "text": " If the pNext chain contains an instance of VkExportMemoryAllocateInfo, it must not contain an instance of VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV." - } - ], - "(VK_KHR_external_memory_win32+VK_NV_external_memory_win32)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-pNext-00641", - "text": " If the pNext chain contains an instance of VkImportMemoryWin32HandleInfoKHR, it must not contain an instance of VkImportMemoryWin32HandleInfoNV." - } - ], - "(VK_KHR_external_memory_fd)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01742", - "text": " If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created." - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648", - "text": " If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHR." - } - ], - "(VK_KHR_external_memory+VK_KHR_device_group)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-None-00643", - "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfo must match that specified when the memory object being imported was allocated." - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-None-00644", - "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the memory was originally allocated." - } - ], - "(VK_KHR_external_memory_win32)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645", - "text": " If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHR." - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01743", - "text": " If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, then the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created." - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00646", - "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, allocationSize must match the size reported in the memory requirements of the image or buffer member of the instance of VkDedicatedAllocationMemoryAllocateInfoNV included in the pNext chain." - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00647", - "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted." - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872", - "text": " If the protected memory feature is not enabled, the VkMemoryAllocateInfo::memoryTypeIndex must not indicate a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT." - } - ], - "(VK_EXT_external_memory_host)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744", - "text": " If the parameters define an import operation and the external handle is a host pointer, the value of memoryTypeIndex must be one of those returned by vkGetMemoryHostPointerPropertiesEXT" - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01745", - "text": " If the parameters define an import operation and the external handle is a host pointer, allocationSize must be an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-None-01873", - "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BIT_ANDROID:" - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-pNext-01874", - "text": " If the parameters do not define an import operation, and the pNext chain contains an instance of VkExportMemoryAllocateInfo with VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID included in its handleTypes member, and the pNext contains an instance of VkMemoryDedicatedAllocateInfo with image not equal to VK_NULL_HANDLE, then allocationSize must be 0, otherwise allocationSize must be greater than 0." - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-pNext-01875", - "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes an instance of VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE:" - } - ], - "core": [ - { - "vuid": "VUID-VkMemoryAllocateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO" - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkMemoryAllocateFlagsInfo, or VkMemoryDedicatedAllocateInfo" - }, - { - "vuid": "VUID-VkMemoryAllocateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - } - ] - }, - "VkMemoryDedicatedAllocateInfo": { - "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01432", - "text": " At least one of image and buffer must be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01433", - "text": " If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01434", - "text": " If image is not VK_NULL_HANDLE, image must have been created without VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in VkImageCreateInfo::flags" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01435", - "text": " If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01436", - "text": " If buffer is not VK_NULL_HANDLE, buffer must have been created without VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in VkBufferCreateInfo::flags" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-parameter", - "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter", - "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-commonparent", - "text": " Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_win32)": [ - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01876", - "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory." - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01877", - "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory." - } - ], - "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_fd)": [ - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01878", - "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory." - }, - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01879", - "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory." - } - ], - "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01797", - "text": " If image is not VK_NULL_HANDLE, image must not have been created with VK_IMAGE_CREATE_DISJOINT_BIT set in VkImageCreateInfo::flags" - } - ] - }, - "VkDedicatedAllocationMemoryAllocateInfoNV": { - "(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649", - "text": " At least one of image and buffer must be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650", - "text": " If image is not VK_NULL_HANDLE, the image must have been created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651", - "text": " If buffer is not VK_NULL_HANDLE, the buffer must have been created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652", - "text": " If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653", - "text": " If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter", - "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter", - "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-commonparent", - "text": " Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_NV_dedicated_allocation)+(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)": [ - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654", - "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory." - }, - { - "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655", - "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory." - } - ] - }, - "VkExportMemoryAllocateInfo": { - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkExportMemoryAllocateInfo-handleTypes-00656", - "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." - }, - { - "vuid": "VUID-VkExportMemoryAllocateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO" - }, - { - "vuid": "VUID-VkExportMemoryAllocateInfo-handleTypes-parameter", - "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" - } - ] - }, - "VkExportMemoryWin32HandleInfoKHR": { - "(VK_KHR_external_memory_win32)": [ - { - "vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657", - "text": " If VkExportMemoryAllocateInfo::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, VkExportMemoryWin32HandleInfoKHR must not be in the pNext chain of VkMemoryAllocateInfo." - }, - { - "vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter", - "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" - } - ] - }, - "VkImportMemoryWin32HandleInfoKHR": { - "(VK_KHR_external_memory_win32)": [ - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658", - "text": " If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659", - "text": " The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660", - "text": " If handleType is not 0, it must be defined as an NT handle or a global share handle." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439", - "text": " If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, name must be NULL." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440", - "text": " If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661", - "text": " If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441", - "text": " if handle is not NULL, name must be NULL." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518", - "text": " If handle is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-name-01519", - "text": " If name is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter", - "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - } - ] - }, - "vkGetMemoryWin32HandleKHR": { - "(VK_KHR_external_memory_win32)": [ - { - "vuid": "VUID-vkGetMemoryWin32HandleKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter", - "text": " pGetWin32HandleInfo must be a valid pointer to a valid VkMemoryGetWin32HandleInfoKHR structure" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter", - "text": " pHandle must be a valid pointer to a HANDLE value" - } - ] - }, - "VkMemoryGetWin32HandleInfoKHR": { - "(VK_KHR_external_memory_win32)": [ - { - "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662", - "text": " handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created." - }, - { - "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663", - "text": " If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHR must be called no more than once for each valid unique combination of memory and handleType." - }, - { - "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664", - "text": " handleType must be defined as an NT handle or a global share handle." - }, - { - "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR" - }, - { - "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - } - ] - }, - "vkGetMemoryWin32HandlePropertiesKHR": { - "(VK_KHR_external_memory_win32)": [ - { - "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665", - "text": " handle must be an external memory handle created outside of the Vulkan API." - }, - { - "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666", - "text": " handleType must not be one of the handle types defined as opaque." - }, - { - "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter", - "text": " pMemoryWin32HandleProperties must be a valid pointer to a VkMemoryWin32HandlePropertiesKHR structure" - } - ] - }, - "VkImportMemoryFdInfoKHR": { - "(VK_KHR_external_memory_fd)": [ - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00667", - "text": " If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." - }, - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-00668", - "text": " The memory from which fd was exported must have been created on the same underlying physical device as device." - }, - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00669", - "text": " If handleType is not 0, it must be defined as a POSIX file descriptor handle." - }, - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00670", - "text": " If handleType is not 0, fd must be a valid handle of the type specified by handleType." - }, - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01746", - "text": " The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in &amp;lt;&amp;lt;external-memory-handle-types-compatibility&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01520", - "text": " fd must obey any requirements listed for handleType in &amp;lt;&amp;lt;external-memory-handle-types-compatibility,external memory handle types compatibility&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR" - }, - { - "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-parameter", - "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - } - ] - }, - "vkGetMemoryFdKHR": { - "(VK_KHR_external_memory_fd)": [ - { - "vuid": "VUID-vkGetMemoryFdKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter", - "text": " pGetFdInfo must be a valid pointer to a valid VkMemoryGetFdInfoKHR structure" - }, - { - "vuid": "VUID-vkGetMemoryFdKHR-pFd-parameter", - "text": " pFd must be a valid pointer to a int value" - } - ] - }, - "VkMemoryGetFdInfoKHR": { - "(VK_KHR_external_memory_fd)": [ - { - "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00671", - "text": " handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created." - }, - { - "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00672", - "text": " handleType must be defined as a POSIX file descriptor handle." - }, - { - "vuid": "VUID-VkMemoryGetFdInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR" - }, - { - "vuid": "VUID-VkMemoryGetFdInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkMemoryGetFdInfoKHR-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - } - ] - }, - "vkGetMemoryFdPropertiesKHR": { - "(VK_KHR_external_memory_fd)": [ - { - "vuid": "VUID-vkGetMemoryFdPropertiesKHR-fd-00673", - "text": " fd must be an external memory handle created outside of the Vulkan API." - }, - { - "vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-00674", - "text": " handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR." - }, - { - "vuid": "VUID-vkGetMemoryFdPropertiesKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter", - "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - }, - { - "vuid": "VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter", - "text": " pMemoryFdProperties must be a valid pointer to a VkMemoryFdPropertiesKHR structure" - } - ] - }, - "VkImportMemoryHostPointerInfoEXT": { - "(VK_EXT_external_memory_host)": [ - { - "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747", - "text": " If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryPropertiesKHR" - }, - { - "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748", - "text": " If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT" - }, - { - "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749", - "text": " pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" - }, - { - "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750", - "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to" - }, - { - "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751", - "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host mapped foreign memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to" - }, - { - "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT" - }, - { - "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter", - "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - } - ] - }, - "vkGetMemoryHostPointerPropertiesEXT": { - "(VK_EXT_external_memory_host)": [ - { - "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752", - "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT" - }, - { - "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753", - "text": " pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" - }, - { - "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754", - "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to host memory" - }, - { - "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755", - "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to host mapped foreign memory" - }, - { - "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter", - "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - }, - { - "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter", - "text": " pMemoryHostPointerProperties must be a valid pointer to a VkMemoryHostPointerPropertiesEXT structure" - } - ] - }, - "VkMemoryHostPointerPropertiesEXT": { - "(VK_EXT_external_memory_host)": [ - { - "vuid": "VUID-VkMemoryHostPointerPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT" - }, - { - "vuid": "VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "VkImportAndroidHardwareBufferInfoANDROID": { - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880", - "text": " If buffer is not NULL, Android hardware buffers must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties." - }, - { - "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881", - "text": " If buffer is not NULL, it must be a valid Android hardware buffer object with format and usage compatible with Vulkan as described by VkExternalMemoryHandleTypeFlagBits." - }, - { - "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID" - }, - { - "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-parameter", - "text": " buffer must be a valid pointer to a AHardwareBuffer value" - } - ] - }, - "vkGetMemoryAndroidHardwareBufferANDROID": { - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetMemoryAndroidHardwareBufferANDROID-pInfo-parameter", - "text": " pInfo must be a valid pointer to a valid VkMemoryGetAndroidHardwareBufferInfoANDROID structure" - }, - { - "vuid": "VUID-vkGetMemoryAndroidHardwareBufferANDROID-pBuffer-parameter", - "text": " pBuffer must be a valid pointer to a valid pointer to a AHardwareBuffer value" - } - ] - }, - "VkMemoryGetAndroidHardwareBufferInfoANDROID": { - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882", - "text": " VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created." - }, - { - "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883", - "text": " If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo with non-NULL image member, then that image must already be bound to memory." - } - ] - }, - "vkGetAndroidHardwareBufferPropertiesANDROID": { - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884", - "text": " buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags." - }, - { - "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-parameter", - "text": " buffer must be a valid pointer to a valid AHardwareBuffer value" - }, - { - "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-pProperties-parameter", - "text": " pProperties must be a valid pointer to a VkAndroidHardwareBufferPropertiesANDROID structure" - } - ] - }, - "VkAndroidHardwareBufferFormatPropertiesANDROID": { - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkAndroidHardwareBufferFormatPropertiesANDROID-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID" - } - ] - }, - "VkExportMemoryAllocateInfoNV": { - "(VK_NV_external_memory)": [ - { - "vuid": "VUID-VkExportMemoryAllocateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV" - }, - { - "vuid": "VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter", - "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" - } - ] - }, - "VkExportMemoryWin32HandleInfoNV": { - "(VK_NV_external_memory_win32)": [ - { - "vuid": "VUID-VkExportMemoryWin32HandleInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV" - }, - { - "vuid": "VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter", - "text": " If pAttributes is not NULL, pAttributes must be a valid pointer to a valid SECURITY_ATTRIBUTES value" - } - ] - }, - "VkImportMemoryWin32HandleInfoNV": { - "(VK_NV_external_memory_win32)": [ - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327", - "text": " handleType must not have more than one bit set." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handle-01328", - "text": " handle must be a valid handle to memory, obtained as specified by handleType." - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV" - }, - { - "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter", - "text": " handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" - } - ] - }, - "vkGetMemoryWin32HandleNV": { - "(VK_NV_external_memory_win32)": [ - { - "vuid": "VUID-vkGetMemoryWin32HandleNV-handleType-01326", - "text": " handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleNV-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleNV-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleNV-handleType-parameter", - "text": " handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask", - "text": " handleType must not be 0" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleNV-pHandle-parameter", - "text": " pHandle must be a valid pointer to a HANDLE value" - }, - { - "vuid": "VUID-vkGetMemoryWin32HandleNV-memory-parent", - "text": " memory must have been created, allocated, or retrieved from device" - } - ] - }, - "VkMemoryAllocateFlagsInfo": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675", - "text": " If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must be a valid device mask." - }, - { - "vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676", - "text": " If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must not be zero" - }, - { - "vuid": "VUID-VkMemoryAllocateFlagsInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO" - }, - { - "vuid": "VUID-VkMemoryAllocateFlagsInfo-flags-parameter", - "text": " flags must be a valid combination of VkMemoryAllocateFlagBits values" - } - ] - }, - "vkFreeMemory": { - "core": [ - { - "vuid": "VUID-vkFreeMemory-memory-00677", - "text": " All submitted commands that refer to memory (via images or buffers) must have completed execution" - }, - { - "vuid": "VUID-vkFreeMemory-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkFreeMemory-memory-parameter", - "text": " If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-vkFreeMemory-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkFreeMemory-memory-parent", - "text": " If memory is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkMapMemory": { - "core": [ - { - "vuid": "VUID-vkMapMemory-memory-00678", - "text": " memory must not be currently mapped" - }, - { - "vuid": "VUID-vkMapMemory-offset-00679", - "text": " offset must be less than the size of memory" - }, - { - "vuid": "VUID-vkMapMemory-size-00680", - "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" - }, - { - "vuid": "VUID-vkMapMemory-size-00681", - "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of the memory minus offset" - }, - { - "vuid": "VUID-vkMapMemory-memory-00682", - "text": " memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT" - }, - { - "vuid": "VUID-vkMapMemory-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkMapMemory-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-vkMapMemory-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-vkMapMemory-ppData-parameter", - "text": " ppData must be a valid pointer to a pointer value" - }, - { - "vuid": "VUID-vkMapMemory-memory-parent", - "text": " memory must have been created, allocated, or retrieved from device" - } - ], - "(VK_KHR_device_group)": [ - { - "vuid": "VUID-vkMapMemory-memory-00683", - "text": " memory must not have been allocated with multiple instances." - } - ] - }, - "vkFlushMappedMemoryRanges": { - "core": [ - { - "vuid": "VUID-vkFlushMappedMemoryRanges-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter", - "text": " pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures" - }, - { - "vuid": "VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength", - "text": " memoryRangeCount must be greater than 0" - } - ] - }, - "vkInvalidateMappedMemoryRanges": { - "core": [ - { - "vuid": "VUID-vkInvalidateMappedMemoryRanges-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter", - "text": " pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures" - }, - { - "vuid": "VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength", - "text": " memoryRangeCount must be greater than 0" - } - ] - }, - "VkMappedMemoryRange": { - "core": [ - { - "vuid": "VUID-VkMappedMemoryRange-memory-00684", - "text": " memory must be currently mapped" - }, - { - "vuid": "VUID-VkMappedMemoryRange-size-00685", - "text": " If size is not equal to VK_WHOLE_SIZE, offset and size must specify a range contained within the currently mapped range of memory" - }, - { - "vuid": "VUID-VkMappedMemoryRange-size-00686", - "text": " If size is equal to VK_WHOLE_SIZE, offset must be within the currently mapped range of memory" - }, - { - "vuid": "VUID-VkMappedMemoryRange-size-01389", - "text": " If size is equal to VK_WHOLE_SIZE, the end of the current mapping of memory must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize bytes from the beginning of the memory object." - }, - { - "vuid": "VUID-VkMappedMemoryRange-offset-00687", - "text": " offset must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize" - }, - { - "vuid": "VUID-VkMappedMemoryRange-size-01390", - "text": " If size is not equal to VK_WHOLE_SIZE, size must either be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, or offset plus size must equal the size of memory." - }, - { - "vuid": "VUID-VkMappedMemoryRange-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE" - }, - { - "vuid": "VUID-VkMappedMemoryRange-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkMappedMemoryRange-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - } - ] - }, - "vkUnmapMemory": { - "core": [ - { - "vuid": "VUID-vkUnmapMemory-memory-00689", - "text": " memory must be currently mapped" - }, - { - "vuid": "VUID-vkUnmapMemory-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkUnmapMemory-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-vkUnmapMemory-memory-parent", - "text": " memory must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetDeviceMemoryCommitment": { - "core": [ - { - "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-00690", - "text": " memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT" - }, - { - "vuid": "VUID-vkGetDeviceMemoryCommitment-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter", - "text": " pCommittedMemoryInBytes must be a valid pointer to a VkDeviceSize value" - }, - { - "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-parent", - "text": " memory must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetDeviceGroupPeerMemoryFeatures": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691", - "text": " heapIndex must be less than memoryHeapCount" - }, - { - "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692", - "text": " localDeviceIndex must be a valid device index" - }, - { - "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693", - "text": " remoteDeviceIndex must be a valid device index" - }, - { - "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694", - "text": " localDeviceIndex must not equal remoteDeviceIndex" - }, - { - "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter", - "text": " pPeerMemoryFeatures must be a valid pointer to a VkPeerMemoryFeatureFlags value" - } - ] - }, - "vkCreateBuffer": { - "core": [ - { - "vuid": "VUID-vkCreateBuffer-flags-00911", - "text": " If the flags member of pCreateInfo includes VK_BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" - }, - { - "vuid": "VUID-vkCreateBuffer-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateBuffer-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkBufferCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateBuffer-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateBuffer-pBuffer-parameter", - "text": " pBuffer must be a valid pointer to a VkBuffer handle" - } - ] - }, - "VkBufferCreateInfo": { - "core": [ - { - "vuid": "VUID-VkBufferCreateInfo-size-00912", - "text": " size must be greater than 0" - }, - { - "vuid": "VUID-VkBufferCreateInfo-sharingMode-00913", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" - }, - { - "vuid": "VUID-VkBufferCreateInfo-sharingMode-00914", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00915", - "text": " If the &amp;lt;&amp;lt;features-features-sparseBinding,sparse bindings&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00916", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyBuffer,sparse buffer residency&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00917", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyAliased,sparse aliased residency&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-00918", - "text": " If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO" - }, - { - "vuid": "VUID-VkBufferCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV or VkExternalMemoryBufferCreateInfo" - }, - { - "vuid": "VUID-VkBufferCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkBufferCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkBufferCreateFlagBits values" - }, - { - "vuid": "VUID-VkBufferCreateInfo-usage-parameter", - "text": " usage must be a valid combination of VkBufferUsageFlagBits values" - }, - { - "vuid": "VUID-VkBufferCreateInfo-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-VkBufferCreateInfo-sharingMode-parameter", - "text": " sharingMode must be a valid VkSharingMode value" - } - ], - "!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkBufferCreateInfo-sharingMode-01391", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" - } - ], - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkBufferCreateInfo-sharingMode-01419", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" - } - ], - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkBufferCreateInfo-pNext-00920", - "text": " If the pNext chain contains an instance of VkExternalMemoryBufferCreateInfo, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo\\-&amp;gt;handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkBufferCreateInfo-flags-01887", - "text": " If the protected memory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT" - }, - { - "vuid": "VUID-VkBufferCreateInfo-None-01888", - "text": " If any of the bits VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT are set, VK_BUFFER_CREATE_PROTECTED_BIT must not also be set" - } - ], - "(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-VkBufferCreateInfo-pNext-01571", - "text": " If the pNext chain contains an instance of VkDedicatedAllocationBufferCreateInfoNV, and the dedicatedAllocation member of the chained structure is VK_TRUE, then flags must not include VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" - } - ] - }, - "VkDedicatedAllocationBufferCreateInfoNV": { - "(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-VkDedicatedAllocationBufferCreateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV" - } - ] - }, - "VkExternalMemoryBufferCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkExternalMemoryBufferCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO" - }, - { - "vuid": "VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter", - "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" - } - ] - }, - "vkDestroyBuffer": { - "core": [ - { - "vuid": "VUID-vkDestroyBuffer-buffer-00922", - "text": " All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution" - }, - { - "vuid": "VUID-vkDestroyBuffer-buffer-00923", - "text": " If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyBuffer-buffer-00924", - "text": " If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyBuffer-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyBuffer-buffer-parameter", - "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkDestroyBuffer-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyBuffer-buffer-parent", - "text": " If buffer is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateBufferView": { - "core": [ - { - "vuid": "VUID-vkCreateBufferView-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateBufferView-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkBufferViewCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateBufferView-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateBufferView-pView-parameter", - "text": " pView must be a valid pointer to a VkBufferView handle" - } - ] - }, - "VkBufferViewCreateInfo": { - "core": [ - { - "vuid": "VUID-VkBufferViewCreateInfo-offset-00925", - "text": " offset must be less than the size of buffer" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-offset-00926", - "text": " offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-range-00928", - "text": " If range is not equal to VK_WHOLE_SIZE, range must be greater than 0" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-range-00929", - "text": " If range is not equal to VK_WHOLE_SIZE, range must be a multiple of the element size of format" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-range-00930", - "text": " If range is not equal to VK_WHOLE_SIZE, range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-offset-00931", - "text": " If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-buffer-00932", - "text": " buffer must have been created with a usage value containing at least one of VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-buffer-00933", - "text": " If buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format must be supported for uniform texel buffers, as specified by the VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-buffer-00934", - "text": " If buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format must be supported for storage texel buffers, as specified by the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-buffer-00935", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkBufferViewCreateInfo-format-parameter", - "text": " format must be a valid VkFormat value" - } - ] - }, - "vkDestroyBufferView": { - "core": [ - { - "vuid": "VUID-vkDestroyBufferView-bufferView-00936", - "text": " All submitted commands that refer to bufferView must have completed execution" - }, - { - "vuid": "VUID-vkDestroyBufferView-bufferView-00937", - "text": " If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyBufferView-bufferView-00938", - "text": " If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyBufferView-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyBufferView-bufferView-parameter", - "text": " If bufferView is not VK_NULL_HANDLE, bufferView must be a valid VkBufferView handle" - }, - { - "vuid": "VUID-vkDestroyBufferView-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyBufferView-bufferView-parent", - "text": " If bufferView is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateImage": { - "core": [ - { - "vuid": "VUID-vkCreateImage-flags-00939", - "text": " If the flags member of pCreateInfo includes VK_IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" - }, - { - "vuid": "VUID-vkCreateImage-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateImage-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkImageCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateImage-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateImage-pImage-parameter", - "text": " pImage must be a valid pointer to a VkImage handle" - } - ] - }, - "VkImageCreateInfo": { - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkImageCreateInfo-format-00940", - "text": " The combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters." - }, - { - "vuid": "VUID-VkImageCreateInfo-format-00943", - "text": " format must not be VK_FORMAT_UNDEFINED" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkImageCreateInfo-pNext-01889", - "text": " If the pNext chain does not contain an instance of VkExternalFormatANDROID, or if format is not VK_FORMAT_UNDEFINED, the combination of format, imageType, tiling, usage, and flags must be supported, as indicated by a VK_SUCCESS return value from vkGetPhysicalDeviceImageFormatProperties invoked with the same values passed to the corresponding parameters." - }, - { - "vuid": "VUID-VkImageCreateInfo-pNext-01974", - "text": " If the pNext chain contains an instance of VkExternalFormatANDROID, and its member externalFormat is non-zero the format must be VK_FORMAT_UNDEFINED." - }, - { - "vuid": "VUID-VkImageCreateInfo-pNext-01975", - "text": " If the pNext chain does not contain an instance of VkExternalFormatANDROID, or does and its member externalFormat is 0 the format must not be VK_FORMAT_UNDEFINED." - }, - { - "vuid": "VUID-VkImageCreateInfo-pNext-01892", - "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:" - }, - { - "vuid": "VUID-VkImageCreateInfo-pNext-01893", - "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0:" - } - ], - "core": [ - { - "vuid": "VUID-VkImageCreateInfo-sharingMode-00941", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" - }, - { - "vuid": "VUID-VkImageCreateInfo-sharingMode-00942", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" - }, - { - "vuid": "VUID-VkImageCreateInfo-extent-00944", - "text": " extent::width must be greater than 0." - }, - { - "vuid": "VUID-VkImageCreateInfo-extent-00945", - "text": " extent::height must be greater than 0." - }, - { - "vuid": "VUID-VkImageCreateInfo-extent-00946", - "text": " extent::depth must be greater than 0." - }, - { - "vuid": "VUID-VkImageCreateInfo-mipLevels-00947", - "text": " mipLevels must be greater than 0" - }, - { - "vuid": "VUID-VkImageCreateInfo-arrayLayers-00948", - "text": " arrayLayers must be greater than 0" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-00949", - "text": " If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_2D" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00951", - "text": " If imageType is VK_IMAGE_TYPE_1D, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension1D, or VkImageFormatProperties::maxExtent.width (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00952", - "text": " If imageType is VK_IMAGE_TYPE_2D and flags does not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension2D, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00953", - "text": " If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be less than or equal to VkPhysicalDeviceLimits::maxImageDimensionCube, or VkImageFormatProperties::maxExtent.width/height (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00954", - "text": " If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be equal and arrayLayers must be greater than or equal to 6" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00955", - "text": " If imageType is VK_IMAGE_TYPE_3D, extent.width, extent.height and extent.depth must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension3D, or VkImageFormatProperties::maxExtent.width/height/depth (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure) - whichever is higher" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00956", - "text": " If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00957", - "text": " If imageType is VK_IMAGE_TYPE_2D, extent.depth must be 1" - }, - { - "vuid": "VUID-VkImageCreateInfo-mipLevels-00958", - "text": " mipLevels must be less than or equal to {lfloor}log2(max(extent.width, extent.height, extent.depth)){rfloor} + 1." - }, - { - "vuid": "VUID-VkImageCreateInfo-extent-00959", - "text": " mipLevels must be less than or equal to VkImageFormatProperties::maxMipLevels (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)" - }, - { - "vuid": "VUID-VkImageCreateInfo-arrayLayers-00960", - "text": " arrayLayers must be less than or equal to VkImageFormatProperties::maxArrayLayers (as returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure)" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00961", - "text": " If imageType is VK_IMAGE_TYPE_3D, arrayLayers must be 1." - }, - { - "vuid": "VUID-VkImageCreateInfo-samples-00962", - "text": " If samples is not VK_SAMPLE_COUNT_1_BIT, imageType must be VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, tiling must be VK_IMAGE_TILING_OPTIMAL, and mipLevels must be equal to 1" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-00963", - "text": " If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, then bits other than VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT must not be set" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-00964", - "text": " If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-00965", - "text": " If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-00966", - "text": " If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, usage must also contain at least one of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT." - }, - { - "vuid": "VUID-VkImageCreateInfo-samples-00967", - "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, imageType, tiling, usage, and flags equal to those in this structure" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-00968", - "text": " If the &amp;lt;&amp;lt;features-features-shaderStorageImageMultisample,multisampled storage images&amp;gt;&amp;gt; feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-00969", - "text": " If the &amp;lt;&amp;lt;features-features-sparseBinding,sparse bindings&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-01924", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyAliased,sparse aliased residency&amp;gt;&amp;gt; feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00970", - "text": " If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00971", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyImage2D,sparse residency for 2D images&amp;gt;&amp;gt; feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00972", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyImage3D,sparse residency for 3D images&amp;gt;&amp;gt; feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00973", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency2Samples,sparse residency for images with 2 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00974", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency4Samples,sparse residency for images with 4 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00975", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency8Samples,sparse residency for images with 8 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-00976", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidency16Samples,sparse residency for images with 16 samples&amp;gt;&amp;gt; feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-00987", - "text": " If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-None-01925", - "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set" - }, - { - "vuid": "VUID-VkImageCreateInfo-initialLayout-00993", - "text": " initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED." - }, - { - "vuid": "VUID-VkImageCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO" - }, - { - "vuid": "VUID-VkImageCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageFormatListCreateInfoKHR, or VkImageSwapchainCreateInfoKHR" - }, - { - "vuid": "VUID-VkImageCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkImageCreateFlagBits values" - }, - { - "vuid": "VUID-VkImageCreateInfo-imageType-parameter", - "text": " imageType must be a valid VkImageType value" - }, - { - "vuid": "VUID-VkImageCreateInfo-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-VkImageCreateInfo-samples-parameter", - "text": " samples must be a valid VkSampleCountFlagBits value" - }, - { - "vuid": "VUID-VkImageCreateInfo-tiling-parameter", - "text": " tiling must be a valid VkImageTiling value" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-parameter", - "text": " usage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-VkImageCreateInfo-sharingMode-parameter", - "text": " sharingMode must be a valid VkSharingMode value" - }, - { - "vuid": "VUID-VkImageCreateInfo-initialLayout-parameter", - "text": " initialLayout must be a valid VkImageLayout value" - } - ], - "!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkImageCreateInfo-sharingMode-01392", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" - } - ], - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkImageCreateInfo-sharingMode-01420", - "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkImageCreateInfo-flags-00950", - "text": " If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_3D" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkImageCreateInfo-flags-01890", - "text": " If the protected memory feature is not enabled, flags must not contain VK_IMAGE_CREATE_PROTECTED_BIT." - }, - { - "vuid": "VUID-VkImageCreateInfo-None-01891", - "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_CREATE_PROTECTED_BIT must not also be set." - } - ], - "(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_NV_external_memory)": [ - { - "vuid": "VUID-VkImageCreateInfo-pNext-00988", - "text": " If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfo." - } - ], - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkImageCreateInfo-pNext-00990", - "text": " If the pNext chain contains an instance of VkExternalMemoryImageCreateInfo, its handleTypes member must only contain bits that are also in VkExternalImageFormatProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2 with format, imageType, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfo in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfo::handleTypes" - } - ], - "(VK_NV_external_memory+VK_NV_external_memory_capabilities)": [ - { - "vuid": "VUID-VkImageCreateInfo-pNext-00991", - "text": " If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, imageType, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes" - } - ], - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkImageCreateInfo-physicalDeviceCount-01421", - "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-00992", - "text": " If flags contains VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkImageCreateInfo-flags-01572", - "text": " If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then format must be a &amp;lt;&amp;lt;appendix-compressedtex-bc,block-compressed image format&amp;gt;&amp;gt;, an &amp;lt;&amp;lt;appendix-compressedtex-etc2, ETC compressed image format&amp;gt;&amp;gt;, or an &amp;lt;&amp;lt;appendix-compressedtex-astc, ASTC compressed image format&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkImageCreateInfo-flags-01573", - "text": " If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT." - } - ], - "(VK_VERSION_1_1,VK_KHR_external_memory,VK_NV_external_memory)": [ - { - "vuid": "VUID-VkImageCreateInfo-pNext-01443", - "text": " If the pNext chain includes a ifdef::VK_VERSION_1_1,VK_KHR_external_memory[VkExternalMemoryImageCreateInfo]" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageCreateInfo-format-01574", - "text": " If the image format is one of those listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;:" - }, - { - "vuid": "VUID-VkImageCreateInfo-tiling-01575", - "text": " If tiling is VK_IMAGE_TILING_OPTIMAL, format is a multi-planar format, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-tiling-01576", - "text": " If tiling is VK_IMAGE_TILING_LINEAR, format is a multi-planar format, and VkFormatProperties::linearTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DISJOINT_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" - }, - { - "vuid": "VUID-VkImageCreateInfo-format-01577", - "text": " If format is not a multi-planar format, and flags does not include VK_IMAGE_CREATE_ALIAS_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" - } - ], - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkImageCreateInfo-flags-01533", - "text": " If flags contains VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT format must be a depth or depth/stencil format" - } - ] - }, - "VkDedicatedAllocationImageCreateInfoNV": { - "(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994", - "text": " If dedicatedAllocation is VK_TRUE, VkImageCreateInfo::flags must not include VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" - }, - { - "vuid": "VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV" - } - ] - }, - "VkExternalMemoryImageCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_external_memory)": [ - { - "vuid": "VUID-VkExternalMemoryImageCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO" - }, - { - "vuid": "VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter", - "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" - }, - { - "vuid": "VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask", - "text": " handleTypes must not be 0" - } - ] - }, - "VkExternalMemoryImageCreateInfoNV": { - "(VK_NV_external_memory)": [ - { - "vuid": "VUID-VkExternalMemoryImageCreateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV" - }, - { - "vuid": "VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter", - "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" - } - ] - }, - "VkExternalFormatANDROID": { - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkExternalFormatANDROID-externalFormat-01894", - "text": " externalFormat must be 0 or a value returned in the externalFormat member of VkAndroidHardwareBufferFormatPropertiesANDROID by an earlier call to vkGetAndroidHardwareBufferPropertiesANDROID" - }, - { - "vuid": "VUID-VkExternalFormatANDROID-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID" - } - ] - }, - "VkImageSwapchainCreateInfoKHR": { - "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995", - "text": " If swapchain is not VK_NULL_HANDLE, the fields of VkImageCreateInfo must match the &amp;lt;&amp;lt;swapchain-wsi-image-create-info, implied image creation parameters&amp;gt;&amp;gt; of the swapchain" - }, - { - "vuid": "VUID-VkImageSwapchainCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter", - "text": " If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle" - } - ] - }, - "VkImageFormatListCreateInfoKHR": { - "(VK_KHR_image_format_list)": [ - { - "vuid": "VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01578", - "text": " If viewFormatCount is not 0, all of the formats in the pViewFormats array must be compatible with the format specified in the format field of VkImageCreateInfo, as described in the compatibility table." - }, - { - "vuid": "VUID-VkImageFormatListCreateInfoKHR-flags-01579", - "text": " If VkImageCreateInfo::flags does not contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, viewFormatCount must be 0 or 1." - }, - { - "vuid": "VUID-VkImageFormatListCreateInfoKHR-viewFormatCount-01580", - "text": " If viewFormatCount is not 0, VkImageCreateInfo::format must be in pViewFormats." - }, - { - "vuid": "VUID-VkImageFormatListCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkImageFormatListCreateInfoKHR-pViewFormats-parameter", - "text": " If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values" - } - ] - }, - "vkGetImageSubresourceLayout": { - "core": [ - { - "vuid": "VUID-vkGetImageSubresourceLayout-image-00996", - "text": " image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-aspectMask-00997", - "text": " The aspectMask member of pSubresource must only have a single bit set" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-mipLevel-01716", - "text": " The mipLevel member of pSubresource must be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-arrayLayer-01717", - "text": " The arrayLayer member of pSubresource must be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-pSubresource-parameter", - "text": " pSubresource must be a valid pointer to a valid VkImageSubresource structure" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-pLayout-parameter", - "text": " pLayout must be a valid pointer to a VkSubresourceLayout structure" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-image-parent", - "text": " image must have been created, allocated, or retrieved from device" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkGetImageSubresourceLayout-format-01581", - "text": " If the format of image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt; with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-format-01582", - "text": " If the format of image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt; with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkGetImageSubresourceLayout-image-01895", - "text": " If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory." - } - ] - }, - "VkImageSubresource": { - "core": [ - { - "vuid": "VUID-VkImageSubresource-aspectMask-parameter", - "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" - }, - { - "vuid": "VUID-VkImageSubresource-aspectMask-requiredbitmask", - "text": " aspectMask must not be 0" - } - ] - }, - "vkDestroyImage": { - "core": [ - { - "vuid": "VUID-vkDestroyImage-image-01000", - "text": " All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution" - }, - { - "vuid": "VUID-vkDestroyImage-image-01001", - "text": " If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyImage-image-01002", - "text": " If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyImage-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyImage-image-parameter", - "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkDestroyImage-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyImage-image-parent", - "text": " If image is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateImageView": { - "core": [ - { - "vuid": "VUID-vkCreateImageView-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateImageView-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkImageViewCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateImageView-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateImageView-pView-parameter", - "text": " pView must be a valid pointer to a VkImageView handle" - } - ] - }, - "VkImageViewCreateInfo": { - "core": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01003", - "text": " If image was not created with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then viewType must not be VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-viewType-01004", - "text": " If the &amp;lt;&amp;lt;features-features-imageCubeArray,image cubemap arrays&amp;gt;&amp;gt; feature is not enabled, viewType must not be VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01006", - "text": " If image was created with VK_IMAGE_TILING_LINEAR, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01007", - "text": " image must have been created with a usage value containing at least one of VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01008", - "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01009", - "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01010", - "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01011", - "text": " If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01478", - "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01718", - "text": " If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01018", - "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01020", - "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-subResourceRange-01021", - "text": " subresourceRange and viewType must be compatible with the image, as described in the &amp;lt;&amp;lt;resources-image-views-compatibility,compatibility table&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageViewUsageCreateInfo or VkSamplerYcbcrConversionInfo" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-viewType-parameter", - "text": " viewType must be a valid VkImageViewType value" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-components-parameter", - "text": " components must be a valid VkComponentMapping structure" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-parameter", - "text": " subresourceRange must be a valid VkImageSubresourceRange structure" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01005", - "text": " If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01482", - "text": " If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01483", - "text": " If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01484", - "text": " If image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::baseArrayLayer must be less than the extent.depth specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01485", - "text": " If subresourceRange::layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange::layerCount must be non-zero and subresourceRange::baseArrayLayer + subresourceRange::layerCount must be less than or equal to the extent.depth specified in VkImageCreateInfo when image was created" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01012", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01013", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01014", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01015", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01016", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01965", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL and format is not VK_FORMAT_UNDEFINED, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01966", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01967", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01968", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01969", - "text": " If image was created with VK_IMAGE_TILING_OPTIMAL, and format is not VK_FORMAT_UNDEFINED, and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01896", - "text": " If image has an &amp;lt;&amp;lt;memory-external-android-hardware-buffer-external-formats,external format&amp;gt;&amp;gt;:" - } - ], - "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01480", - "text": " subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01719", - "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01759", - "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" - } - ], - "!(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01760", - "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, and if the format of the image is not a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01761", - "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, and if the format of the image is not a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format, format must be compatible with the format used to create image, as defined in &amp;lt;&amp;lt;features-formats-compatibility-classes,Format Compatibility Classes&amp;gt;&amp;gt;" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01583", - "text": " If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with, or must be an uncompressed format that is size-compatible with, the format used to create image." - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01584", - "text": " If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, the levelCount and layerCount members of subresourceRange must both be 1." - } - ], - "(VK_KHR_image_format_list)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-pNext-01585", - "text": " If a VkImageFormatListCreateInfoKHR structure was included in the pNext chain of the VkImageCreateInfo struct used when creating image and the viewFormatCount field of VkImageFormatListCreateInfoKHR is not zero then format must be one of the formats in VkImageFormatListCreateInfoKHR::pViewFormats." - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01586", - "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format, and if subresourceRange.aspectMask is one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in &amp;lt;&amp;lt;features-formats-compatible-planes&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-image-01762", - "text": " If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, or if the format of the image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar&amp;gt;&amp;gt; format and if subresourceRange.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, format must be identical to the format used to create image" - }, - { - "vuid": "VUID-VkImageViewCreateInfo-pNext-01970", - "text": " If the pNext chain contains an instance of VkSamplerYcbcrConversionInfo with a conversion value other than VK_NULL_HANDLE, all members of components must have the value VK_COMPONENT_SWIZZLE_IDENTITY." - } - ], - "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageViewCreateInfo-image-01019", - "text": " If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be identical to the format used to create image" - } - ] - }, - "VkImageViewUsageCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkImageViewUsageCreateInfo-usage-01587", - "text": " usage must not include any set bits that were not set in the usage member of the VkImageCreateInfo structure used to create the image this image view is created from." - }, - { - "vuid": "VUID-VkImageViewUsageCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO" - }, - { - "vuid": "VUID-VkImageViewUsageCreateInfo-usage-parameter", - "text": " usage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask", - "text": " usage must not be 0" - } - ] - }, - "VkImageSubresourceRange": { - "core": [ - { - "vuid": "VUID-VkImageSubresourceRange-levelCount-01720", - "text": " If levelCount is not VK_REMAINING_MIP_LEVELS, it must be greater than 0" - }, - { - "vuid": "VUID-VkImageSubresourceRange-layerCount-01721", - "text": " If layerCount is not VK_REMAINING_ARRAY_LAYERS, it must be greater than 0" - }, - { - "vuid": "VUID-VkImageSubresourceRange-aspectMask-parameter", - "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" - }, - { - "vuid": "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask", - "text": " aspectMask must not be 0" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageSubresourceRange-aspectMask-01670", - "text": " If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, then it must not include any of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" - } - ] - }, - "VkComponentMapping": { - "core": [ - { - "vuid": "VUID-VkComponentMapping-r-parameter", - "text": " r must be a valid VkComponentSwizzle value" - }, - { - "vuid": "VUID-VkComponentMapping-g-parameter", - "text": " g must be a valid VkComponentSwizzle value" - }, - { - "vuid": "VUID-VkComponentMapping-b-parameter", - "text": " b must be a valid VkComponentSwizzle value" - }, - { - "vuid": "VUID-VkComponentMapping-a-parameter", - "text": " a must be a valid VkComponentSwizzle value" - } - ] - }, - "vkDestroyImageView": { - "core": [ - { - "vuid": "VUID-vkDestroyImageView-imageView-01026", - "text": " All submitted commands that refer to imageView must have completed execution" - }, - { - "vuid": "VUID-vkDestroyImageView-imageView-01027", - "text": " If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyImageView-imageView-01028", - "text": " If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyImageView-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyImageView-imageView-parameter", - "text": " If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle" - }, - { - "vuid": "VUID-vkDestroyImageView-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyImageView-imageView-parent", - "text": " If imageView is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetBufferMemoryRequirements": { - "core": [ - { - "vuid": "VUID-vkGetBufferMemoryRequirements-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetBufferMemoryRequirements-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter", - "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure" - }, - { - "vuid": "VUID-vkGetBufferMemoryRequirements-buffer-parent", - "text": " buffer must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetImageMemoryRequirements": { - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkGetImageMemoryRequirements-image-01588", - "text": " image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set" - } - ], - "core": [ - { - "vuid": "VUID-vkGetImageMemoryRequirements-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetImageMemoryRequirements-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter", - "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure" - }, - { - "vuid": "VUID-vkGetImageMemoryRequirements-image-parent", - "text": " image must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetBufferMemoryRequirements2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-vkGetBufferMemoryRequirements2-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetBufferMemoryRequirements2-pInfo-parameter", - "text": " pInfo must be a valid pointer to a valid VkBufferMemoryRequirementsInfo2 structure" - }, - { - "vuid": "VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter", - "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure" - } - ] - }, - "VkBufferMemoryRequirementsInfo2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-VkBufferMemoryRequirementsInfo2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2" - }, - { - "vuid": "VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - } - ] - }, - "vkGetImageMemoryRequirements2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-vkGetImageMemoryRequirements2-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetImageMemoryRequirements2-pInfo-parameter", - "text": " pInfo must be a valid pointer to a valid VkImageMemoryRequirementsInfo2 structure" - }, - { - "vuid": "VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter", - "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure" - } - ] - }, - "VkImageMemoryRequirementsInfo2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01589", - "text": " If image was created with a multi-planar format and the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" - }, - { - "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01590", - "text": " If image was not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" - }, - { - "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01591", - "text": " If image was created with a single-plane format, there must not be a VkImagePlaneMemoryRequirementsInfo in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" - } - ], - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01897", - "text": " If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory." - } - ], - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-VkImageMemoryRequirementsInfo2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2" - }, - { - "vuid": "VUID-VkImageMemoryRequirementsInfo2-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkImagePlaneMemoryRequirementsInfo" - }, - { - "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-parameter", - "text": " image must be a valid VkImage handle" - } - ] - }, - "VkImagePlaneMemoryRequirementsInfo": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-01592", - "text": " planeAspect must be an aspect that exists in the format; that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT" - }, - { - "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO" - }, - { - "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter", - "text": " planeAspect must be a valid VkImageAspectFlagBits value" - } - ] - }, - "VkMemoryRequirements2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-VkMemoryRequirements2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2" - }, - { - "vuid": "VUID-VkMemoryRequirements2-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkMemoryDedicatedRequirements" - } - ] - }, - "VkMemoryDedicatedRequirements": { - "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-VkMemoryDedicatedRequirements-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS" - } - ] - }, - "vkBindBufferMemory": { - "core": [ - { - "vuid": "VUID-vkBindBufferMemory-buffer-01029", - "text": " buffer must not already be backed by a memory object" - }, - { - "vuid": "VUID-vkBindBufferMemory-buffer-01030", - "text": " buffer must not have been created with any sparse memory binding flags" - }, - { - "vuid": "VUID-vkBindBufferMemory-memoryOffset-01031", - "text": " memoryOffset must be less than the size of memory" - }, - { - "vuid": "VUID-vkBindBufferMemory-memory-01035", - "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" - }, - { - "vuid": "VUID-vkBindBufferMemory-memoryOffset-01036", - "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" - }, - { - "vuid": "VUID-vkBindBufferMemory-size-01037", - "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset" - }, - { - "vuid": "VUID-vkBindBufferMemory-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkBindBufferMemory-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkBindBufferMemory-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-vkBindBufferMemory-buffer-parent", - "text": " buffer must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkBindBufferMemory-memory-parent", - "text": " memory must have been created, allocated, or retrieved from device" - } - ], - "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-vkBindBufferMemory-buffer-01444", - "text": " If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer" - }, - { - "vuid": "VUID-vkBindBufferMemory-memory-01508", - "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero." - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkBindBufferMemory-None-01898", - "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" - }, - { - "vuid": "VUID-vkBindBufferMemory-None-01899", - "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" - } - ], - "(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-vkBindBufferMemory-buffer-01038", - "text": " If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero" - } - ], - "(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-vkBindBufferMemory-buffer-01039", - "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" - } - ] - }, - "vkBindBufferMemory2": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ - { - "vuid": "VUID-vkBindBufferMemory2-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkBindBufferMemory2-pBindInfos-parameter", - "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindBufferMemoryInfo structures" - }, - { - "vuid": "VUID-vkBindBufferMemory2-bindInfoCount-arraylength", - "text": " bindInfoCount must be greater than 0" - } - ] - }, - "VkBindBufferMemoryInfo": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ - { - "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01593", - "text": " buffer must not already be backed by a memory object" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01594", - "text": " buffer must not have been created with any sparse memory binding flags" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-memoryOffset-01595", - "text": " memoryOffset must be less than the size of memory" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-memory-01599", - "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-memoryOffset-01600", - "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-size-01601", - "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-commonparent", - "text": " Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01602", - "text": " If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer and memoryOffset must be zero" - }, - { - "vuid": "VUID-VkBindBufferMemoryInfo-memory-01900", - "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer and memoryOffset must be zero." - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01603", - "text": " If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to buffer and memoryOffset must be zero" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01604", - "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkBindBufferMemoryInfo-pNext-01605", - "text": " If the pNext chain includes VkBindBufferMemoryDeviceGroupInfo, all instances of memory specified by VkBindBufferMemoryDeviceGroupInfo::pDeviceIndices must have been allocated" - } - ] - }, - "VkBindBufferMemoryDeviceGroupInfo": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606", - "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" - }, - { - "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607", - "text": " All elements of pDeviceIndices must be valid device indices" - }, - { - "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO" - }, - { - "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter", - "text": " If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values" - } - ] - }, - "vkBindImageMemory": { - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkBindImageMemory-image-01608", - "text": " image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT set." - } - ], - "core": [ - { - "vuid": "VUID-vkBindImageMemory-image-01044", - "text": " image must not already be backed by a memory object" - }, - { - "vuid": "VUID-vkBindImageMemory-image-01045", - "text": " image must not have been created with any sparse memory binding flags" - }, - { - "vuid": "VUID-vkBindImageMemory-memoryOffset-01046", - "text": " memoryOffset must be less than the size of memory" - }, - { - "vuid": "VUID-vkBindImageMemory-memory-01047", - "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" - }, - { - "vuid": "VUID-vkBindImageMemory-memoryOffset-01048", - "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" - }, - { - "vuid": "VUID-vkBindImageMemory-size-01049", - "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image must be less than or equal to the size of memory minus memoryOffset" - }, - { - "vuid": "VUID-vkBindImageMemory-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkBindImageMemory-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkBindImageMemory-memory-parameter", - "text": " memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-vkBindImageMemory-image-parent", - "text": " image must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkBindImageMemory-memory-parent", - "text": " memory must have been created, allocated, or retrieved from device" - } - ], - "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-vkBindImageMemory-image-01445", - "text": " If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image" - }, - { - "vuid": "VUID-vkBindImageMemory-memory-01509", - "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero." - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkBindImageMemory-None-01901", - "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" - }, - { - "vuid": "VUID-vkBindImageMemory-None-01902", - "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" - } - ], - "(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-vkBindImageMemory-image-01050", - "text": " If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero" - } - ], - "(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-vkBindImageMemory-image-01051", - "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" - } - ] - }, - "vkBindImageMemory2": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ - { - "vuid": "VUID-vkBindImageMemory2-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkBindImageMemory2-pBindInfos-parameter", - "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindImageMemoryInfo structures" - }, - { - "vuid": "VUID-vkBindImageMemory2-bindInfoCount-arraylength", - "text": " bindInfoCount must be greater than 0" - } - ] - }, - "VkBindImageMemoryInfo": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-image-01609", - "text": " image must not already be backed by a memory object" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-image-01610", - "text": " image must not have been created with any sparse memory binding flags" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-memoryOffset-01611", - "text": " memoryOffset must be less than the size of memory" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, or VkBindImagePlaneMemoryInfo" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-commonparent", - "text": " Both of image, and memory that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-memory-01612", - "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-memoryOffset-01613", - "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-memory-01614", - "text": " The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01615", - "text": " If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01616", - "text": " If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01617", - "text": " If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01618", - "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, image must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set." - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01619", - "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2’s pNext chain" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01620", - "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2’s pNext chain" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01621", - "text": " If the pNext chain includes an instance of the VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image and the correct planeAspect for this plane in the VkImagePlaneMemoryRequirementsInfo structure attached to the VkImageMemoryRequirementsInfo2’s pNext chain" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-image-01622", - "text": " If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image and memoryOffset must be zero" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-memory-01903", - "text": " If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero." - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-image-01623", - "text": " If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to image and memoryOffset must be zero" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-image-01624", - "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1+VK_KHR_swapchain)+!(VK_KHR_device_group+VK_KHR_swapchain)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-memory-01625", - "text": " memory must be a valid VkDeviceMemory handle" - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01626", - "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all instances of memory specified by VkBindImageMemoryDeviceGroupInfo::pDeviceIndices must have been allocated" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01627", - "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, and VkBindImageMemoryDeviceGroupInfo::splitInstanceBindRegionCount is not zero, then image must have been created with the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit set" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01628", - "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions must be valid rectangles contained within the dimensions of image" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01629", - "text": " If the pNext chain includes VkBindImageMemoryDeviceGroupInfo, the union of the areas of all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions that correspond to the same instance of image must cover the entire image." - } - ], - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-VkBindImageMemoryInfo-image-01630", - "text": " If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01631", - "text": " If the pNext chain includes an instance of VkBindImageMemorySwapchainInfoKHR, memory must be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkBindImageMemoryInfo-pNext-01632", - "text": " If the pNext chain does not include an instance of VkBindImageMemorySwapchainInfoKHR, memory must be a valid VkDeviceMemory handle" - } - ] - }, - "VkBindImageMemoryDeviceGroupInfo": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633", - "text": " At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero." - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634", - "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635", - "text": " All elements of pDeviceIndices must be valid device indices." - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636", - "text": " splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637", - "text": " Elements of pSplitInstanceBindRegions that correspond to the same instance of an image must not overlap." - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638", - "text": " The offset.x member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of all non-metadata aspects of the image" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639", - "text": " The offset.y member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of all non-metadata aspects of the image" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640", - "text": " The extent.width member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block width of all non-metadata aspects of the image, or else extent.width + offset.x must equal the width of the image subresource" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641", - "text": " The extent.height member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block height of all non-metadata aspects of the image, or else extent.height
offset.y must equal the width of the image subresource" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter", - "text": " If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values" - }, - { - "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter", - "text": " If splitInstanceBindRegionCount is not 0, pSplitInstanceBindRegions must be a valid pointer to an array of splitInstanceBindRegionCount VkRect2D structures" - } - ] - }, - "VkBindImageMemorySwapchainInfoKHR": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644", - "text": " imageIndex must be less than the number of images in swapchain" - }, - { - "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR" - }, - { - "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - } - ] - }, - "VkBindImagePlaneMemoryInfo": { - "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-01642", - "text": " planeAspect must be a single valid plane aspect for the image format (that is, planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT for “_2PLANE” formats and planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT for “_3PLANE” formats)" - }, - { - "vuid": "VUID-VkBindImagePlaneMemoryInfo-None-01643", - "text": " A single call to vkBindImageMemory2 must bind all or none of the planes of an image (i.e. bindings to all planes of an image must be made in a single vkBindImageMemory2 call), as separate bindings" - }, - { - "vuid": "VUID-VkBindImagePlaneMemoryInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO" - }, - { - "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter", - "text": " planeAspect must be a valid VkImageAspectFlagBits value" - } - ] - }, - "vkCreateSampler": { - "core": [ - { - "vuid": "VUID-vkCreateSampler-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateSampler-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkSamplerCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateSampler-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateSampler-pSampler-parameter", - "text": " pSampler must be a valid pointer to a VkSampler handle" - } - ] - }, - "VkSamplerCreateInfo": { - "core": [ - { - "vuid": "VUID-VkSamplerCreateInfo-mipLodBias-01069", - "text": " The absolute value of mipLodBias must be less than or equal to VkPhysicalDeviceLimits::maxSamplerLodBias" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-maxLod-01973", - "text": " maxLod must be greater than or equal to minLod" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01070", - "text": " If the &amp;lt;&amp;lt;features-features-samplerAnisotropy,anisotropic sampling&amp;gt;&amp;gt; feature is not enabled, anisotropyEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01071", - "text": " If anisotropyEnable is VK_TRUE, maxAnisotropy must be between 1.0 and VkPhysicalDeviceLimits::maxSamplerAnisotropy, inclusive" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072", - "text": " If unnormalizedCoordinates is VK_TRUE, minFilter and magFilter must be equal" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073", - "text": " If unnormalizedCoordinates is VK_TRUE, mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074", - "text": " If unnormalizedCoordinates is VK_TRUE, minLod and maxLod must be zero" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075", - "text": " If unnormalizedCoordinates is VK_TRUE, addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076", - "text": " If unnormalizedCoordinates is VK_TRUE, anisotropyEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077", - "text": " If unnormalizedCoordinates is VK_TRUE, compareEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01078", - "text": " If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a valid VkBorderColor value" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079", - "text": " If the VK_KHR_sampler_mirror_clamp_to_edge extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01080", - "text": " If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSamplerReductionModeCreateInfoEXT or VkSamplerYcbcrConversionInfo" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-magFilter-parameter", - "text": " magFilter must be a valid VkFilter value" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-minFilter-parameter", - "text": " minFilter must be a valid VkFilter value" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-mipmapMode-parameter", - "text": " mipmapMode must be a valid VkSamplerMipmapMode value" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-addressModeU-parameter", - "text": " addressModeU must be a valid VkSamplerAddressMode value" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-addressModeV-parameter", - "text": " addressModeV must be a valid VkSamplerAddressMode value" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-addressModeW-parameter", - "text": " addressModeW must be a valid VkSamplerAddressMode value" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkSamplerCreateInfo-minFilter-01645", - "text": " If &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; is enabled and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT is not set for the format, minFilter and magFilter must be equal to the sampler Y’CBCR conversion’s chromaFilter" - }, - { - "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01646", - "text": " If &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; is enabled, addressModeU, addressModeV, and addressModeW must be VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE, and unnormalizedCoordinates must be VK_FALSE" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_sampler_filter_minmax)": [ - { - "vuid": "VUID-VkSamplerCreateInfo-None-01647", - "text": " The sampler reduction mode must be set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT if &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; is enabled" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-VkSamplerCreateInfo-magFilter-01081", - "text": " If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, anisotropyEnable must be VK_FALSE" - } - ], - "(VK_IMG_filter_cubic+VK_EXT_sampler_filter_minmax)": [ - { - "vuid": "VUID-VkSamplerCreateInfo-magFilter-01422", - "text": " If either magFilter or minFilter is VK_FILTER_CUBIC_IMG, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT" - } - ], - "(VK_EXT_sampler_filter_minmax)": [ - { - "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01423", - "text": " If compareEnable is VK_TRUE, the reductionMode member of VkSamplerReductionModeCreateInfoEXT must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT" - } - ] - }, - "VkSamplerReductionModeCreateInfoEXT": { - "(VK_EXT_sampler_filter_minmax)": [ - { - "vuid": "VUID-VkSamplerReductionModeCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkSamplerReductionModeCreateInfoEXT-reductionMode-parameter", - "text": " reductionMode must be a valid VkSamplerReductionModeEXT value" - } - ] - }, - "vkDestroySampler": { - "core": [ - { - "vuid": "VUID-vkDestroySampler-sampler-01082", - "text": " All submitted commands that refer to sampler must have completed execution" - }, - { - "vuid": "VUID-vkDestroySampler-sampler-01083", - "text": " If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroySampler-sampler-01084", - "text": " If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroySampler-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroySampler-sampler-parameter", - "text": " If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle" - }, - { - "vuid": "VUID-vkDestroySampler-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroySampler-sampler-parent", - "text": " If sampler is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "VkSamplerYcbcrConversionInfo": { - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkSamplerYcbcrConversionInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionInfo-conversion-parameter", - "text": " conversion must be a valid VkSamplerYcbcrConversion handle" - } - ] - }, - "vkCreateSamplerYcbcrConversion": { - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkCreateSamplerYcbcrConversion-None-01648", - "text": " The &amp;lt;&amp;lt;features-features-sampler-YCbCr-conversion, sampler Y’CBCR conversion feature&amp;gt;&amp;gt; must be enabled" - }, - { - "vuid": "VUID-vkCreateSamplerYcbcrConversion-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateSamplerYcbcrConversion-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter", - "text": " pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle" - } - ] - }, - "VkSamplerYcbcrConversionCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01649", - "text": " format must not be VK_FORMAT_UNDEFINED" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01904", - "text": " If an external format conversion is being created, format must be VK_FORMAT_UNDEFINED, otherwise it must not be VK_FORMAT_UNDEFINED." - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01650", - "text": " format must support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651", - "text": " If the format does not support VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_COSITED_EVEN" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652", - "text": " If the format does not support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_MIDPOINT" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01653", - "text": " format must represent unsigned normalized values (i.e. the format must be a UNORM format)" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-None-01654", - "text": " If the format has a _422 or _420 suffix:" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655", - "text": " If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to channels of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a channel which contains zero or one as a consequence of &amp;lt;&amp;lt;textures-conversion-to-rgba,conversion to RGBA&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656", - "text": " If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, forceExplicitReconstruction must be FALSE" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657", - "text": " If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, chromaFilter must be VK_FILTER_NEAREST" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkExternalFormatANDROID" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter", - "text": " ycbcrModel must be a valid VkSamplerYcbcrModelConversion value" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter", - "text": " ycbcrRange must be a valid VkSamplerYcbcrRange value" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter", - "text": " components must be a valid VkComponentMapping structure" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter", - "text": " xChromaOffset must be a valid VkChromaLocation value" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter", - "text": " yChromaOffset must be a valid VkChromaLocation value" - }, - { - "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter", - "text": " chromaFilter must be a valid VkFilter value" - } - ] - }, - "vkDestroySamplerYcbcrConversion": { - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkDestroySamplerYcbcrConversion-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", - "text": " If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle" - }, - { - "vuid": "VUID-vkDestroySamplerYcbcrConversion-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent", - "text": " If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateDescriptorSetLayout": { - "core": [ - { - "vuid": "VUID-vkCreateDescriptorSetLayout-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateDescriptorSetLayout-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter", - "text": " pSetLayout must be a valid pointer to a VkDescriptorSetLayout handle" - } - ] - }, - "VkDescriptorSetLayoutCreateInfo": { - "core": [ - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-binding-00279", - "text": " The VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values." - }, - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetLayoutBindingFlagsCreateInfoEXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkDescriptorSetLayoutCreateFlagBits values" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter", - "text": " If bindingCount is not 0, pBindings must be a valid pointer to an array of bindingCount valid VkDescriptorSetLayoutBinding structures" - } - ], - "(VK_KHR_push_descriptor)": [ - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-00280", - "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-00281", - "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then the total number of elements of all bindings must be less than or equal to VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors" - } - ], - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-03000", - "text": " If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, flags must include VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001", - "text": " If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" - } - ] - }, - "VkDescriptorSetLayoutBinding": { - "core": [ - { - "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283", - "text": " If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-01510", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter", - "text": " descriptorType must be a valid VkDescriptorType value" - } - ] - }, - "VkDescriptorSetLayoutBindingFlagsCreateInfoEXT": { - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-bindingCount-03002", - "text": " If bindingCount is not zero, bindingCount must equal VkDescriptorSetLayoutCreateInfo::bindingCount" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03004", - "text": " If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformBufferUpdateAfterBind-03005", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingSampledImageUpdateAfterBind-03006", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingSampledImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageImageUpdateAfterBind-03007", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageBufferUpdateAfterBind-03008", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUniformTexelBufferUpdateAfterBind-03009", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingStorageTexelBufferUpdateAfterBind-03010", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-None-03011", - "text": " All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingUpdateUnusedWhilePending-03012", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUpdateUnusedWhilePending is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingPartiallyBound-03013", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingPartiallyBound is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-descriptorBindingVariableDescriptorCount-03014", - "text": " If VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingVariableDescriptorCount is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-03015", - "text": " If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, that element’s descriptorType must not be VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-parameter", - "text": " If bindingCount is not 0, pBindingFlags must be a valid pointer to an array of bindingCount valid combinations of VkDescriptorBindingFlagBitsEXT values" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-pBindingFlags-requiredbitmask", - "text": " Each element of pBindingFlags must not be 0" - } - ], - "(VK_EXT_descriptor_indexing)+(VK_KHR_push_descriptor)": [ - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfoEXT-flags-03003", - "text": " If VkDescriptorSetLayoutCreateInfo::flags includes VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT, or VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT" - } - ] - }, - "vkGetDescriptorSetLayoutSupport": { - "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ - { - "vuid": "VUID-vkGetDescriptorSetLayoutSupport-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure" - }, - { - "vuid": "VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter", - "text": " pSupport must be a valid pointer to a VkDescriptorSetLayoutSupport structure" - } - ] - }, - "VkDescriptorSetLayoutSupport": { - "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ - { - "vuid": "VUID-VkDescriptorSetLayoutSupport-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutSupport-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountLayoutSupportEXT" - } - ] - }, - "VkDescriptorSetVariableDescriptorCountLayoutSupportEXT": { - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkDescriptorSetVariableDescriptorCountLayoutSupportEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT" - } - ] - }, - "vkDestroyDescriptorSetLayout": { - "core": [ - { - "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284", - "text": " If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285", - "text": " If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyDescriptorSetLayout-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter", - "text": " If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" - }, - { - "vuid": "VUID-vkDestroyDescriptorSetLayout-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent", - "text": " If descriptorSetLayout is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreatePipelineLayout": { - "core": [ - { - "vuid": "VUID-vkCreatePipelineLayout-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreatePipelineLayout-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkPipelineLayoutCreateInfo structure" - }, - { - "vuid": "VUID-vkCreatePipelineLayout-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreatePipelineLayout-pPipelineLayout-parameter", - "text": " pPipelineLayout must be a valid pointer to a VkPipelineLayout handle" - } - ] - }, - "VkPipelineLayoutCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286", - "text": " setLayoutCount must be less than or equal to VkPhysicalDeviceLimits::maxBoundDescriptorSets" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292", - "text": " Any two elements of pPushConstantRanges must not include the same stage in stageFlags" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", - "text": " If setLayoutCount is not 0, pSetLayouts must be a valid pointer to an array of setLayoutCount valid VkDescriptorSetLayout handles" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter", - "text": " If pushConstantRangeCount is not 0, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures" - } - ], - "!(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00287", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00288", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00289", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00290", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00291", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01676", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01677", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01678", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01679", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01680", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01681", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01682", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01683", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01684", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments" - } - ], - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03016", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03017", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03018", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03019", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03020", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03021", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03022", - "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSamplers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03023", - "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindUniformBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03024", - "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03025", - "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSampledImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03026", - "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03027", - "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInputAttachments" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03028", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03029", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03030", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03031", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03032", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03033", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03034", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03035", - "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSamplers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffers" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSampledImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageImages" - }, - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043", - "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindInputAttachments" - } - ], - "(VK_KHR_push_descriptor)": [ - { - "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293", - "text": " pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set" - } - ] - }, - "VkPushConstantRange": { - "core": [ - { - "vuid": "VUID-VkPushConstantRange-offset-00294", - "text": " offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize" - }, - { - "vuid": "VUID-VkPushConstantRange-offset-00295", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-VkPushConstantRange-size-00296", - "text": " size must be greater than 0" - }, - { - "vuid": "VUID-VkPushConstantRange-size-00297", - "text": " size must be a multiple of 4" - }, - { - "vuid": "VUID-VkPushConstantRange-size-00298", - "text": " size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset" - }, - { - "vuid": "VUID-VkPushConstantRange-stageFlags-parameter", - "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" - }, - { - "vuid": "VUID-VkPushConstantRange-stageFlags-requiredbitmask", - "text": " stageFlags must not be 0" - } - ] - }, - "vkDestroyPipelineLayout": { - "core": [ - { - "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00299", - "text": " If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00300", - "text": " If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyPipelineLayout-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-parameter", - "text": " If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-vkDestroyPipelineLayout-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-parent", - "text": " If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCreateDescriptorPool": { - "core": [ - { - "vuid": "VUID-vkCreateDescriptorPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateDescriptorPool-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorPoolCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateDescriptorPool-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDescriptorPool-pDescriptorPool-parameter", - "text": " pDescriptorPool must be a valid pointer to a VkDescriptorPool handle" - } - ] - }, - "VkDescriptorPoolCreateInfo": { - "core": [ - { - "vuid": "VUID-VkDescriptorPoolCreateInfo-maxSets-00301", - "text": " maxSets must be greater than 0" - }, - { - "vuid": "VUID-VkDescriptorPoolCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO" - }, - { - "vuid": "VUID-VkDescriptorPoolCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkDescriptorPoolCreateFlagBits values" - }, - { - "vuid": "VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter", - "text": " pPoolSizes must be a valid pointer to an array of poolSizeCount valid VkDescriptorPoolSize structures" - }, - { - "vuid": "VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength", - "text": " poolSizeCount must be greater than 0" - } - ] - }, - "VkDescriptorPoolSize": { - "core": [ - { - "vuid": "VUID-VkDescriptorPoolSize-descriptorCount-00302", - "text": " descriptorCount must be greater than 0" - }, - { - "vuid": "VUID-VkDescriptorPoolSize-type-parameter", - "text": " type must be a valid VkDescriptorType value" - } - ] - }, - "vkDestroyDescriptorPool": { - "core": [ - { - "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00303", - "text": " All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution" - }, - { - "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00304", - "text": " If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00305", - "text": " If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyDescriptorPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-parameter", - "text": " If descriptorPool is not VK_NULL_HANDLE, descriptorPool must be a valid VkDescriptorPool handle" - }, - { - "vuid": "VUID-vkDestroyDescriptorPool-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-parent", - "text": " If descriptorPool is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkAllocateDescriptorSets": { - "core": [ - { - "vuid": "VUID-vkAllocateDescriptorSets-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter", - "text": " pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure" - }, - { - "vuid": "VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter", - "text": " pDescriptorSets must be a valid pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles" - } - ] - }, - "VkDescriptorSetAllocateInfo": { - "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-00306", - "text": " descriptorSetCount must not be greater than the number of sets that are currently available for allocation in descriptorPool" - }, - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorPool-00307", - "text": " descriptorPool must have enough free descriptor capacity remaining to allocate the descriptor sets of the specified layouts" - } - ], - "(VK_KHR_push_descriptor)": [ - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308", - "text": " Each element of pSetLayouts must not have been created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set" - } - ], - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044", - "text": " If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set" - } - ], - "core": [ - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO" - }, - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountAllocateInfoEXT" - }, - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter", - "text": " descriptorPool must be a valid VkDescriptorPool handle" - }, - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter", - "text": " pSetLayouts must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSetLayout handles" - }, - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength", - "text": " descriptorSetCount must be greater than 0" - }, - { - "vuid": "VUID-VkDescriptorSetAllocateInfo-commonparent", - "text": " Both of descriptorPool, and the elements of pSetLayouts must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkDescriptorSetVariableDescriptorCountAllocateInfoEXT": { - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-descriptorSetCount-03045", - "text": " If descriptorSetCount is not zero, descriptorSetCount must equal VkDescriptorSetAllocateInfo::descriptorSetCount" - }, - { - "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pSetLayouts-03046", - "text": " If VkDescriptorSetAllocateInfo::pSetLayouts[i] has a variable descriptor count binding, then pDescriptorCounts[i] must be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created." - }, - { - "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT" - }, - { - "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfoEXT-pDescriptorCounts-parameter", - "text": " If descriptorSetCount is not 0, pDescriptorCounts must be a valid pointer to an array of descriptorSetCount uint32_t values" - } - ] - }, - "vkFreeDescriptorSets": { - "core": [ - { - "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00309", - "text": " All submitted commands that refer to any element of pDescriptorSets must have completed execution" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00310", - "text": " pDescriptorSets must be a valid pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or VK_NULL_HANDLE" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00311", - "text": " Each valid handle in pDescriptorSets must have been allocated from descriptorPool" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-00312", - "text": " descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-parameter", - "text": " descriptorPool must be a valid VkDescriptorPool handle" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength", - "text": " descriptorSetCount must be greater than 0" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-parent", - "text": " descriptorPool must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-parent", - "text": " Each element of pDescriptorSets that is a valid handle must have been created, allocated, or retrieved from descriptorPool" - } - ] - }, - "vkResetDescriptorPool": { - "core": [ - { - "vuid": "VUID-vkResetDescriptorPool-descriptorPool-00313", - "text": " All uses of descriptorPool (via any allocated descriptor sets) must have completed execution" - }, - { - "vuid": "VUID-vkResetDescriptorPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkResetDescriptorPool-descriptorPool-parameter", - "text": " descriptorPool must be a valid VkDescriptorPool handle" - }, - { - "vuid": "VUID-vkResetDescriptorPool-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-vkResetDescriptorPool-descriptorPool-parent", - "text": " descriptorPool must have been created, allocated, or retrieved from device" - } - ] - }, - "vkUpdateDescriptorSets": { - "!(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-vkUpdateDescriptorSets-dstSet-00314", - "text": " The dstSet member of each element of pDescriptorWrites or pDescriptorCopies must not be used by any command that was recorded to a command buffer which is in the &amp;lt;&amp;lt;commandbuffers-lifecycle, pending state&amp;gt;&amp;gt;." - } - ], - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-vkUpdateDescriptorSets-None-03047", - "text": " Descriptor bindings updated by this command which were created without the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT bits set must not be used by any command that was recorded to a command buffer which is in the &amp;lt;&amp;lt;commandbuffers-lifecycle,pending state&amp;gt;&amp;gt;." - } - ], - "core": [ - { - "vuid": "VUID-vkUpdateDescriptorSets-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter", - "text": " If descriptorWriteCount is not 0, pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures" - }, - { - "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter", - "text": " If descriptorCopyCount is not 0, pDescriptorCopies must be a valid pointer to an array of descriptorCopyCount valid VkCopyDescriptorSet structures" - } - ] - }, - "VkWriteDescriptorSet": { - "core": [ - { - "vuid": "VUID-VkWriteDescriptorSet-dstBinding-00315", - "text": " dstBinding must be less than or equal to the maximum value of binding of all VkDescriptorSetLayoutBinding structures specified when dstSet’s descriptor set layout was created" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-dstBinding-00316", - "text": " dstBinding must be a binding with a non-zero descriptorCount" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00317", - "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical descriptorType and stageFlags." - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00318", - "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must all either use immutable samplers or must all not use immutable samplers." - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00319", - "text": " descriptorType must match the type of dstBinding within dstSet" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-dstSet-00320", - "text": " dstSet must be a valid VkDescriptorSet handle" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-dstArrayElement-00321", - "text": " The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00322", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pImageInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorImageInfo structures" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00323", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pTexelBufferView must be a valid pointer to an array of descriptorCount valid VkBufferView handles" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00324", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00325", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was not allocated with a layout that included immutable samplers for dstBinding with descriptorType, the sampler member of each element of pImageInfo must be a valid VkSampler object" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00326", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView and imageLayout members of each element of pImageInfo must be a valid VkImageView and VkImageLayout, respectively" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01946", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, then the imageView member of each pImageInfo element must have been created without a VkSamplerYcbcrConversionInfo structure in its pNext chain" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01947", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and if any element of pImageInfo has a imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, then dstSet must have been allocated with a layout that included immutable samplers for dstBinding" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01948", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was allocated with a layout that included immutable samplers for dstBinding, then the imageView member of each element of pImageInfo which corresponds to a immutable sampler that enables &amp;lt;&amp;lt;samplers-YCbCr-conversion,sampler Y’CBCR conversion&amp;gt;&amp;gt; must have been created with a VkSamplerYcbcrConversionInfo structure in its pNext chain with an identically defined VkSamplerYcbcrConversionInfo to the corresponding immutable sampler" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01402", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, for each descriptor that will be accessed via load or store operations the imageLayout member for corresponding elements of pImageInfo must be VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00327", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00328", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00329", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, and the buffer member of any element of pBufferInfo is the handle of a non-sparse buffer, then that buffer must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00330", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00331", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00332", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxUniformBufferRange" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00333", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxStorageBufferRange" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00334", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00335", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00336", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the identity swizzle" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00337", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_SAMPLED_BIT set" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01403", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageLayout member of each element of pImageInfo must be VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00338", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00339", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-parameter", - "text": " descriptorType must be a valid VkDescriptorType value" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-arraylength", - "text": " descriptorCount must be greater than 0" - }, - { - "vuid": "VUID-VkWriteDescriptorSet-commonparent", - "text": " Both of dstSet, and the elements of pTexelBufferView that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-03048", - "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical VkDescriptorBindingFlagBitsEXT." - } - ] - }, - "VkDescriptorBufferInfo": { - "core": [ - { - "vuid": "VUID-VkDescriptorBufferInfo-offset-00340", - "text": " offset must be less than the size of buffer" - }, - { - "vuid": "VUID-VkDescriptorBufferInfo-range-00341", - "text": " If range is not equal to VK_WHOLE_SIZE, range must be greater than 0" - }, - { - "vuid": "VUID-VkDescriptorBufferInfo-range-00342", - "text": " If range is not equal to VK_WHOLE_SIZE, range must be less than or equal to the size of buffer minus offset" - }, - { - "vuid": "VUID-VkDescriptorBufferInfo-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - } - ] - }, - "VkDescriptorImageInfo": { - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkDescriptorImageInfo-imageView-00343", - "text": " imageView must not be 2D or 2D array image view created from a 3D image" - } - ], - "core": [ - { - "vuid": "VUID-VkDescriptorImageInfo-imageView-01976", - "text": " If imageView is created from a depth/stencil image, the aspectMask used to create the imageView must include either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT but not both." - }, - { - "vuid": "VUID-VkDescriptorImageInfo-imageLayout-00344", - "text": " imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time this descriptor is accessed" - }, - { - "vuid": "VUID-VkDescriptorImageInfo-commonparent", - "text": " Both of imageView, and sampler that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkDescriptorImageInfo-sampler-01564", - "text": " If sampler is used and the VkFormat of the image is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT" - } - ] - }, - "VkCopyDescriptorSet": { - "core": [ - { - "vuid": "VUID-VkCopyDescriptorSet-srcBinding-00345", - "text": " srcBinding must be a valid binding within srcSet" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-srcArrayElement-00346", - "text": " The sum of srcArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by srcBinding, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-dstBinding-00347", - "text": " dstBinding must be a valid binding within dstSet" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-dstArrayElement-00348", - "text": " The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-srcSet-00349", - "text": " If srcSet is equal to dstSet, then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-srcSet-parameter", - "text": " srcSet must be a valid VkDescriptorSet handle" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-dstSet-parameter", - "text": " dstSet must be a valid VkDescriptorSet handle" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-commonparent", - "text": " Both of dstSet, and srcSet must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkCopyDescriptorSet-srcSet-01918", - "text": " If srcSet’s layout was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet’s layout must also have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-srcSet-01919", - "text": " If srcSet’s layout was created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set, then dstSet’s layout must also have been created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT flag set" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-srcSet-01920", - "text": " If the descriptor pool from which srcSet was allocated was created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set" - }, - { - "vuid": "VUID-VkCopyDescriptorSet-srcSet-01921", - "text": " If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set, then the descriptor pool from which dstSet was allocated must also have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT flag set" - } - ] - }, - "vkCreateDescriptorUpdateTemplate": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ - { - "vuid": "VUID-vkCreateDescriptorUpdateTemplate-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateDescriptorUpdateTemplate-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorUpdateTemplateCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateDescriptorUpdateTemplate-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDescriptorUpdateTemplate-pDescriptorUpdateTemplate-parameter", - "text": " pDescriptorUpdateTemplate must be a valid pointer to a VkDescriptorUpdateTemplate handle" - } - ] - }, - "VkDescriptorUpdateTemplateCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350", - "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-pDescriptorUpdateEntries-parameter", - "text": " pDescriptorUpdateEntries must be a valid pointer to an array of descriptorUpdateEntryCount valid VkDescriptorUpdateTemplateEntry structures" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-parameter", - "text": " templateType must be a valid VkDescriptorUpdateTemplateType value" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter", - "text": " If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorUpdateEntryCount-arraylength", - "text": " descriptorUpdateEntryCount must be greater than 0" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent", - "text": " Both of descriptorSetLayout, and pipelineLayout that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)": [ - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351", - "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineBindPoint must be a valid VkPipelineBindPoint value" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352", - "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineLayout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353", - "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" - } - ] - }, - "VkDescriptorUpdateTemplateEntry": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ - { - "vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354", - "text": " dstBinding must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors." - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355", - "text": " dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding implicitly specified when using a descriptor update template to update descriptors, and all applicable consecutive bindings, as described by &amp;lt;&amp;lt;descriptorsets-updates-consecutive&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkDescriptorUpdateTemplateEntry-descriptorType-parameter", - "text": " descriptorType must be a valid VkDescriptorType value" - } - ] - }, - "vkDestroyDescriptorUpdateTemplate": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ - { - "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", - "text": " If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357", - "text": " If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter", - "text": " If descriptorUpdateTemplate is not VK_NULL_HANDLE, descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle" - }, - { - "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent", - "text": " If descriptorUpdateTemplate is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkUpdateDescriptorSetWithTemplate": { - "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ - { - "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-pData-01685", - "text": " pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate" - }, - { - "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter", - "text": " descriptorSet must be a valid VkDescriptorSet handle" - }, - { - "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter", - "text": " descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle" - }, - { - "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent", - "text": " descriptorUpdateTemplate must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCmdBindDescriptorSets": { - "core": [ - { - "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358", - "text": " Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359", - "text": " dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-firstSet-00360", - "text": " The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361", - "text": " pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01971", - "text": " Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01972", - "text": " Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter", - "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-layout-parameter", - "text": " layout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter", - "text": " pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter", - "text": " If dynamicOffsetCount is not 0, pDynamicOffsets must be a valid pointer to an array of dynamicOffsetCount uint32_t values" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength", - "text": " descriptorSetCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdBindDescriptorSets-commonparent", - "text": " Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCmdPushDescriptorSetKHR": { - "(VK_KHR_push_descriptor)": [ - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363", - "text": " pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00364", - "text": " set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00365", - "text": " set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter", - "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-layout-parameter", - "text": " layout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter", - "text": " pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength", - "text": " descriptorWriteCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetKHR-commonparent", - "text": " Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCmdPushDescriptorSetWithTemplateKHR": { - "(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366", - "text": " The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer’s parent VkCommandPool’s queue family" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686", - "text": " pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplateKHR" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter", - "text": " descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter", - "text": " layout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent", - "text": " Each of commandBuffer, descriptorUpdateTemplate, and layout must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCmdPushConstants": { - "core": [ - { - "vuid": "VUID-vkCmdPushConstants-offset-01795", - "text": " For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage" - }, - { - "vuid": "VUID-vkCmdPushConstants-offset-01796", - "text": " For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range’s VkPushConstantRange::stageFlags" - }, - { - "vuid": "VUID-vkCmdPushConstants-offset-00368", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdPushConstants-size-00369", - "text": " size must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdPushConstants-offset-00370", - "text": " offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize" - }, - { - "vuid": "VUID-vkCmdPushConstants-size-00371", - "text": " size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset" - }, - { - "vuid": "VUID-vkCmdPushConstants-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdPushConstants-layout-parameter", - "text": " layout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-vkCmdPushConstants-stageFlags-parameter", - "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" - }, - { - "vuid": "VUID-vkCmdPushConstants-stageFlags-requiredbitmask", - "text": " stageFlags must not be 0" - }, - { - "vuid": "VUID-vkCmdPushConstants-pValues-parameter", - "text": " pValues must be a valid pointer to an array of size bytes" - }, - { - "vuid": "VUID-vkCmdPushConstants-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdPushConstants-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdPushConstants-size-arraylength", - "text": " size must be greater than 0" - }, - { - "vuid": "VUID-vkCmdPushConstants-commonparent", - "text": " Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCreateQueryPool": { - "core": [ - { - "vuid": "VUID-vkCreateQueryPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateQueryPool-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkQueryPoolCreateInfo structure" - }, - { - "vuid": "VUID-vkCreateQueryPool-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateQueryPool-pQueryPool-parameter", - "text": " pQueryPool must be a valid pointer to a VkQueryPool handle" - } - ] - }, - "VkQueryPoolCreateInfo": { - "core": [ - { - "vuid": "VUID-VkQueryPoolCreateInfo-queryType-00791", - "text": " If the &amp;lt;&amp;lt;features-features-pipelineStatisticsQuery,pipeline statistics queries&amp;gt;&amp;gt; feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS" - }, - { - "vuid": "VUID-VkQueryPoolCreateInfo-queryType-00792", - "text": " If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values" - }, - { - "vuid": "VUID-VkQueryPoolCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO" - }, - { - "vuid": "VUID-VkQueryPoolCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkQueryPoolCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkQueryPoolCreateInfo-queryType-parameter", - "text": " queryType must be a valid VkQueryType value" - } - ] - }, - "vkDestroyQueryPool": { - "core": [ - { - "vuid": "VUID-vkDestroyQueryPool-queryPool-00793", - "text": " All submitted commands that refer to queryPool must have completed execution" - }, - { - "vuid": "VUID-vkDestroyQueryPool-queryPool-00794", - "text": " If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyQueryPool-queryPool-00795", - "text": " If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyQueryPool-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyQueryPool-queryPool-parameter", - "text": " If queryPool is not VK_NULL_HANDLE, queryPool must be a valid VkQueryPool handle" - }, - { - "vuid": "VUID-vkDestroyQueryPool-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyQueryPool-queryPool-parent", - "text": " If queryPool is a valid handle, it must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCmdResetQueryPool": { - "core": [ - { - "vuid": "VUID-vkCmdResetQueryPool-firstQuery-00796", - "text": " firstQuery must be less than the number of queries in queryPool" - }, - { - "vuid": "VUID-vkCmdResetQueryPool-firstQuery-00797", - "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" - }, - { - "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdResetQueryPool-queryPool-parameter", - "text": " queryPool must be a valid VkQueryPool handle" - }, - { - "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdResetQueryPool-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdResetQueryPool-commonparent", - "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCmdBeginQuery": { - "core": [ - { - "vuid": "VUID-vkCmdBeginQuery-queryPool-01922", - "text": " queryPool must have been created with a queryType that differs from that of any queries that are &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt; within commandBuffer" - }, - { - "vuid": "VUID-vkCmdBeginQuery-None-00807", - "text": " All queries used by the command must be unavailable" - }, - { - "vuid": "VUID-vkCmdBeginQuery-queryType-00800", - "text": " If the &amp;lt;&amp;lt;features-features-occlusionQueryPrecise,precise occlusion queries&amp;gt;&amp;gt; feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT" - }, - { - "vuid": "VUID-vkCmdBeginQuery-query-00802", - "text": " query must be less than the number of queries in queryPool" - }, - { - "vuid": "VUID-vkCmdBeginQuery-queryType-00803", - "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdBeginQuery-queryType-00804", - "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdBeginQuery-queryType-00805", - "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations" - }, - { - "vuid": "VUID-vkCmdBeginQuery-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBeginQuery-queryPool-parameter", - "text": " queryPool must be a valid VkQueryPool handle" - }, - { - "vuid": "VUID-vkCmdBeginQuery-flags-parameter", - "text": " flags must be a valid combination of VkQueryControlFlagBits values" - }, - { - "vuid": "VUID-vkCmdBeginQuery-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBeginQuery-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdBeginQuery-commonparent", - "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdBeginQuery-commandBuffer-01885", - "text": " commandBuffer must not be a protected command buffer" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdBeginQuery-query-00808", - "text": " If vkCmdBeginQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" - } - ] - }, - "vkCmdEndQuery": { - "core": [ - { - "vuid": "VUID-vkCmdEndQuery-None-01923", - "text": " All queries used by the command must be &amp;lt;&amp;lt;queries-operation-active,active&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdEndQuery-query-00810", - "text": " query must be less than the number of queries in queryPool" - }, - { - "vuid": "VUID-vkCmdEndQuery-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdEndQuery-queryPool-parameter", - "text": " queryPool must be a valid VkQueryPool handle" - }, - { - "vuid": "VUID-vkCmdEndQuery-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdEndQuery-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdEndQuery-commonparent", - "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdEndQuery-commandBuffer-01886", - "text": " commandBuffer must not be a protected command buffer" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdEndQuery-query-00812", - "text": " If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" - } - ] - }, - "vkGetQueryPoolResults": { - "core": [ - { - "vuid": "VUID-vkGetQueryPoolResults-firstQuery-00813", - "text": " firstQuery must be less than the number of queries in queryPool" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-flags-00814", - "text": " If VK_QUERY_RESULT_64_BIT is not set in flags then pData and stride must be multiples of 4" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-flags-00815", - "text": " If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-firstQuery-00816", - "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-dataSize-00817", - "text": " dataSize must be large enough to contain the result of each query, as described &amp;lt;&amp;lt;queries-operation-memorylayout,here&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-queryType-00818", - "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-queryPool-parameter", - "text": " queryPool must be a valid VkQueryPool handle" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-pData-parameter", - "text": " pData must be a valid pointer to an array of dataSize bytes" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-flags-parameter", - "text": " flags must be a valid combination of VkQueryResultFlagBits values" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-dataSize-arraylength", - "text": " dataSize must be greater than 0" - }, - { - "vuid": "VUID-vkGetQueryPoolResults-queryPool-parent", - "text": " queryPool must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCmdCopyQueryPoolResults": { - "core": [ - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-dstOffset-00819", - "text": " dstOffset must be less than the size of dstBuffer" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-firstQuery-00820", - "text": " firstQuery must be less than the number of queries in queryPool" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-firstQuery-00821", - "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-00822", - "text": " If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-00823", - "text": " If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824", - "text": " dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described &amp;lt;&amp;lt;queries-operation-memorylayout,here&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825", - "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826", - "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-00827", - "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-queryPool-parameter", - "text": " queryPool must be a valid VkQueryPool handle" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter", - "text": " dstBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-parameter", - "text": " flags must be a valid combination of VkQueryResultFlagBits values" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-commonparent", - "text": " Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCmdWriteTimestamp": { - "core": [ - { - "vuid": "VUID-vkCmdWriteTimestamp-queryPool-01416", - "text": " queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-queryPool-00828", - "text": " The query identified by queryPool and query must be unavailable" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-timestampValidBits-00829", - "text": " The command pool’s queue family must support a non-zero timestampValidBits" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-parameter", - "text": " pipelineStage must be a valid VkPipelineStageFlagBits value" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-queryPool-parameter", - "text": " queryPool must be a valid VkQueryPool handle" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-commonparent", - "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdWriteTimestamp-None-00830", - "text": " All queries used by the command must be unavailable" - }, - { - "vuid": "VUID-vkCmdWriteTimestamp-query-00831", - "text": " If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" - } - ] - }, - "vkCmdClearColorImage": { - "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-vkCmdClearColorImage-image-00001", - "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdClearColorImage-image-01935", - "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "core": [ - { - "vuid": "VUID-vkCmdClearColorImage-image-00002", - "text": " image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdClearColorImage-image-00003", - "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdClearColorImage-imageLayout-00004", - "text": " imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdClearColorImage-baseMipLevel-01470", - "text": " The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearColorImage-pRanges-01692", - "text": " For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearColorImage-baseArrayLayer-01472", - "text": " The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearColorImage-pRanges-01693", - "text": " For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearColorImage-image-00007", - "text": " image must not have a compressed or depth/stencil format" - }, - { - "vuid": "VUID-vkCmdClearColorImage-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdClearColorImage-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdClearColorImage-imageLayout-parameter", - "text": " imageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdClearColorImage-pColor-parameter", - "text": " pColor must be a valid pointer to a valid VkClearColorValue union" - }, - { - "vuid": "VUID-vkCmdClearColorImage-pRanges-parameter", - "text": " pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures" - }, - { - "vuid": "VUID-vkCmdClearColorImage-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdClearColorImage-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdClearColorImage-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdClearColorImage-rangeCount-arraylength", - "text": " rangeCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdClearColorImage-commonparent", - "text": " Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkCmdClearColorImage-image-01545", - "text": " image must not use a format listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;" - } - ], - "!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdClearColorImage-imageLayout-00005", - "text": " imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdClearColorImage-imageLayout-01394", - "text": " imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01805", - "text": " If commandBuffer is an unprotected command buffer, then image must not be a protected image" - }, - { - "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01806", - "text": " If commandBuffer is a protected command buffer, then image must not be an unprotected image" - } - ] - }, - "vkCmdClearDepthStencilImage": { - "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-vkCmdClearDepthStencilImage-image-00008", - "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdClearDepthStencilImage-image-01936", - "text": " image must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "core": [ - { - "vuid": "VUID-vkCmdClearDepthStencilImage-image-00009", - "text": " image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-image-00010", - "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-00011", - "text": " imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-00012", - "text": " imageLayout must be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474", - "text": " The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-01694", - "text": " For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476", - "text": " The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-01695", - "text": " For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-image-00014", - "text": " image must have a depth/stencil format" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-parameter", - "text": " imageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter", - "text": " pDepthStencil must be a valid pointer to a valid VkClearDepthStencilValue structure" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-parameter", - "text": " pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength", - "text": " rangeCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-commonparent", - "text": " Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01807", - "text": " If commandBuffer is an unprotected command buffer, then image must not be a protected image" - }, - { - "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01808", - "text": " If commandBuffer is a protected command buffer, then image must not be an unprotected image" - } - ] - }, - "vkCmdClearAttachments": { - "core": [ - { - "vuid": "VUID-vkCmdClearAttachments-aspectMask-00015", - "text": " If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, the colorAttachment member of that element must refer to a valid color attachment in the current subpass" - }, - { - "vuid": "VUID-vkCmdClearAttachments-pRects-00016", - "text": " The rectangular region specified by each element of pRects must be contained within the render area of the current render pass instance" - }, - { - "vuid": "VUID-vkCmdClearAttachments-pRects-00017", - "text": " The layers specified by each element of pRects must be contained within every attachment that pAttachments refers to" - }, - { - "vuid": "VUID-vkCmdClearAttachments-layerCount-01934", - "text": " The layerCount member of each element of pRects must not be 0" - }, - { - "vuid": "VUID-vkCmdClearAttachments-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdClearAttachments-pAttachments-parameter", - "text": " pAttachments must be a valid pointer to an array of attachmentCount valid VkClearAttachment structures" - }, - { - "vuid": "VUID-vkCmdClearAttachments-pRects-parameter", - "text": " pRects must be a valid pointer to an array of rectCount VkClearRect structures" - }, - { - "vuid": "VUID-vkCmdClearAttachments-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdClearAttachments-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdClearAttachments-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdClearAttachments-attachmentCount-arraylength", - "text": " attachmentCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdClearAttachments-rectCount-arraylength", - "text": " rectCount must be greater than 0" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdClearAttachments-baseArrayLayer-00018", - "text": " If the render pass instance this is recorded in uses multiview, then baseArrayLayer must be zero and layerCount must be one." - } - ] - }, - "VkClearAttachment": { - "core": [ - { - "vuid": "VUID-VkClearAttachment-aspectMask-00019", - "text": " If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, it must not include VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" - }, - { - "vuid": "VUID-VkClearAttachment-aspectMask-00020", - "text": " aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT" - }, - { - "vuid": "VUID-VkClearAttachment-clearValue-00021", - "text": " clearValue must be a valid VkClearValue union" - }, - { - "vuid": "VUID-VkClearAttachment-aspectMask-parameter", - "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" - }, - { - "vuid": "VUID-VkClearAttachment-aspectMask-requiredbitmask", - "text": " aspectMask must not be 0" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkClearAttachment-commandBuffer-01809", - "text": " If commandBuffer is an unprotected command buffer, then the attachment to be cleared must not be a protected image." - }, - { - "vuid": "VUID-VkClearAttachment-commandBuffer-01810", - "text": " If commandBuffer is a protected command buffer, then the attachment to be cleared must not be an unprotected image." - } - ] - }, - "VkClearDepthStencilValue": { - "(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-VkClearDepthStencilValue-depth-00022", - "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled depth must be between 0.0 and 1.0, inclusive" - } - ], - "!(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-VkClearDepthStencilValue-depth-00022", - "text": " depth must be between 0.0 and 1.0, inclusive" - } - ] - }, - "VkClearValue": { - "core": [ - { - "vuid": "VUID-VkClearValue-depthStencil-00023", - "text": " depthStencil must be a valid VkClearDepthStencilValue structure" - } - ] - }, - "vkCmdFillBuffer": { - "core": [ - { - "vuid": "VUID-vkCmdFillBuffer-dstOffset-00024", - "text": " dstOffset must be less than the size of dstBuffer" - }, - { - "vuid": "VUID-vkCmdFillBuffer-dstOffset-00025", - "text": " dstOffset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdFillBuffer-size-00026", - "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" - }, - { - "vuid": "VUID-vkCmdFillBuffer-size-00027", - "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset" - }, - { - "vuid": "VUID-vkCmdFillBuffer-size-00028", - "text": " If size is not equal to VK_WHOLE_SIZE, size must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdFillBuffer-dstBuffer-00029", - "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdFillBuffer-dstBuffer-00031", - "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdFillBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdFillBuffer-dstBuffer-parameter", - "text": " dstBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdFillBuffer-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdFillBuffer-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations" - }, - { - "vuid": "VUID-vkCmdFillBuffer-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdFillBuffer-commonparent", - "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-vkCmdFillBuffer-commandBuffer-00030", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01811", - "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" - }, - { - "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01812", - "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" - } - ] - }, - "vkCmdUpdateBuffer": { - "core": [ - { - "vuid": "VUID-vkCmdUpdateBuffer-dstOffset-00032", - "text": " dstOffset must be less than the size of dstBuffer" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00033", - "text": " dataSize must be less than or equal to the size of dstBuffer minus dstOffset" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-00034", - "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-00035", - "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dstOffset-00036", - "text": " dstOffset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00037", - "text": " dataSize must be less than or equal to 65536" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00038", - "text": " dataSize must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-parameter", - "text": " dstBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-pData-parameter", - "text": " pData must be a valid pointer to an array of dataSize bytes" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-dataSize-arraylength", - "text": " dataSize must be greater than 0" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-commonparent", - "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01813", - "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" - }, - { - "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01814", - "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" - } - ] - }, - "vkCmdCopyBuffer": { - "core": [ - { - "vuid": "VUID-vkCmdCopyBuffer-size-00112", - "text": " The size member of each element of pRegions must be greater than 0" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-srcOffset-00113", - "text": " The srcOffset member of each element of pRegions must be less than the size of srcBuffer" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-dstOffset-00114", - "text": " The dstOffset member of each element of pRegions must be less than the size of dstBuffer" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-size-00115", - "text": " The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-size-00116", - "text": " The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-pRegions-00117", - "text": " The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-00118", - "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-00119", - "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-00120", - "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-00121", - "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-parameter", - "text": " srcBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-parameter", - "text": " dstBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-pRegions-parameter", - "text": " pRegions must be a valid pointer to an array of regionCount VkBufferCopy structures" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-regionCount-arraylength", - "text": " regionCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-commonparent", - "text": " Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01822", - "text": " If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01823", - "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" - }, - { - "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01824", - "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" - } - ] - }, - "vkCmdCopyImage": { - "core": [ - { - "vuid": "VUID-vkCmdCopyImage-pRegions-00122", - "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" - }, - { - "vuid": "VUID-vkCmdCopyImage-pRegions-00123", - "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" - }, - { - "vuid": "VUID-vkCmdCopyImage-pRegions-00124", - "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcImage-00126", - "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcImageLayout-00128", - "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-00131", - "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImageLayout-00133", - "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcImage-00136", - "text": " The sample count of srcImage and dstImage must match" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcSubresource-01696", - "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstSubresource-01697", - "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcSubresource-01698", - "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstSubresource-01699", - "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcOffset-01783", - "text": " The srcOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstOffset-01784", - "text": " The dstOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" - }, - { - "vuid": "VUID-vkCmdCopyImage-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcImage-parameter", - "text": " srcImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcImageLayout-parameter", - "text": " srcImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-parameter", - "text": " dstImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImageLayout-parameter", - "text": " dstImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdCopyImage-pRegions-parameter", - "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageCopy structures" - }, - { - "vuid": "VUID-vkCmdCopyImage-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdCopyImage-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdCopyImage-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdCopyImage-regionCount-arraylength", - "text": " regionCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdCopyImage-commonparent", - "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-vkCmdCopyImage-srcImage-00125", - "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-00130", - "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdCopyImage-srcImage-01938", - "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-01939", - "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkCmdCopyImage-srcImage-00127", - "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-00132", - "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcImage-00135", - "text": " The VkFormat of each of srcImage and dstImage must be compatible, as defined &amp;lt;&amp;lt;copies-images-format-compatibility, below&amp;gt;&amp;gt;" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkCmdCopyImage-srcImage-01546", - "text": " If srcImage is non-sparse then the image or disjoint plane to be copied must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-01547", - "text": " If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcImage-01548", - "text": " If the VkFormat of each of srcImage and dstImage is not a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, the VkFormat of each of srcImage and dstImage must be compatible, as defined &amp;lt;&amp;lt;copies-images-format-compatibility, below&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdCopyImage-None-01549", - "text": " In a copy to or from a plane of a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar image&amp;gt;&amp;gt;, the VkFormat of the image and plane must be compatible according to &amp;lt;&amp;lt;features-formats-compatible-planes,the description of compatible planes&amp;gt;&amp;gt; for the plane being copied" - }, - { - "vuid": "VUID-vkCmdCopyImage-aspectMask-01550", - "text": " When a copy is performed to or from an image with a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, the aspectMask of the srcSubresource and/or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for a VkFormat with three planes)" - } - ], - "!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdCopyImage-srcImageLayout-00129", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImageLayout-00134", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdCopyImage-srcImageLayout-01917", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImageLayout-01395", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdCopyImage-commandBuffer-01825", - "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdCopyImage-commandBuffer-01826", - "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdCopyImage-commandBuffer-01827", - "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" - } - ] - }, - "VkImageCopy": { - "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageCopy-aspectMask-00137", - "text": " The aspectMask member of srcSubresource and dstSubresource must match" - }, - { - "vuid": "VUID-VkImageCopy-srcOffset-00157", - "text": " If the calling command’s srcImage is a compressed image, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block" - }, - { - "vuid": "VUID-VkImageCopy-extent-00158", - "text": " If the calling command’s srcImage is a compressed image, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width" - }, - { - "vuid": "VUID-VkImageCopy-extent-00159", - "text": " If the calling command’s srcImage is a compressed image, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height" - }, - { - "vuid": "VUID-VkImageCopy-extent-00160", - "text": " If the calling command’s srcImage is a compressed image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth" - }, - { - "vuid": "VUID-VkImageCopy-dstOffset-00162", - "text": " If the calling command’s dstImage is a compressed format image, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block" - }, - { - "vuid": "VUID-VkImageCopy-extent-00163", - "text": " If the calling command’s dstImage is a compressed format image, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width" - }, - { - "vuid": "VUID-VkImageCopy-extent-00164", - "text": " If the calling command’s dstImage is a compressed format image, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height" - }, - { - "vuid": "VUID-VkImageCopy-extent-00165", - "text": " If the calling command’s dstImage is a compressed format image, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkImageCopy-srcImage-01551", - "text": " If neither the calling command’s srcImage nor the calling command’s dstImage has a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion, multi-planar image format&amp;gt;&amp;gt; then the aspectMask member of srcSubresource and dstSubresource must match" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01552", - "text": " If the calling command’s srcImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,two planes&amp;gt;&amp;gt; then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01553", - "text": " If the calling command’s srcImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,three planes&amp;gt;&amp;gt; then the srcSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01554", - "text": " If the calling command’s dstImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,two planes&amp;gt;&amp;gt; then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01555", - "text": " If the calling command’s dstImage has a VkFormat with &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,three planes&amp;gt;&amp;gt; then the dstSubresource aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01556", - "text": " If the calling command’s srcImage has a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar image format&amp;gt;&amp;gt; and the dstImage does not have a multi-planar image format, the dstSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01557", - "text": " If the calling command’s dstImage has a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar image format&amp;gt;&amp;gt; and the srcImage does not have a multi-planar image format, the srcSubresource aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01727", - "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01728", - "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the source image subresource width" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01729", - "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the source image subresource height" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01730", - "text": " If the calling command’s srcImage is a compressed image, or a single-plane, “_422” image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the source image subresource depth" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01731", - "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01732", - "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the destination image subresource width" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01733", - "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the destination image subresource height" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01734", - "text": " If the calling command’s dstImage is a compressed format image, or a single-plane, “_422” image format, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the destination image subresource depth" - } - ], - "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkImageCopy-layerCount-00138", - "text": " The layerCount member of srcSubresource and dstSubresource must match" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-00139", - "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01789", - "text": " If the calling command’s srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then extent.depth must be 1." - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-VkImageCopy-extent-00140", - "text": " The number of slices of the extent (for 3D) or layers of the srcSubresource (for non-3D) must match the number of slices of the extent (for 3D) or layers of the dstSubresource (for non-3D)" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-00141", - "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of the corresponding subresource must be 0 and 1, respectively" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01790", - "text": " If both srcImage and dstImage are of type VK_IMAGE_TYPE_2D then then extent.depth must be 1." - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01791", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_2D, and the dstImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of srcSubresource." - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01792", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_2D, and the srcImage is of type VK_IMAGE_TYPE_3D, then extent.depth must equal to the layerCount member of dstSubresource." - } - ], - "core": [ - { - "vuid": "VUID-VkImageCopy-aspectMask-00142", - "text": " The aspectMask member of srcSubresource must specify aspects present in the calling command’s srcImage" - }, - { - "vuid": "VUID-VkImageCopy-aspectMask-00143", - "text": " The aspectMask member of dstSubresource must specify aspects present in the calling command’s dstImage" - }, - { - "vuid": "VUID-VkImageCopy-srcOffset-00144", - "text": " srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width" - }, - { - "vuid": "VUID-VkImageCopy-srcOffset-00145", - "text": " srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-00146", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1." - }, - { - "vuid": "VUID-VkImageCopy-srcOffset-00147", - "text": " srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth" - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01785", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.z must be 0 and extent.depth must be 1." - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01786", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.z must be 0 and extent.depth must be 1." - }, - { - "vuid": "VUID-VkImageCopy-srcImage-01787", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_2D, then srcOffset.z must be 0." - }, - { - "vuid": "VUID-VkImageCopy-dstImage-01788", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_2D, then dstOffset.z must be 0." - }, - { - "vuid": "VUID-VkImageCopy-dstOffset-00150", - "text": " dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width" - }, - { - "vuid": "VUID-VkImageCopy-dstOffset-00151", - "text": " dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height" - }, - { - "vuid": "VUID-VkImageCopy-dstImage-00152", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1." - }, - { - "vuid": "VUID-VkImageCopy-dstOffset-00153", - "text": " dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth" - }, - { - "vuid": "VUID-VkImageCopy-srcSubresource-parameter", - "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" - }, - { - "vuid": "VUID-VkImageCopy-dstSubresource-parameter", - "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" - } - ] - }, - "VkImageSubresourceLayers": { - "core": [ - { - "vuid": "VUID-VkImageSubresourceLayers-aspectMask-00167", - "text": " If aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" - }, - { - "vuid": "VUID-VkImageSubresourceLayers-aspectMask-00168", - "text": " aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT" - }, - { - "vuid": "VUID-VkImageSubresourceLayers-layerCount-01700", - "text": " layerCount must be greater than 0" - }, - { - "vuid": "VUID-VkImageSubresourceLayers-aspectMask-parameter", - "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" - }, - { - "vuid": "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask", - "text": " aspectMask must not be 0" - } - ] - }, - "vkCmdCopyBufferToImage": { - "core": [ - { - "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00171", - "text": " srcBuffer must be large enough to contain all buffer locations that are accessed according to &amp;lt;&amp;lt;copies-buffers-images-addressing,Buffer and Image Addressing&amp;gt;&amp;gt;, for each element of pRegions" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00172", - "text": " The image region specified by each element of pRegions must be a region that is contained within dstImage" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00173", - "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-00174", - "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-00176", - "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00177", - "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00178", - "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00179", - "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180", - "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-imageSubresource-01701", - "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-imageSubresource-01702", - "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-01793", - "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-parameter", - "text": " srcBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-parameter", - "text": " dstImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter", - "text": " dstImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-parameter", - "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-regionCount-arraylength", - "text": " regionCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-commonparent", - "text": " Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00175", - "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-01940", - "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-00181", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-01396", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01828", - "text": " If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01829", - "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01830", - "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" - } - ] - }, - "vkCmdCopyImageToBuffer": { - "core": [ - { - "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00182", - "text": " The image region specified by each element of pRegions must be a region that is contained within srcImage" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00183", - "text": " dstBuffer must be large enough to contain all buffer locations that are accessed according to &amp;lt;&amp;lt;copies-buffers-images-addressing,Buffer and Image Addressing&amp;gt;&amp;gt;, for each element of pRegions" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00184", - "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00186", - "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00187", - "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00188", - "text": " srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189", - "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", - "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-00192", - "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703", - "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704", - "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-01794", - "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-parameter", - "text": " srcImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter", - "text": " srcImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter", - "text": " dstBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-parameter", - "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-regionCount-arraylength", - "text": " regionCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-commonparent", - "text": " Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00185", - "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-01941", - "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01831", - "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01832", - "text": " If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer" - }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01833", - "text": " If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer" - } - ] - }, - "VkBufferImageCopy": { - "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkBufferImageCopy-bufferOffset-00193", - "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format, then bufferOffset must be a multiple of the format’s element size" - }, - { - "vuid": "VUID-VkBufferImageCopy-bufferRowLength-00203", - "text": " If the calling command’s VkImage parameter is a compressed image, bufferRowLength must be a multiple of the compressed texel block width" - }, - { - "vuid": "VUID-VkBufferImageCopy-bufferImageHeight-00204", - "text": " If the calling command’s VkImage parameter is a compressed image, bufferImageHeight must be a multiple of the compressed texel block height" - }, - { - "vuid": "VUID-VkBufferImageCopy-imageOffset-00205", - "text": " If the calling command’s VkImage parameter is a compressed image, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" - }, - { - "vuid": "VUID-VkBufferImageCopy-bufferOffset-00206", - "text": " If the calling command’s VkImage parameter is a compressed image, bufferOffset must be a multiple of the compressed texel block size in bytes" - }, - { - "vuid": "VUID-VkBufferImageCopy-imageExtent-00207", - "text": " If the calling command’s VkImage parameter is a compressed image, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width" - }, - { - "vuid": "VUID-VkBufferImageCopy-imageExtent-00208", - "text": " If the calling command’s VkImage parameter is a compressed image, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height" - }, - { - "vuid": "VUID-VkBufferImageCopy-imageExtent-00209", - "text": " If the calling command’s VkImage parameter is a compressed image, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkBufferImageCopy-bufferOffset-01558", - "text": " If the calling command’s VkImage parameter’s format is not a depth/stencil format or a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, then bufferOffset must be a multiple of the format’s element size" - }, - { - "vuid": "VUID-VkBufferImageCopy-bufferOffset-01559", - "text": " If the calling command’s VkImage parameter’s format is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, then bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in &amp;lt;&amp;lt;features-formats-compatible-planes&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-01735", - "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferRowLength must be a multiple of the compressed texel block width" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-01736", - "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferImageHeight must be a multiple of the compressed texel block height" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-01737", - "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-01738", - "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, bufferOffset must be a multiple of the compressed texel block size in bytes" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-01739", - "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the image subresource width" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-01740", - "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the image subresource height" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-01741", - "text": " If the calling command’s VkImage parameter is a compressed image, or a single-plane, “_422” image format, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the image subresource depth" - }, - { - "vuid": "VUID-VkBufferImageCopy-aspectMask-01560", - "text": " If the calling command’s VkImage parameter’s format is a &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion,multi-planar format&amp;gt;&amp;gt;, then the aspectMask member of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)" - } - ], - "core": [ - { - "vuid": "VUID-VkBufferImageCopy-bufferOffset-00194", - "text": " bufferOffset must be a multiple of 4" - }, - { - "vuid": "VUID-VkBufferImageCopy-bufferRowLength-00195", - "text": " bufferRowLength must be 0, or greater than or equal to the width member of imageExtent" - }, - { - "vuid": "VUID-VkBufferImageCopy-bufferImageHeight-00196", - "text": " bufferImageHeight must be 0, or greater than or equal to the height member of imageExtent" - }, - { - "vuid": "VUID-VkBufferImageCopy-imageOffset-00197", - "text": " imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the image subresource width" - }, - { - "vuid": "VUID-VkBufferImageCopy-imageOffset-00198", - "text": " imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the image subresource height" - }, - { - "vuid": "VUID-VkBufferImageCopy-srcImage-00199", - "text": " If the calling command’s srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D, then imageOffset.y must be 0 and imageExtent.height must be 1." - }, - { - "vuid": "VUID-VkBufferImageCopy-imageOffset-00200", - "text": " imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the image subresource depth" - }, - { - "vuid": "VUID-VkBufferImageCopy-srcImage-00201", - "text": " If the calling command’s srcImage (vkCmdCopyImageToBuffer) or dstImage (vkCmdCopyBufferToImage) is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then imageOffset.z must be 0 and imageExtent.depth must be 1" - }, - { - "vuid": "VUID-VkBufferImageCopy-aspectMask-00211", - "text": " The aspectMask member of imageSubresource must specify aspects present in the calling command’s VkImage parameter" - }, - { - "vuid": "VUID-VkBufferImageCopy-aspectMask-00212", - "text": " The aspectMask member of imageSubresource must only have a single bit set" - }, - { - "vuid": "VUID-VkBufferImageCopy-baseArrayLayer-00213", - "text": " If the calling command’s VkImage parameter is of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of imageSubresource must be 0 and 1, respectively" - }, - { - "vuid": "VUID-VkBufferImageCopy-None-00214", - "text": " When copying to the depth aspect of an image subresource, the data in the source buffer must be in the range [0,1]" - }, - { - "vuid": "VUID-VkBufferImageCopy-imageSubresource-parameter", - "text": " imageSubresource must be a valid VkImageSubresourceLayers structure" - } - ] - }, - "vkCmdBlitImage": { - "core": [ - { - "vuid": "VUID-vkCmdBlitImage-pRegions-00215", - "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" - }, - { - "vuid": "VUID-vkCmdBlitImage-pRegions-00216", - "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" - }, - { - "vuid": "VUID-vkCmdBlitImage-pRegions-00217", - "text": " The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00219", - "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00220", - "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImageLayout-00221", - "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImage-00224", - "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImage-00225", - "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImageLayout-00226", - "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00228", - "text": " The sample count of srcImage and dstImage must both be equal to VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00229", - "text": " If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00230", - "text": " If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00231", - "text": " If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00232", - "text": " If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00233", - "text": " srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImage-00234", - "text": " dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcSubresource-01705", - "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstSubresource-01706", - "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcSubresource-01707", - "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstSubresource-01708", - "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdBlitImage-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImage-parameter", - "text": " srcImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdBlitImage-srcImageLayout-parameter", - "text": " srcImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImage-parameter", - "text": " dstImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImageLayout-parameter", - "text": " dstImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdBlitImage-pRegions-parameter", - "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageBlit structures" - }, - { - "vuid": "VUID-vkCmdBlitImage-filter-parameter", - "text": " filter must be a valid VkFilter value" - }, - { - "vuid": "VUID-vkCmdBlitImage-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBlitImage-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdBlitImage-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdBlitImage-regionCount-arraylength", - "text": " regionCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdBlitImage-commonparent", - "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdBlitImage-srcImage-00218", - "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_BLIT_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImage-00223", - "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_BLIT_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - }, - { - "vuid": "VUID-vkCmdBlitImage-filter-00235", - "text": " If filter is VK_FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdBlitImage-srcImage-01942", - "text": " srcImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImage-01943", - "text": " dstImage must use a format that supports VK_FORMAT_FEATURE_TRANSFER_DST_BIT, which is indicated by VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - }, - { - "vuid": "VUID-vkCmdBlitImage-filter-01944", - "text": " If filter is VK_FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-vkCmdBlitImage-srcImage-01561", - "text": " srcImage must not use a format listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImage-01562", - "text": " dstImage must not use a format listed in &amp;lt;&amp;lt;features-formats-requiring-sampler-ycbcr-conversion&amp;gt;&amp;gt;" - } - ], - "!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdBlitImage-srcImageLayout-00222", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImageLayout-00227", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdBlitImage-srcImageLayout-01398", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-vkCmdBlitImage-dstImageLayout-01399", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdBlitImage-filter-00236", - "text": " If filter is VK_FILTER_CUBIC_IMG, srcImage must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdBlitImage-filter-01945", - "text": " If filter is VK_FILTER_CUBIC_IMG, srcImage must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned byvkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdBlitImage-filter-00237", - "text": " If filter is VK_FILTER_CUBIC_IMG, srcImage must have a VkImageType of VK_IMAGE_TYPE_2D" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdBlitImage-commandBuffer-01834", - "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdBlitImage-commandBuffer-01835", - "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdBlitImage-commandBuffer-01836", - "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" - } - ] - }, - "VkImageBlit": { - "core": [ - { - "vuid": "VUID-VkImageBlit-aspectMask-00238", - "text": " The aspectMask member of srcSubresource and dstSubresource must match" - }, - { - "vuid": "VUID-VkImageBlit-layerCount-00239", - "text": " The layerCount member of srcSubresource and dstSubresource must match" - }, - { - "vuid": "VUID-VkImageBlit-srcImage-00240", - "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively" - }, - { - "vuid": "VUID-VkImageBlit-aspectMask-00241", - "text": " The aspectMask member of srcSubresource must specify aspects present in the calling command’s srcImage" - }, - { - "vuid": "VUID-VkImageBlit-aspectMask-00242", - "text": " The aspectMask member of dstSubresource must specify aspects present in the calling command’s dstImage" - }, - { - "vuid": "VUID-VkImageBlit-srcOffset-00243", - "text": " srcOffset[0].x and srcOffset[1].x must both be greater than or equal to 0 and less than or equal to the source image subresource width" - }, - { - "vuid": "VUID-VkImageBlit-srcOffset-00244", - "text": " srcOffset[0].y and srcOffset[1].y must both be greater than or equal to 0 and less than or equal to the source image subresource height" - }, - { - "vuid": "VUID-VkImageBlit-srcImage-00245", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset[0].y must be 0 and srcOffset[1].y must be 1." - }, - { - "vuid": "VUID-VkImageBlit-srcOffset-00246", - "text": " srcOffset[0].z and srcOffset[1].z must both be greater than or equal to 0 and less than or equal to the source image subresource depth" - }, - { - "vuid": "VUID-VkImageBlit-srcImage-00247", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset[0].z must be 0 and srcOffset[1].z must be 1." - }, - { - "vuid": "VUID-VkImageBlit-dstOffset-00248", - "text": " dstOffset[0].x and dstOffset[1].x must both be greater than or equal to 0 and less than or equal to the destination image subresource width" - }, - { - "vuid": "VUID-VkImageBlit-dstOffset-00249", - "text": " dstOffset[0].y and dstOffset[1].y must both be greater than or equal to 0 and less than or equal to the destination image subresource height" - }, - { - "vuid": "VUID-VkImageBlit-dstImage-00250", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset[0].y must be 0 and dstOffset[1].y must be 1." - }, - { - "vuid": "VUID-VkImageBlit-dstOffset-00251", - "text": " dstOffset[0].z and dstOffset[1].z must both be greater than or equal to 0 and less than or equal to the destination image subresource depth" - }, - { - "vuid": "VUID-VkImageBlit-dstImage-00252", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset[0].z must be 0 and dstOffset[1].z must be 1." - }, - { - "vuid": "VUID-VkImageBlit-srcSubresource-parameter", - "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" - }, - { - "vuid": "VUID-VkImageBlit-dstSubresource-parameter", - "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" - } - ] - }, - "vkCmdResolveImage": { - "core": [ - { - "vuid": "VUID-vkCmdResolveImage-pRegions-00253", - "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" - }, - { - "vuid": "VUID-vkCmdResolveImage-pRegions-00254", - "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" - }, - { - "vuid": "VUID-vkCmdResolveImage-pRegions-00255", - "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcImage-00256", - "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcImage-00257", - "text": " srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImage-00258", - "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImage-00259", - "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcImageLayout-00260", - "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImageLayout-00262", - "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImage-00264", - "text": " If dstImage was created with tiling equal to VK_IMAGE_TILING_LINEAR, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImage-00265", - "text": " If dstImage was created with tiling equal to VK_IMAGE_TILING_OPTIMAL, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcImage-01386", - "text": " srcImage and dstImage must have been created with the same image format" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcSubresource-01709", - "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstSubresource-01710", - "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcSubresource-01711", - "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstSubresource-01712", - "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" - }, - { - "vuid": "VUID-vkCmdResolveImage-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcImage-parameter", - "text": " srcImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdResolveImage-srcImageLayout-parameter", - "text": " srcImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImage-parameter", - "text": " dstImage must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImageLayout-parameter", - "text": " dstImageLayout must be a valid VkImageLayout value" - }, - { - "vuid": "VUID-vkCmdResolveImage-pRegions-parameter", - "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageResolve structures" - }, - { - "vuid": "VUID-vkCmdResolveImage-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdResolveImage-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdResolveImage-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdResolveImage-regionCount-arraylength", - "text": " regionCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdResolveImage-commonparent", - "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdResolveImage-srcImageLayout-00261", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImageLayout-00263", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkCmdResolveImage-srcImageLayout-01400", - "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - }, - { - "vuid": "VUID-vkCmdResolveImage-dstImageLayout-01401", - "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdResolveImage-commandBuffer-01837", - "text": " If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdResolveImage-commandBuffer-01838", - "text": " If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image" - }, - { - "vuid": "VUID-vkCmdResolveImage-commandBuffer-01839", - "text": " If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image" - } - ] - }, - "VkImageResolve": { - "core": [ - { - "vuid": "VUID-VkImageResolve-aspectMask-00266", - "text": " The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT" - }, - { - "vuid": "VUID-VkImageResolve-layerCount-00267", - "text": " The layerCount member of srcSubresource and dstSubresource must match" - }, - { - "vuid": "VUID-VkImageResolve-srcImage-00268", - "text": " If either of the calling command’s srcImage or dstImage parameters are of VkImageType VK_IMAGE_TYPE_3D, the baseArrayLayer and layerCount members of both srcSubresource and dstSubresource must be 0 and 1, respectively" - }, - { - "vuid": "VUID-VkImageResolve-srcOffset-00269", - "text": " srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the source image subresource width" - }, - { - "vuid": "VUID-VkImageResolve-srcOffset-00270", - "text": " srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the source image subresource height" - }, - { - "vuid": "VUID-VkImageResolve-srcImage-00271", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D, then srcOffset.y must be 0 and extent.height must be 1." - }, - { - "vuid": "VUID-VkImageResolve-srcOffset-00272", - "text": " srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the source image subresource depth" - }, - { - "vuid": "VUID-VkImageResolve-srcImage-00273", - "text": " If the calling command’s srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then srcOffset.z must be 0 and extent.depth must be 1." - }, - { - "vuid": "VUID-VkImageResolve-dstOffset-00274", - "text": " dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the destination image subresource width" - }, - { - "vuid": "VUID-VkImageResolve-dstOffset-00275", - "text": " dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the destination image subresource height" - }, - { - "vuid": "VUID-VkImageResolve-dstImage-00276", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D, then dstOffset.y must be 0 and extent.height must be 1." - }, - { - "vuid": "VUID-VkImageResolve-dstOffset-00277", - "text": " dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the destination image subresource depth" - }, - { - "vuid": "VUID-VkImageResolve-dstImage-00278", - "text": " If the calling command’s dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then dstOffset.z must be 0 and extent.depth must be 1." - }, - { - "vuid": "VUID-VkImageResolve-srcSubresource-parameter", - "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" - }, - { - "vuid": "VUID-VkImageResolve-dstSubresource-parameter", - "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" - } - ] - }, - "vkCmdWriteBufferMarkerAMD": { - "(VK_AMD_buffer_marker)": [ - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798", - "text": " dstOffset must be less than or equal to the size of dstBuffer minus 4." - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799", - "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800", - "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801", - "text": " dstOffset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter", - "text": " pipelineStage must be a valid VkPipelineStageFlagBits value" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter", - "text": " dstBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdWriteBufferMarkerAMD-commonparent", - "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkPipelineInputAssemblyStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428", - "text": " If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, primitiveRestartEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429", - "text": " If the &amp;lt;&amp;lt;features-features-geometryShader,geometry shaders&amp;gt;&amp;gt; feature is not enabled, topology must not be any of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY" - }, - { - "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430", - "text": " If the &amp;lt;&amp;lt;features-features-tessellationShader,tessellation shaders&amp;gt;&amp;gt; feature is not enabled, topology must not be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST" - }, - { - "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter", - "text": " topology must be a valid VkPrimitiveTopology value" - } - ] - }, - "vkCmdBindIndexBuffer": { - "core": [ - { - "vuid": "VUID-vkCmdBindIndexBuffer-offset-00431", - "text": " offset must be less than the size of buffer" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-offset-00432", - "text": " The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-buffer-00433", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-buffer-00434", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-indexType-parameter", - "text": " indexType must be a valid VkIndexType value" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdBindIndexBuffer-commonparent", - "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCmdDraw": { - "core": [ - { - "vuid": "VUID-vkCmdDraw-renderPass-00435", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDraw-subpass-00436", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDraw-None-00437", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDraw-None-00438", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDraw-None-00439", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDraw-None-00440", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDraw-None-00441", - "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDraw-None-00442", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDraw-None-00443", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDraw-None-00444", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDraw-None-00445", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDraw-None-00446", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDraw-None-00447", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDraw-None-00448", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDraw-None-00449", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDraw-None-01499", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDraw-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDraw-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDraw-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDraw-renderpass", - "text": " This command must only be called inside of a render pass instance" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDraw-linearTilingFeatures-00450", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDraw-formatFeatures-01953", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDraw-linearTilingFeatures-00451", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDraw-formatFeatures-01954", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDraw-None-00452", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDraw-maxMultiviewInstanceIndex-00453", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDraw-commandBuffer-01850", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDraw-commandBuffer-01851", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDraw-commandBuffer-01852", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDraw-sampleLocationsEnable-01512", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "vkCmdDrawIndexed": { - "core": [ - { - "vuid": "VUID-vkCmdDrawIndexed-renderPass-00454", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexed-subpass-00455", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00456", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00457", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00458", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00459", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00460", - "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00461", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00462", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-indexSize-00463", - "text": " (indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00464", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00465", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00466", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00467", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00468", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-00469", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-01500", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-renderpass", - "text": " This command must only be called inside of a render pass instance" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-linearTilingFeatures-00470", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-formatFeatures-01955", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-linearTilingFeatures-00471", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-formatFeatures-01956", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-00472", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-00473", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-01853", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-01854", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-01855", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-sampleLocationsEnable-01513", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "vkCmdDrawIndirect": { - "core": [ - { - "vuid": "VUID-vkCmdDrawIndirect-buffer-00474", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-buffer-01660", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-offset-00475", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-drawCount-00476", - "text": " If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-drawCount-00477", - "text": " If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-firstInstance-00478", - "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-renderPass-00479", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndirect-subpass-00480", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00481", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00482", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00483", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00484", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00485", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00486", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-drawCount-00487", - "text": " If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-drawCount-00488", - "text": " If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-drawCount-00489", - "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00490", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00491", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00492", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00493", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00494", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-00495", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-01501", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-commonparent", - "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-linearTilingFeatures-00496", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-formatFeatures-01957", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-linearTilingFeatures-00497", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-formatFeatures-01958", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-00498", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-00499", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-01856", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-01857", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-01858", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-sampleLocationsEnable-01514", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "VkDrawIndirectCommand": { - "core": [ - { - "vuid": "VUID-VkDrawIndirectCommand-None-00500", - "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkDrawIndirectCommand-firstInstance-00501", - "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, firstInstance must be 0" - } - ] - }, - "vkCmdDrawIndirectCountKHR": { - "(VK_KHR_draw_indirect_count)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-buffer-03104", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-buffer-03105", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03106", - "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03107", - "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-offset-03108", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBufferOffset-03109", - "text": " countBufferOffset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-stride-03110", - "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-maxDrawCount-03111", - "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-firstInstance-03112", - "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-renderPass-03113", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-subpass-03114", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03115", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03116", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03117", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03118", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03119", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03120", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03121", - "text": " If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03122", - "text": " If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-03123", - "text": " The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03124", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03125", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03126", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03127", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03128", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03129", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-linearTilingFeatures-03130", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03131", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-countBuffer-parameter", - "text": " countBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-commonparent", - "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-linearTilingFeatures-03169", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-None-03170", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-maxMultiviewInstanceIndex-03132", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-03133", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-03134", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-03135", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountKHR-sampleLocationsEnable-03171", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "vkCmdDrawIndirectCountAMD": { - "(VK_AMD_draw_indirect_count)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-buffer-01661", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-buffer-01662", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-01663", - "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-01664", - "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-offset-00502", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBufferOffset-00503", - "text": " countBufferOffset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-stride-00504", - "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-maxDrawCount-00505", - "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-firstInstance-00506", - "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-renderPass-00507", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-subpass-00508", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00509", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00510", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00511", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00512", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00513", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00514", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-00515", - "text": " If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-00516", - "text": " If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-00517", - "text": " The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00518", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00519", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00520", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00521", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00522", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-00523", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-None-01502", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-countBuffer-parameter", - "text": " countBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-commonparent", - "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_AMD_draw_indirect_count)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-linearTilingFeatures-00524", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_AMD_draw_indirect_count)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-formatFeatures-01959", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-maxMultiviewInstanceIndex-00525", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01859", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01860", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-commandBuffer-01861", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_AMD_draw_indirect_count)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCountAMD-sampleLocationsEnable-01515", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "vkCmdDrawIndexedIndirect": { - "core": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-00526", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-01665", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-offset-00527", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00528", - "text": " If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00529", - "text": " If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-firstInstance-00530", - "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-renderPass-00531", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-subpass-00532", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00533", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00534", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00535", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00536", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00537", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00538", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00539", - "text": " If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00540", - "text": " If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00541", - "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00542", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00543", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00544", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00545", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00546", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00547", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-01503", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commonparent", - "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00548", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-formatFeatures-01960", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-linearTilingFeatures-00549", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-formatFeatures-01961", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-00550", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-00551", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-01862", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-01863", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-01864", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-01516", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "VkDrawIndexedIndirectCommand": { - "core": [ - { - "vuid": "VUID-VkDrawIndexedIndirectCommand-None-00552", - "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in &amp;lt;&amp;lt;fxvertex-input&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkDrawIndexedIndirectCommand-indexSize-00553", - "text": " (indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer" - }, - { - "vuid": "VUID-VkDrawIndexedIndirectCommand-firstInstance-00554", - "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, firstInstance must be 0" - } - ] - }, - "vkCmdDrawIndexedIndirectCountKHR": { - "(VK_KHR_draw_indirect_count)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-03136", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-03137", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03138", - "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03139", - "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-offset-03140", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBufferOffset-03141", - "text": " countBufferOffset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-stride-03142", - "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-maxDrawCount-03143", - "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-firstInstance-03144", - "text": " If the &amp;lt;&amp;lt;features-features-drawIndirectFirstInstance,drawIndirectFirstInstance&amp;gt;&amp;gt; feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-renderPass-03145", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-subpass-03146", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03147", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03148", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03149", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03150", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03151", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03152", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03153", - "text": " If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-03154", - "text": " If count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-drawCount-03155", - "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03156", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03157", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03158", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03159", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03160", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03161", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-linearTilingFeatures-03162", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03163", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-parameter", - "text": " countBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent", - "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-linearTilingFeatures-03172", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-None-03173", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-maxMultiviewInstanceIndex-03164", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-03165", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-03166", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-03167", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountKHR-sampleLocationsEnable-03174", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "vkCmdDrawIndexedIndirectCountAMD": { - "(VK_AMD_draw_indirect_count)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01666", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-01667", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01668", - "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-01669", - "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-offset-00555", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBufferOffset-00556", - "text": " countBufferOffset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-stride-00557", - "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-maxDrawCount-00558", - "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-firstInstance-00559", - "text": " If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-renderPass-00560", - "text": " The current render pass must be &amp;lt;&amp;lt;renderpass-compatibility,compatible&amp;gt;&amp;gt; with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-subpass-00561", - "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00562", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00563", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00564", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00565", - "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00566", - "text": " A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00567", - "text": " If the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00568", - "text": " If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-00569", - "text": " If count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-drawCount-00570", - "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00571", - "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00572", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00573", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00574", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00575", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-00576", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-None-01504", - "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-countBuffer-parameter", - "text": " countBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commonparent", - "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "(VK_AMD_draw_indirect_count)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-linearTilingFeatures-00577", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_AMD_draw_indirect_count)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-formatFeatures-01962", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-maxMultiviewInstanceIndex-00578", - "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex." - } - ], - "(VK_AMD_draw_indirect_count)+(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01865", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01866", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-commandBuffer-01867", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ], - "(VK_AMD_draw_indirect_count)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCountAMD-sampleLocationsEnable-01517", - "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" - } - ] - }, - "VkPipelineVertexInputStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613", - "text": " vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614", - "text": " vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-binding-00615", - "text": " For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription must exist in pVertexBindingDescriptions with the same value of binding" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616", - "text": " All elements of pVertexBindingDescriptions must describe distinct binding numbers" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617", - "text": " All elements of pVertexAttributeDescriptions must describe distinct attribute locations" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineVertexInputDivisorStateCreateInfoEXT" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter", - "text": " If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription structures" - }, - { - "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter", - "text": " If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription structures" - } - ] - }, - "VkVertexInputBindingDescription": { - "core": [ - { - "vuid": "VUID-VkVertexInputBindingDescription-binding-00618", - "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" - }, - { - "vuid": "VUID-VkVertexInputBindingDescription-stride-00619", - "text": " stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride" - }, - { - "vuid": "VUID-VkVertexInputBindingDescription-inputRate-parameter", - "text": " inputRate must be a valid VkVertexInputRate value" - } - ] - }, - "VkVertexInputAttributeDescription": { - "core": [ - { - "vuid": "VUID-VkVertexInputAttributeDescription-location-00620", - "text": " location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes" - }, - { - "vuid": "VUID-VkVertexInputAttributeDescription-binding-00621", - "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" - }, - { - "vuid": "VUID-VkVertexInputAttributeDescription-offset-00622", - "text": " offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset" - }, - { - "vuid": "VUID-VkVertexInputAttributeDescription-format-00623", - "text": " format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" - }, - { - "vuid": "VUID-VkVertexInputAttributeDescription-format-parameter", - "text": " format must be a valid VkFormat value" - } - ] - }, - "vkCmdBindVertexBuffers": { - "core": [ - { - "vuid": "VUID-vkCmdBindVertexBuffers-firstBinding-00624", - "text": " firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-firstBinding-00625", - "text": " The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-pOffsets-00626", - "text": " All elements of pOffsets must be less than the size of the corresponding element in pBuffers" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-00627", - "text": " All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-00628", - "text": " Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-parameter", - "text": " pBuffers must be a valid pointer to an array of bindingCount valid VkBuffer handles" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-pOffsets-parameter", - "text": " pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-bindingCount-arraylength", - "text": " bindingCount must be greater than 0" - }, - { - "vuid": "VUID-vkCmdBindVertexBuffers-commonparent", - "text": " Both of commandBuffer, and the elements of pBuffers must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkPipelineVertexInputDivisorStateCreateInfoEXT": { - "(VK_EXT_vertex_attribute_divisor)": [ - { - "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter", - "text": " pVertexBindingDivisors must be a valid pointer to an array of vertexBindingDivisorCount VkVertexInputBindingDivisorDescriptionEXT structures" - }, - { - "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength", - "text": " vertexBindingDivisorCount must be greater than 0" - } - ] - }, - "VkVertexInputBindingDivisorDescriptionEXT": { - "(VK_EXT_vertex_attribute_divisor)": [ - { - "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869", - "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" - }, - { - "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870", - "text": " divisor must be a value between 0 and VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive." - }, - { - "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871", - "text": " VkVertexInputBindingDescription::inputRate must be of type VK_VERTEX_INPUT_RATE_INSTANCE for this binding." - } - ] - }, - "VkPipelineTessellationStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214", - "text": " patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" - }, - { - "vuid": "VUID-VkPipelineTessellationStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineTessellationDomainOriginStateCreateInfo" - }, - { - "vuid": "VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "VkPipelineTessellationDomainOriginStateCreateInfo": { - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter", - "text": " domainOrigin must be a valid VkTessellationDomainOrigin value" - } - ] - }, - "VkPipelineViewportSwizzleStateCreateInfoNV": { - "(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215", - "text": " viewportCount must match the viewportCount set in VkPipelineViewportStateCreateInfo" - }, - { - "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV" - }, - { - "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-arraylength", - "text": " viewportCount must be greater than 0" - } - ] - }, - "VkViewportSwizzleNV": { - "(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-VkViewportSwizzleNV-x-parameter", - "text": " x must be a valid VkViewportCoordinateSwizzleNV value" - }, - { - "vuid": "VUID-VkViewportSwizzleNV-y-parameter", - "text": " y must be a valid VkViewportCoordinateSwizzleNV value" - }, - { - "vuid": "VUID-VkViewportSwizzleNV-z-parameter", - "text": " z must be a valid VkViewportCoordinateSwizzleNV value" - }, - { - "vuid": "VUID-VkViewportSwizzleNV-w-parameter", - "text": " w must be a valid VkViewportCoordinateSwizzleNV value" - } - ] - }, - "VkPipelineViewportWScalingStateCreateInfoNV": { - "(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV" - }, - { - "vuid": "VUID-VkPipelineViewportWScalingStateCreateInfoNV-viewportCount-arraylength", - "text": " viewportCount must be greater than 0" - } - ] - }, - "vkCmdSetViewportWScalingNV": { - "(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-None-01322", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-firstViewport-01323", - "text": " firstViewport must be less than VkPhysicalDeviceLimits::maxViewports" - }, - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-firstViewport-01324", - "text": " The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" - }, - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-pViewportWScalings-parameter", - "text": " pViewportWScalings must be a valid pointer to an array of viewportCount VkViewportWScalingNV structures" - }, - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdSetViewportWScalingNV-viewportCount-arraylength", - "text": " viewportCount must be greater than 0" - } - ] - }, - "VkPipelineViewportStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216", - "text": " If the multiple viewports feature is not enabled, viewportCount must be 1" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217", - "text": " If the multiple viewports feature is not enabled, scissorCount must be 1" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218", - "text": " viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219", - "text": " scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220", - "text": " scissorCount and viewportCount must be identical" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineViewportSwizzleStateCreateInfoNV or VkPipelineViewportWScalingStateCreateInfoNV" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength", - "text": " viewportCount must be greater than 0" - }, - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength", - "text": " scissorCount must be greater than 0" - } - ], - "(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726", - "text": " If the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure chained to the pNext chain is VK_TRUE, the viewportCount member of the VkPipelineViewportWScalingStateCreateInfoNV structure must be equal to viewportCount" - } - ] - }, - "vkCmdSetViewport": { - "core": [ - { - "vuid": "VUID-vkCmdSetViewport-None-01221", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetViewport-firstViewport-01222", - "text": " firstViewport must be less than VkPhysicalDeviceLimits::maxViewports" - }, - { - "vuid": "VUID-vkCmdSetViewport-firstViewport-01223", - "text": " The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" - }, - { - "vuid": "VUID-vkCmdSetViewport-firstViewport-01224", - "text": " If the multiple viewports feature is not enabled, firstViewport must be 0" - }, - { - "vuid": "VUID-vkCmdSetViewport-viewportCount-01225", - "text": " If the multiple viewports feature is not enabled, viewportCount must be 1" - }, - { - "vuid": "VUID-vkCmdSetViewport-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetViewport-pViewports-parameter", - "text": " pViewports must be a valid pointer to an array of viewportCount VkViewport structures" - }, - { - "vuid": "VUID-vkCmdSetViewport-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetViewport-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdSetViewport-viewportCount-arraylength", - "text": " viewportCount must be greater than 0" - } - ] - }, - "VkViewport": { - "core": [ - { - "vuid": "VUID-VkViewport-width-01770", - "text": " width must be greater than 0.0" - }, - { - "vuid": "VUID-VkViewport-width-01771", - "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]" - }, - { - "vuid": "VUID-VkViewport-height-01773", - "text": " The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]" - }, - { - "vuid": "VUID-VkViewport-x-01774", - "text": " x must be greater than or equal to viewportBoundsRange[0]" - }, - { - "vuid": "VUID-VkViewport-x-01232", - "text": " (x + width) must be less than or equal to viewportBoundsRange[1]" - }, - { - "vuid": "VUID-VkViewport-y-01775", - "text": " y must be greater than or equal to viewportBoundsRange[0]" - }, - { - "vuid": "VUID-VkViewport-y-01233", - "text": " (y + height) must be less than or equal to viewportBoundsRange[1]" - } - ], - "!(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)": [ - { - "vuid": "VUID-VkViewport-height-01772", - "text": " height must be greater than 0.0" - } - ], - "(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)": [ - { - "vuid": "VUID-VkViewport-y-01776", - "text": " y must be less than or equal to viewportBoundsRange[1]" - }, - { - "vuid": "VUID-VkViewport-y-01777", - "text": " (y + height) must be greater than or equal to viewportBoundsRange[0]" - } - ], - "(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-VkViewport-minDepth-01234", - "text": " Unless VK_EXT_depth_range_unrestricted extension is enabled minDepth must be between 0.0 and 1.0, inclusive" - }, - { - "vuid": "VUID-VkViewport-maxDepth-01235", - "text": " Unless VK_EXT_depth_range_unrestricted extension is enabled maxDepth must be between 0.0 and 1.0, inclusive" - } - ], - "!(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-VkViewport-minDepth-01234", - "text": " minDepth must be between 0.0 and 1.0, inclusive" - }, - { - "vuid": "VUID-VkViewport-maxDepth-01235", - "text": " maxDepth must be between 0.0 and 1.0, inclusive" - } - ] - }, - "VkPipelineRasterizationStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782", - "text": " If the &amp;lt;&amp;lt;features-features-depthClamp,depth clamping&amp;gt;&amp;gt; feature is not enabled, depthClampEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT or VkPipelineRasterizationStateRasterizationOrderAMD" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter", - "text": " polygonMode must be a valid VkPolygonMode value" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter", - "text": " cullMode must be a valid combination of VkCullModeFlagBits values" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter", - "text": " frontFace must be a valid VkFrontFace value" - } - ], - "!(VK_NV_fill_rectangle)": [ - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413", - "text": " If the &amp;lt;&amp;lt;features-features-fillModeNonSolid,non-solid fill modes&amp;gt;&amp;gt; feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL" - } - ], - "(VK_NV_fill_rectangle)": [ - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", - "text": " If the &amp;lt;&amp;lt;features-features-fillModeNonSolid,non-solid fill modes&amp;gt;&amp;gt; feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414", - "text": " If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV" - } - ] - }, - "VkPipelineMultisampleStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784", - "text": " If the &amp;lt;&amp;lt;features-features-sampleRateShading,sample rate shading&amp;gt;&amp;gt; feature is not enabled, sampleShadingEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785", - "text": " If the &amp;lt;&amp;lt;features-features-alphaToOne,alpha to one&amp;gt;&amp;gt; feature is not enabled, alphaToOneEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786", - "text": " minSampleShading must be in the range [0,1]" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, or VkPipelineSampleLocationsStateCreateInfoEXT" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter", - "text": " rasterizationSamples must be a valid VkSampleCountFlagBits value" - }, - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter", - "text": " If pSampleMask is not NULL, pSampleMask must be a valid pointer to an array of \\(\\lceil{\\mathit{rasterizationSamples} \\over 32}\\rceil\\) VkSampleMask values" - } - ], - "(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415", - "text": " If the subpass has any color attachments and rasterizationSamples is greater than the number of color samples, then sampleShadingEnable must be VK_FALSE" - } - ] - }, - "VkPipelineRasterizationStateRasterizationOrderAMD": { - "(VK_AMD_rasterization_order)": [ - { - "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD" - }, - { - "vuid": "VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter", - "text": " rasterizationOrder must be a valid VkRasterizationOrderAMD value" - } - ] - }, - "VkPipelineSampleLocationsStateCreateInfoEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter", - "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" - } - ] - }, - "VkSampleLocationsInfoEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526", - "text": " sampleLocationsPerPixel must be a bit value that is set in VkPhysicalDeviceSampleLocationsPropertiesEXT::sampleLocationSampleCounts" - }, - { - "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527", - "text": " sampleLocationsCount must equal sampleLocationsPerPixel {times} sampleLocationGridSize.width {times} sampleLocationGridSize.height" - }, - { - "vuid": "VUID-VkSampleLocationsInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT" - }, - { - "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter", - "text": " sampleLocationsPerPixel must be a valid VkSampleCountFlagBits value" - }, - { - "vuid": "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter", - "text": " pSampleLocations must be a valid pointer to an array of sampleLocationsCount VkSampleLocationEXT structures" - }, - { - "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-arraylength", - "text": " sampleLocationsCount must be greater than 0" - } - ] - }, - "vkCmdSetSampleLocationsEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdSetSampleLocationsEXT-None-01528", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529", - "text": " The sampleLocationsPerPixel member of pSampleLocationsInfo must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" - }, - { - "vuid": "VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530", - "text": " If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE then the current render pass must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sample locations state pointed to by pSampleLocationsInfo" - }, - { - "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter", - "text": " pSampleLocationsInfo must be a valid pointer to a valid VkSampleLocationsInfoEXT structure" - }, - { - "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ] - }, - "vkCmdSetLineWidth": { - "core": [ - { - "vuid": "VUID-vkCmdSetLineWidth-None-00787", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetLineWidth-lineWidth-00788", - "text": " If the wide lines feature is not enabled, lineWidth must be 1.0" - }, - { - "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ] - }, - "vkCmdSetDepthBias": { - "core": [ - { - "vuid": "VUID-vkCmdSetDepthBias-None-00789", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetDepthBias-depthBiasClamp-00790", - "text": " If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0" - }, - { - "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ] - }, - "VkPipelineRasterizationConservativeStateCreateInfoEXT": { - "(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769", - "text": " extraPrimitiveOverestimationSize must be in the range of 0.0 to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive" - }, - { - "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter", - "text": " conservativeRasterizationMode must be a valid VkConservativeRasterizationModeEXT value" - } - ] - }, - "VkPipelineDiscardRectangleStateCreateInfoEXT": { - "(VK_EXT_discard_rectangles)": [ - { - "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582", - "text": " discardRectangleCount must be between 0 and VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles, inclusive" - }, - { - "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter", - "text": " discardRectangleMode must be a valid VkDiscardRectangleModeEXT value" - } - ] - }, - "vkCmdSetDiscardRectangleEXT": { - "(VK_EXT_discard_rectangles)": [ - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-None-00583", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585", - "text": " The sum of firstDiscardRectangle and discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-x-00587", - "text": " The x and y member of offset in each VkRect2D element of pDiscardRectangles must be greater than or equal to 0" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-offset-00588", - "text": " Evaluation of (offset.x + extent.width) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-offset-00589", - "text": " Evaluation of (offset.y + extent.height) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter", - "text": " pDiscardRectangles must be a valid pointer to an array of discardRectangleCount VkRect2D structures" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength", - "text": " discardRectangleCount must be greater than 0" - } - ] - }, - "vkCmdSetScissor": { - "core": [ - { - "vuid": "VUID-vkCmdSetScissor-None-00590", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetScissor-firstScissor-00591", - "text": " firstScissor must be less than VkPhysicalDeviceLimits::maxViewports" - }, - { - "vuid": "VUID-vkCmdSetScissor-firstScissor-00592", - "text": " The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" - }, - { - "vuid": "VUID-vkCmdSetScissor-firstScissor-00593", - "text": " If the multiple viewports feature is not enabled, firstScissor must be 0" - }, - { - "vuid": "VUID-vkCmdSetScissor-scissorCount-00594", - "text": " If the multiple viewports feature is not enabled, scissorCount must be 1" - }, - { - "vuid": "VUID-vkCmdSetScissor-x-00595", - "text": " The x and y members of offset must be greater than or equal to 0" - }, - { - "vuid": "VUID-vkCmdSetScissor-offset-00596", - "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow" - }, - { - "vuid": "VUID-vkCmdSetScissor-offset-00597", - "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow" - }, - { - "vuid": "VUID-vkCmdSetScissor-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetScissor-pScissors-parameter", - "text": " pScissors must be a valid pointer to an array of scissorCount VkRect2D structures" - }, - { - "vuid": "VUID-vkCmdSetScissor-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetScissor-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - }, - { - "vuid": "VUID-vkCmdSetScissor-scissorCount-arraylength", - "text": " scissorCount must be greater than 0" - } - ] - }, - "VkPipelineDepthStencilStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598", - "text": " If the &amp;lt;&amp;lt;features-features-depthBounds,depth bounds testing&amp;gt;&amp;gt; feature is not enabled, depthBoundsTestEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter", - "text": " depthCompareOp must be a valid VkCompareOp value" - }, - { - "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter", - "text": " front must be a valid VkStencilOpState structure" - }, - { - "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter", - "text": " back must be a valid VkStencilOpState structure" - } - ] - }, - "vkCmdSetDepthBounds": { - "core": [ - { - "vuid": "VUID-vkCmdSetDepthBounds-None-00599", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ], - "(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-00600", - "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds must be between 0.0 and 1.0, inclusive" - }, - { - "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-00601", - "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled maxDepthBounds must be between 0.0 and 1.0, inclusive" - } - ], - "!(VK_EXT_depth_range_unrestricted)": [ - { - "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-00600", - "text": " minDepthBounds must be between 0.0 and 1.0, inclusive" - }, - { - "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-00601", - "text": " maxDepthBounds must be between 0.0 and 1.0, inclusive" - } - ] - }, - "VkStencilOpState": { - "core": [ - { - "vuid": "VUID-VkStencilOpState-failOp-parameter", - "text": " failOp must be a valid VkStencilOp value" - }, - { - "vuid": "VUID-VkStencilOpState-passOp-parameter", - "text": " passOp must be a valid VkStencilOp value" - }, - { - "vuid": "VUID-VkStencilOpState-depthFailOp-parameter", - "text": " depthFailOp must be a valid VkStencilOp value" - }, - { - "vuid": "VUID-VkStencilOpState-compareOp-parameter", - "text": " compareOp must be a valid VkCompareOp value" - } - ] - }, - "vkCmdSetStencilCompareMask": { - "core": [ - { - "vuid": "VUID-vkCmdSetStencilCompareMask-None-00602", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetStencilCompareMask-faceMask-parameter", - "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" - }, - { - "vuid": "VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask", - "text": " faceMask must not be 0" - }, - { - "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ] - }, - "vkCmdSetStencilWriteMask": { - "core": [ - { - "vuid": "VUID-vkCmdSetStencilWriteMask-None-00603", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetStencilWriteMask-faceMask-parameter", - "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" - }, - { - "vuid": "VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask", - "text": " faceMask must not be 0" - }, - { - "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ] - }, - "vkCmdSetStencilReference": { - "core": [ - { - "vuid": "VUID-vkCmdSetStencilReference-None-00604", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetStencilReference-faceMask-parameter", - "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" - }, - { - "vuid": "VUID-vkCmdSetStencilReference-faceMask-requiredbitmask", - "text": " faceMask must not be 0" - }, - { - "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ] - }, - "VkPipelineCoverageToColorStateCreateInfoNV": { - "(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404", - "text": " If coverageToColorEnable is VK_TRUE, then the render pass subpass indicated by VkGraphicsPipelineCreateInfo::renderPass and VkGraphicsPipelineCreateInfo::subpass must have a color attachment at the location selected by coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - }, - { - "vuid": "VUID-VkPipelineCoverageToColorStateCreateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV" - }, - { - "vuid": "VUID-VkPipelineCoverageToColorStateCreateInfoNV-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "VkPipelineCoverageModulationStateCreateInfoNV": { - "(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405", - "text": " If coverageModulationTableEnable is VK_TRUE, coverageModulationTableCount must be equal to the number of rasterization samples divided by the number of color samples in the subpass." - }, - { - "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV" - }, - { - "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter", - "text": " coverageModulationMode must be a valid VkCoverageModulationModeNV value" - }, - { - "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableCount-arraylength", - "text": " coverageModulationTableCount must be greater than 0" - } - ] - }, - "VkPipelineColorBlendStateCreateInfo": { - "core": [ - { - "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605", - "text": " If the &amp;lt;&amp;lt;features-features-independentBlend,independent blending&amp;gt;&amp;gt; feature is not enabled, all elements of pAttachments must be identical" - }, - { - "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606", - "text": " If the &amp;lt;&amp;lt;features-features-logicOp,logic operations&amp;gt;&amp;gt; feature is not enabled, logicOpEnable must be VK_FALSE" - }, - { - "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607", - "text": " If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value" - }, - { - "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO" - }, - { - "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT" - }, - { - "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter", - "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures" - } - ] - }, - "VkPipelineColorBlendAttachmentState": { - "core": [ - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608", - "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609", - "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, dstColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610", - "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, srcAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611", - "text": " If the &amp;lt;&amp;lt;features-features-dualSrcBlend,dual source blending&amp;gt;&amp;gt; feature is not enabled, dstAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter", - "text": " srcColorBlendFactor must be a valid VkBlendFactor value" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter", - "text": " dstColorBlendFactor must be a valid VkBlendFactor value" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter", - "text": " colorBlendOp must be a valid VkBlendOp value" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter", - "text": " srcAlphaBlendFactor must be a valid VkBlendFactor value" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter", - "text": " dstAlphaBlendFactor must be a valid VkBlendFactor value" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter", - "text": " alphaBlendOp must be a valid VkBlendOp value" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter", - "text": " colorWriteMask must be a valid combination of VkColorComponentFlagBits values" - } - ], - "(VK_EXT_blend_operation_advanced)": [ - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406", - "text": " If either of colorBlendOp or alphaBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then colorBlendOp must equal alphaBlendOp" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407", - "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and colorBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then colorBlendOp must be the same for all attachments." - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408", - "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and alphaBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then alphaBlendOp must be the same for all attachments." - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409", - "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendAllOperations is VK_FALSE, then colorBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT" - }, - { - "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410", - "text": " If colorBlendOp or alphaBlendOp is an &amp;lt;&amp;lt;framebuffer-blend-advanced,advanced blend operation&amp;gt;&amp;gt;, then VkSubpassDescription::colorAttachmentCount of the subpass this pipeline is compiled against must be less than or equal to VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendMaxColorAttachments" - } - ] - }, - "vkCmdSetBlendConstants": { - "core": [ - { - "vuid": "VUID-vkCmdSetBlendConstants-None-00612", - "text": " The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_BLEND_CONSTANTS dynamic state enabled" - }, - { - "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" - } - ] - }, - "VkPipelineColorBlendAdvancedStateCreateInfoEXT": { - "(VK_EXT_blend_operation_advanced)": [ - { - "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424", - "text": " If the &amp;lt;&amp;lt;features-limits-advancedBlendNonPremultipliedSrcColor,non-premultiplied source color&amp;gt;&amp;gt; property is not supported, srcPremultiplied must be VK_TRUE" - }, - { - "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425", - "text": " If the &amp;lt;&amp;lt;features-limits-advancedBlendNonPremultipliedDstColor,non-premultiplied destination color&amp;gt;&amp;gt; property is not supported, dstPremultiplied must be VK_TRUE" - }, - { - "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426", - "text": " If the &amp;lt;&amp;lt;features-limits-advancedBlendCorrelatedOverlap,correlated overlap&amp;gt;&amp;gt; property is not supported, blendOverlap must be VK_BLEND_OVERLAP_UNCORRELATED_EXT" - }, - { - "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter", - "text": " blendOverlap must be a valid VkBlendOverlapEXT value" - } - ] - }, - "vkCmdDispatch": { - "core": [ - { - "vuid": "VUID-vkCmdDispatch-groupCountX-00386", - "text": " groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" - }, - { - "vuid": "VUID-vkCmdDispatch-groupCountY-00387", - "text": " groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" - }, - { - "vuid": "VUID-vkCmdDispatch-groupCountZ-00388", - "text": " groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00389", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00390", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00391", - "text": " A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00392", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00393", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00394", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00395", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00396", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDispatch-None-00397", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDispatch-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDispatch-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDispatch-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" - }, - { - "vuid": "VUID-vkCmdDispatch-renderpass", - "text": " This command must only be called outside of a render pass instance" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatch-linearTilingFeatures-00398", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatch-formatFeatures-01949", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatch-linearTilingFeatures-00399", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatch-formatFeatures-01950", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDispatch-None-00400", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDispatch-commandBuffer-01844", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDispatch-commandBuffer-01845", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDispatch-commandBuffer-01846", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ] - }, - "vkCmdDispatchIndirect": { - "core": [ - { - "vuid": "VUID-vkCmdDispatchIndirect-buffer-00401", - "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00402", - "text": " For each set n that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00403", - "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the bound VkPipeline object, specified via vkCmdBindPipeline" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00404", - "text": " A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-buffer-00405", - "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-offset-00406", - "text": " offset must be a multiple of 4" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-offset-00407", - "text": " The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00408", - "text": " For each push constant that is statically used by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in &amp;lt;&amp;lt;descriptorsets-compatibility&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00409", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00410", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00411", - "text": " If any VkSampler object that is accessed from a shader by the VkPipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00412", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00413", - "text": " If the &amp;lt;&amp;lt;features-features-robustBufferAccess,robust buffer access&amp;gt;&amp;gt; feature is not enabled, and any shader stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the bound descriptor set" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-renderpass", - "text": " This command must only be called outside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-commonparent", - "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" - } - ], - "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatchIndirect-linearTilingFeatures-00414", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatchIndirect-formatFeatures-01951", - "text": " Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatchIndirect-linearTilingFeatures-00415", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkCmdDispatchIndirect-formatFeatures-01952", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must be of a format which supports cubic filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG flag in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures returned by vkGetAndroidHardwareBufferPropertiesANDROID for external format images, or by VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties for non-external format linearly or optimally tiled images, respectively" - } - ], - "(VK_IMG_filter_cubic)": [ - { - "vuid": "VUID-vkCmdDispatchIndirect-None-00416", - "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" - } - ], - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-01847", - "text": " If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer." - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-01848", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer." - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-01849", - "text": " If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer." - } - ] - }, - "VkDispatchIndirectCommand": { - "core": [ - { - "vuid": "VUID-VkDispatchIndirectCommand-x-00417", - "text": " x must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" - }, - { - "vuid": "VUID-VkDispatchIndirectCommand-y-00418", - "text": " y must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" - }, - { - "vuid": "VUID-VkDispatchIndirectCommand-z-00419", - "text": " z must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" - } - ] - }, - "vkCmdDispatchBase": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkCmdDispatchBase-None-00420", - "text": " All valid usage rules from vkCmdDispatch apply" - }, - { - "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00421", - "text": " baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" - }, - { - "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00422", - "text": " baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" - }, - { - "vuid": "VUID-vkCmdDispatchBase-baseGroupZ-00423", - "text": " baseGroupZ must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" - }, - { - "vuid": "VUID-vkCmdDispatchBase-groupCountX-00424", - "text": " groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] minus baseGroupX" - }, - { - "vuid": "VUID-vkCmdDispatchBase-groupCountY-00425", - "text": " groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] minus baseGroupY" - }, - { - "vuid": "VUID-vkCmdDispatchBase-groupCountZ-00426", - "text": " groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] minus baseGroupZ" - }, - { - "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00427", - "text": " If any of baseGroupX, baseGroupY, or baseGroupZ are not zero, then the bound compute pipeline must have been created with the VK_PIPELINE_CREATE_DISPATCH_BASE flag." - }, - { - "vuid": "VUID-vkCmdDispatchBase-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDispatchBase-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDispatchBase-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" - }, - { - "vuid": "VUID-vkCmdDispatchBase-renderpass", - "text": " This command must only be called outside of a render pass instance" - } - ] - }, - "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pFeatures-parameter", - "text": " pFeatures must be a valid pointer to a VkDeviceGeneratedCommandsFeaturesNVX structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-pLimits-parameter", - "text": " pLimits must be a valid pointer to a VkDeviceGeneratedCommandsLimitsNVX structure" - } - ] - }, - "VkDeviceGeneratedCommandsFeaturesNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkDeviceGeneratedCommandsFeaturesNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX" - }, - { - "vuid": "VUID-VkDeviceGeneratedCommandsFeaturesNVX-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "VkDeviceGeneratedCommandsLimitsNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkDeviceGeneratedCommandsLimitsNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX" - }, - { - "vuid": "VUID-VkDeviceGeneratedCommandsLimitsNVX-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkCreateObjectTableNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkCreateObjectTableNVX-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateObjectTableNVX-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkObjectTableCreateInfoNVX structure" - }, - { - "vuid": "VUID-vkCreateObjectTableNVX-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateObjectTableNVX-pObjectTable-parameter", - "text": " pObjectTable must be a valid pointer to a VkObjectTableNVX handle" - } - ] - }, - "VkObjectTableCreateInfoNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-computeBindingPointSupport-01355", - "text": " If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, pObjectEntryUsageFlags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-01356", - "text": " Any value within pObjectEntryCounts must not exceed VkDeviceGeneratedCommandsLimitsNVX::maxObjectEntryCounts" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-maxUniformBuffersPerDescriptor-01357", - "text": " maxUniformBuffersPerDescriptor must be within the limits supported by the device." - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-maxStorageBuffersPerDescriptor-01358", - "text": " maxStorageBuffersPerDescriptor must be within the limits supported by the device." - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-maxStorageImagesPerDescriptor-01359", - "text": " maxStorageImagesPerDescriptor must be within the limits supported by the device." - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-maxSampledImagesPerDescriptor-01360", - "text": " maxSampledImagesPerDescriptor must be within the limits supported by the device." - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryTypes-parameter", - "text": " pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryCounts-parameter", - "text": " pObjectEntryCounts must be a valid pointer to an array of objectCount uint32_t values" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-parameter", - "text": " pObjectEntryUsageFlags must be a valid pointer to an array of objectCount valid combinations of VkObjectEntryUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-pObjectEntryUsageFlags-requiredbitmask", - "text": " Each element of pObjectEntryUsageFlags must not be 0" - }, - { - "vuid": "VUID-VkObjectTableCreateInfoNVX-objectCount-arraylength", - "text": " objectCount must be greater than 0" - } - ] - }, - "vkDestroyObjectTableNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-01361", - "text": " All submitted commands that refer to objectTable must have completed execution." - }, - { - "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-01362", - "text": " If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here." - }, - { - "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-01363", - "text": " If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL." - }, - { - "vuid": "VUID-vkDestroyObjectTableNVX-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-parameter", - "text": " objectTable must be a valid VkObjectTableNVX handle" - }, - { - "vuid": "VUID-vkDestroyObjectTableNVX-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyObjectTableNVX-objectTable-parent", - "text": " objectTable must have been created, allocated, or retrieved from device" - } - ] - }, - "vkRegisterObjectsNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkRegisterObjectsNVX-pObjectTableEntry-01364", - "text": " The contents of pObjectTableEntry must yield plausible bindings supported by the device." - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-pObjectIndices-01365", - "text": " At any pObjectIndices there must not be a registered resource already." - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-pObjectIndices-01366", - "text": " Any value inside pObjectIndices must be below the appropriate VkObjectTableCreateInfoNVX::pObjectEntryCounts limits provided at objectTable creation time." - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-objectTable-parameter", - "text": " objectTable must be a valid VkObjectTableNVX handle" - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-ppObjectTableEntries-parameter", - "text": " ppObjectTableEntries must be a valid pointer to an array of objectCount valid VkObjectTableEntryNVX structures" - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-pObjectIndices-parameter", - "text": " pObjectIndices must be a valid pointer to an array of objectCount uint32_t values" - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-objectCount-arraylength", - "text": " objectCount must be greater than 0" - }, - { - "vuid": "VUID-vkRegisterObjectsNVX-objectTable-parent", - "text": " objectTable must have been created, allocated, or retrieved from device" - } - ] - }, - "VkObjectTableEntryNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkObjectTableEntryNVX-computeBindingPointSupport-01367", - "text": " If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, flags must not contain VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX" - }, - { - "vuid": "VUID-VkObjectTableEntryNVX-type-parameter", - "text": " type must be a valid VkObjectEntryTypeNVX value" - }, - { - "vuid": "VUID-VkObjectTableEntryNVX-flags-parameter", - "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkObjectTableEntryNVX-flags-requiredbitmask", - "text": " flags must not be 0" - } - ] - }, - "VkObjectTablePipelineEntryNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkObjectTablePipelineEntryNVX-type-01368", - "text": " type must be VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX" - }, - { - "vuid": "VUID-VkObjectTablePipelineEntryNVX-type-parameter", - "text": " type must be a valid VkObjectEntryTypeNVX value" - }, - { - "vuid": "VUID-VkObjectTablePipelineEntryNVX-flags-parameter", - "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkObjectTablePipelineEntryNVX-flags-requiredbitmask", - "text": " flags must not be 0" - }, - { - "vuid": "VUID-VkObjectTablePipelineEntryNVX-pipeline-parameter", - "text": " pipeline must be a valid VkPipeline handle" - } - ] - }, - "VkObjectTableDescriptorSetEntryNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-type-01369", - "text": " type must be VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX" - }, - { - "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-type-parameter", - "text": " type must be a valid VkObjectEntryTypeNVX value" - }, - { - "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-flags-parameter", - "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-flags-requiredbitmask", - "text": " flags must not be 0" - }, - { - "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-pipelineLayout-parameter", - "text": " pipelineLayout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-descriptorSet-parameter", - "text": " descriptorSet must be a valid VkDescriptorSet handle" - }, - { - "vuid": "VUID-VkObjectTableDescriptorSetEntryNVX-commonparent", - "text": " Both of descriptorSet, and pipelineLayout must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkObjectTableVertexBufferEntryNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-type-01370", - "text": " type must be VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX" - }, - { - "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-type-parameter", - "text": " type must be a valid VkObjectEntryTypeNVX value" - }, - { - "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-flags-parameter", - "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-flags-requiredbitmask", - "text": " flags must not be 0" - }, - { - "vuid": "VUID-VkObjectTableVertexBufferEntryNVX-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - } - ] - }, - "VkObjectTableIndexBufferEntryNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-type-01371", - "text": " type must be VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX" - }, - { - "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-type-parameter", - "text": " type must be a valid VkObjectEntryTypeNVX value" - }, - { - "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter", - "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask", - "text": " flags must not be 0" - }, - { - "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter", - "text": " indexType must be a valid VkIndexType value" - } - ] - }, - "VkObjectTablePushConstantEntryNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkObjectTablePushConstantEntryNVX-type-01372", - "text": " type must be VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX" - }, - { - "vuid": "VUID-VkObjectTablePushConstantEntryNVX-type-parameter", - "text": " type must be a valid VkObjectEntryTypeNVX value" - }, - { - "vuid": "VUID-VkObjectTablePushConstantEntryNVX-flags-parameter", - "text": " flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkObjectTablePushConstantEntryNVX-flags-requiredbitmask", - "text": " flags must not be 0" - }, - { - "vuid": "VUID-VkObjectTablePushConstantEntryNVX-pipelineLayout-parameter", - "text": " pipelineLayout must be a valid VkPipelineLayout handle" - }, - { - "vuid": "VUID-VkObjectTablePushConstantEntryNVX-stageFlags-parameter", - "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" - }, - { - "vuid": "VUID-VkObjectTablePushConstantEntryNVX-stageFlags-requiredbitmask", - "text": " stageFlags must not be 0" - } - ] - }, - "vkUnregisterObjectsNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkUnregisterObjectsNVX-pObjectIndices-01373", - "text": " At any pObjectIndices there must be a registered resource already." - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-01374", - "text": " The pObjectEntryTypes of the resource at pObjectIndices must match." - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-None-01375", - "text": " All operations on the device using the registered resource must have been completed." - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-objectTable-parameter", - "text": " objectTable must be a valid VkObjectTableNVX handle" - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-pObjectEntryTypes-parameter", - "text": " pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values" - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-pObjectIndices-parameter", - "text": " pObjectIndices must be a valid pointer to an array of objectCount uint32_t values" - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-objectCount-arraylength", - "text": " objectCount must be greater than 0" - }, - { - "vuid": "VUID-vkUnregisterObjectsNVX-objectTable-parent", - "text": " objectTable must have been created, allocated, or retrieved from device" - } - ] - }, - "VkIndirectCommandsLayoutTokenNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-bindingUnit-01342", - "text": " bindingUnit must stay within device supported limits for the appropriate commands." - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-dynamicCount-01343", - "text": " dynamicCount must stay within device supported limits for the appropriate commands." - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-divisor-01344", - "text": " divisor must be greater than 0 and a power of two." - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutTokenNVX-tokenType-parameter", - "text": " tokenType must be a valid VkIndirectCommandsTokenTypeNVX value" - } - ] - }, - "VkIndirectCommandsTokenNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkIndirectCommandsTokenNVX-buffer-01345", - "text": " The buffer’s usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set." - }, - { - "vuid": "VUID-VkIndirectCommandsTokenNVX-offset-01346", - "text": " The offset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minCommandsTokenBufferOffsetAlignment." - }, - { - "vuid": "VUID-VkIndirectCommandsTokenNVX-tokenType-parameter", - "text": " tokenType must be a valid VkIndirectCommandsTokenTypeNVX value" - }, - { - "vuid": "VUID-VkIndirectCommandsTokenNVX-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - } - ] - }, - "vkCreateIndirectCommandsLayoutNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkIndirectCommandsLayoutCreateInfoNVX structure" - }, - { - "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateIndirectCommandsLayoutNVX-pIndirectCommandsLayout-parameter", - "text": " pIndirectCommandsLayout must be a valid pointer to a VkIndirectCommandsLayoutNVX handle" - } - ] - }, - "VkIndirectCommandsLayoutCreateInfoNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347", - "text": " tokenCount must be greater than 0 and below VkDeviceGeneratedCommandsLimitsNVX::maxIndirectCommandsLayoutTokenCount" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348", - "text": " If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, then pipelineBindPoint must not be VK_PIPELINE_BIND_POINT_COMPUTE" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349", - "text": " If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX it must be the first element of the array and there must be only a single element of such token type." - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01350", - "text": " All state binding tokens in pTokens must occur prior work provoking tokens (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX)." - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01351", - "text": " The content of pTokens must include one single work provoking token that is compatible with the pipelineBindPoint." - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter", - "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter", - "text": " flags must be a valid combination of VkIndirectCommandsLayoutUsageFlagBitsNVX values" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask", - "text": " flags must not be 0" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter", - "text": " pTokens must be a valid pointer to an array of tokenCount valid VkIndirectCommandsLayoutTokenNVX structures" - }, - { - "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength", - "text": " tokenCount must be greater than 0" - } - ] - }, - "vkDestroyIndirectCommandsLayoutNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-01352", - "text": " All submitted commands that refer to indirectCommandsLayout must have completed execution" - }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01353", - "text": " If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-objectTable-01354", - "text": " If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter", - "text": " indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle" - }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent", - "text": " indirectCommandsLayout must have been created, allocated, or retrieved from device" - } - ] - }, - "vkCmdReserveSpaceForCommandsNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01329", - "text": " The provided commandBuffer must not have had a prior space reservation since its creation or the last reset." - }, - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-01330", - "text": " The state of the commandBuffer must be legal to execute all commands within the sequence provided by the indirectCommandsLayout member of pProcessCommandsInfo." - }, - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-pReserveSpaceInfo-parameter", - "text": " pReserveSpaceInfo must be a valid pointer to a valid VkCmdReserveSpaceForCommandsInfoNVX structure" - }, - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-renderpass", - "text": " This command must only be called inside of a render pass instance" - }, - { - "vuid": "VUID-vkCmdReserveSpaceForCommandsNVX-bufferlevel", - "text": " commandBuffer must be a secondary VkCommandBuffer" - } - ] - }, - "VkCmdReserveSpaceForCommandsInfoNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX" - }, - { - "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter", - "text": " objectTable must be a valid VkObjectTableNVX handle" - }, - { - "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter", - "text": " indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle" - }, - { - "vuid": "VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent", - "text": " Both of indirectCommandsLayout, and objectTable must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkCmdProcessCommandsNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdProcessCommandsNVX-pProcessCommandsInfo-parameter", - "text": " pProcessCommandsInfo must be a valid pointer to a valid VkCmdProcessCommandsInfoNVX structure" - }, - { - "vuid": "VUID-vkCmdProcessCommandsNVX-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdProcessCommandsNVX-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - }, - { - "vuid": "VUID-vkCmdProcessCommandsNVX-renderpass", - "text": " This command must only be called inside of a render pass instance" - } - ] - }, - "VkCmdProcessCommandsInfoNVX": { - "(VK_NVX_device_generated_commands)": [ - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-objectTable-01331", - "text": " The provided objectTable must include all objects referenced by the generation process." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-01332", - "text": " indirectCommandsTokenCount must match the indirectCommandsLayout’s tokenCount." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-tokenType-01333", - "text": " The tokenType member of each entry in the pIndirectCommandsTokens array must match the values used at creation time of indirectCommandsLayout" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01334", - "text": " If targetCommandBuffer is provided, it must have reserved command space." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01335", - "text": " If targetCommandBuffer is provided, the objectTable must match the reservation’s objectTable and must have had all referenced objects registered at reservation time." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01336", - "text": " If targetCommandBuffer is provided, the indirectCommandsLayout must match the reservation’s indirectCommandsLayout." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-01337", - "text": " If targetCommandBuffer is provided, the maxSequencesCount must not exceed the reservation’s maxSequencesCount." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01338", - "text": " If sequencesCountBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-01339", - "text": " If sequencesCountBuffer is used, sequencesCountOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceCountBufferOffsetAlignment." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01340", - "text": " If sequencesIndexBuffer is used, its usage flag must have VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-01341", - "text": " If sequencesIndexBuffer is used, sequencesIndexOffset must be aligned to VkDeviceGeneratedCommandsLimitsNVX::minSequenceIndexBufferOffsetAlignment." - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter", - "text": " objectTable must be a valid VkObjectTableNVX handle" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter", - "text": " indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-pIndirectCommandsTokens-parameter", - "text": " pIndirectCommandsTokens must be a valid pointer to an array of indirectCommandsTokenCount valid VkIndirectCommandsTokenNVX structures" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter", - "text": " If targetCommandBuffer is not NULL, targetCommandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter", - "text": " If sequencesCountBuffer is not VK_NULL_HANDLE, sequencesCountBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter", - "text": " If sequencesIndexBuffer is not VK_NULL_HANDLE, sequencesIndexBuffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsTokenCount-arraylength", - "text": " indirectCommandsTokenCount must be greater than 0" - }, - { - "vuid": "VUID-VkCmdProcessCommandsInfoNVX-commonparent", - "text": " Each of indirectCommandsLayout, objectTable, sequencesCountBuffer, sequencesIndexBuffer, and targetCommandBuffer that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "vkGetPhysicalDeviceSparseImageFormatProperties": { - "core": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094", - "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter", - "text": " type must be a valid VkImageType value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter", - "text": " samples must be a valid VkSampleCountFlagBits value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter", - "text": " usage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter", - "text": " tiling must be a valid VkImageTiling value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties structures" - } - ] - }, - "vkGetPhysicalDeviceSparseImageFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pFormatInfo-parameter", - "text": " pFormatInfo must be a valid pointer to a valid VkPhysicalDeviceSparseImageFormatInfo2 structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties2 structures" - } - ] - }, - "VkPhysicalDeviceSparseImageFormatInfo2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095", - "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter", - "text": " type must be a valid VkImageType value" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter", - "text": " samples must be a valid VkSampleCountFlagBits value" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter", - "text": " usage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter", - "text": " tiling must be a valid VkImageTiling value" - } - ] - }, - "VkSparseImageFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkSparseImageFormatProperties2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2" - }, - { - "vuid": "VUID-VkSparseImageFormatProperties2-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetImageSparseMemoryRequirements": { - "core": [ - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirementCount-parameter", - "text": " pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements-pSparseMemoryRequirements-parameter", - "text": " If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures" - }, - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements-image-parent", - "text": " image must have been created, allocated, or retrieved from device" - } - ] - }, - "vkGetImageSparseMemoryRequirements2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements2-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements2-pInfo-parameter", - "text": " pInfo must be a valid pointer to a valid VkImageSparseMemoryRequirementsInfo2 structure" - }, - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirementCount-parameter", - "text": " pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetImageSparseMemoryRequirements2-pSparseMemoryRequirements-parameter", - "text": " If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements2 structures" - } - ] - }, - "VkImageSparseMemoryRequirementsInfo2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-VkImageSparseMemoryRequirementsInfo2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2" - }, - { - "vuid": "VUID-VkImageSparseMemoryRequirementsInfo2-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter", - "text": " image must be a valid VkImage handle" - } - ] - }, - "VkSparseImageMemoryRequirements2": { - "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ - { - "vuid": "VUID-VkSparseImageMemoryRequirements2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2" - }, - { - "vuid": "VUID-VkSparseImageMemoryRequirements2-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "VkSparseMemoryBind": { - "core": [ - { - "vuid": "VUID-VkSparseMemoryBind-memory-01096", - "text": " If memory is not VK_NULL_HANDLE, memory and memoryOffset must match the memory requirements of the resource, as described in section &amp;lt;&amp;lt;resources-association&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkSparseMemoryBind-memory-01097", - "text": " If memory is not VK_NULL_HANDLE, memory must not have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set" - }, - { - "vuid": "VUID-VkSparseMemoryBind-size-01098", - "text": " size must be greater than 0" - }, - { - "vuid": "VUID-VkSparseMemoryBind-resourceOffset-01099", - "text": " resourceOffset must be less than the size of the resource" - }, - { - "vuid": "VUID-VkSparseMemoryBind-size-01100", - "text": " size must be less than or equal to the size of the resource minus resourceOffset" - }, - { - "vuid": "VUID-VkSparseMemoryBind-memoryOffset-01101", - "text": " memoryOffset must be less than the size of memory" - }, - { - "vuid": "VUID-VkSparseMemoryBind-size-01102", - "text": " size must be less than or equal to the size of memory minus memoryOffset" - }, - { - "vuid": "VUID-VkSparseMemoryBind-memory-parameter", - "text": " If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-VkSparseMemoryBind-flags-parameter", - "text": " flags must be a valid combination of VkSparseMemoryBindFlagBits values" - } - ] - }, - "VkSparseBufferMemoryBindInfo": { - "core": [ - { - "vuid": "VUID-VkSparseBufferMemoryBindInfo-buffer-parameter", - "text": " buffer must be a valid VkBuffer handle" - }, - { - "vuid": "VUID-VkSparseBufferMemoryBindInfo-pBinds-parameter", - "text": " pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures" - }, - { - "vuid": "VUID-VkSparseBufferMemoryBindInfo-bindCount-arraylength", - "text": " bindCount must be greater than 0" - } - ] - }, - "VkSparseImageOpaqueMemoryBindInfo": { - "core": [ - { - "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103", - "text": " If the flags member of any element of pBinds contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must be within the mip tail region of the metadata aspect of image" - }, - { - "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-parameter", - "text": " pBinds must be a valid pointer to an array of bindCount valid VkSparseMemoryBind structures" - }, - { - "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-bindCount-arraylength", - "text": " bindCount must be greater than 0" - } - ] - }, - "VkSparseImageMemoryBindInfo": { - "core": [ - { - "vuid": "VUID-VkSparseImageMemoryBindInfo-subresource-01722", - "text": " The subresource.mipLevel member of each element of pBinds must be less than the mipLevels specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkSparseImageMemoryBindInfo-subresource-01723", - "text": " The subresource.arrayLayer member of each element of pBinds must be less than the arrayLayers specified in VkImageCreateInfo when image was created" - }, - { - "vuid": "VUID-VkSparseImageMemoryBindInfo-image-parameter", - "text": " image must be a valid VkImage handle" - }, - { - "vuid": "VUID-VkSparseImageMemoryBindInfo-pBinds-parameter", - "text": " pBinds must be a valid pointer to an array of bindCount valid VkSparseImageMemoryBind structures" - }, - { - "vuid": "VUID-VkSparseImageMemoryBindInfo-bindCount-arraylength", - "text": " bindCount must be greater than 0" - } - ] - }, - "VkSparseImageMemoryBind": { - "core": [ - { - "vuid": "VUID-VkSparseImageMemoryBind-memory-01104", - "text": " If the &amp;lt;&amp;lt;features-features-sparseResidencyAliased,sparse aliased residency&amp;gt;&amp;gt; feature is not enabled, and if any other resources are bound to ranges of memory, the range of memory being bound must not overlap with those bound ranges" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-memory-01105", - "text": " memory and memoryOffset must match the memory requirements of the calling command’s image, as described in section &amp;lt;&amp;lt;resources-association&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-subresource-01106", - "text": " subresource must be a valid image subresource for image (see &amp;lt;&amp;lt;resources-image-views&amp;gt;&amp;gt;)" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-offset-01107", - "text": " offset.x must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of the image" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-extent-01108", - "text": " extent.width must either be a multiple of the sparse image block width of the image, or else (extent.width + offset.x) must equal the width of the image subresource" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-offset-01109", - "text": " offset.y must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of the image" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-extent-01110", - "text": " extent.height must either be a multiple of the sparse image block height of the image, or else (extent.height + offset.y) must equal the height of the image subresource" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-offset-01111", - "text": " offset.z must be a multiple of the sparse image block depth (VkSparseImageFormatProperties::imageGranularity.depth) of the image" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-extent-01112", - "text": " extent.depth must either be a multiple of the sparse image block depth of the image, or else (extent.depth + offset.z) must equal the depth of the image subresource" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-subresource-parameter", - "text": " subresource must be a valid VkImageSubresource structure" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-memory-parameter", - "text": " If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle" - }, - { - "vuid": "VUID-VkSparseImageMemoryBind-flags-parameter", - "text": " flags must be a valid combination of VkSparseMemoryBindFlagBits values" - } - ] - }, - "vkQueueBindSparse": { - "core": [ - { - "vuid": "VUID-vkQueueBindSparse-fence-01113", - "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" - }, - { - "vuid": "VUID-vkQueueBindSparse-fence-01114", - "text": " If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue" - }, - { - "vuid": "VUID-vkQueueBindSparse-pSignalSemaphores-01115", - "text": " Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device" - }, - { - "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01116", - "text": " When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, no other queue must be waiting on the same semaphore." - }, - { - "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01117", - "text": " All elements of the pWaitSemaphores member of all elements of pBindInfo must be semaphores that are signaled, or have &amp;lt;&amp;lt;synchronization-semaphores-signaling, semaphore signal operations&amp;gt;&amp;gt; previously submitted for execution." - }, - { - "vuid": "VUID-vkQueueBindSparse-queue-parameter", - "text": " queue must be a valid VkQueue handle" - }, - { - "vuid": "VUID-vkQueueBindSparse-pBindInfo-parameter", - "text": " If bindInfoCount is not 0, pBindInfo must be a valid pointer to an array of bindInfoCount valid VkBindSparseInfo structures" - }, - { - "vuid": "VUID-vkQueueBindSparse-fence-parameter", - "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-vkQueueBindSparse-queuetype", - "text": " The queue must support sparse binding operations" - }, - { - "vuid": "VUID-vkQueueBindSparse-commonparent", - "text": " Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkBindSparseInfo": { - "core": [ - { - "vuid": "VUID-VkBindSparseInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO" - }, - { - "vuid": "VUID-VkBindSparseInfo-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceGroupBindSparseInfo" - }, - { - "vuid": "VUID-VkBindSparseInfo-pWaitSemaphores-parameter", - "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" - }, - { - "vuid": "VUID-VkBindSparseInfo-pBufferBinds-parameter", - "text": " If bufferBindCount is not 0, pBufferBinds must be a valid pointer to an array of bufferBindCount valid VkSparseBufferMemoryBindInfo structures" - }, - { - "vuid": "VUID-VkBindSparseInfo-pImageOpaqueBinds-parameter", - "text": " If imageOpaqueBindCount is not 0, pImageOpaqueBinds must be a valid pointer to an array of imageOpaqueBindCount valid VkSparseImageOpaqueMemoryBindInfo structures" - }, - { - "vuid": "VUID-VkBindSparseInfo-pImageBinds-parameter", - "text": " If imageBindCount is not 0, pImageBinds must be a valid pointer to an array of imageBindCount valid VkSparseImageMemoryBindInfo structures" - }, - { - "vuid": "VUID-VkBindSparseInfo-pSignalSemaphores-parameter", - "text": " If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles" - }, - { - "vuid": "VUID-VkBindSparseInfo-commonparent", - "text": " Both of the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkDevice" - } - ] - }, - "VkDeviceGroupBindSparseInfo": { - "(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118", - "text": " resourceDeviceIndex and memoryDeviceIndex must both be valid device indices." - }, - { - "vuid": "VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119", - "text": " Each memory allocation bound in this batch must have allocated an instance for memoryDeviceIndex." - }, - { - "vuid": "VUID-VkDeviceGroupBindSparseInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO" - } - ] - }, - "vkCreateAndroidSurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_android_surface)": [ - { - "vuid": "VUID-vkCreateAndroidSurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateAndroidSurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkAndroidSurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateAndroidSurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateAndroidSurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkAndroidSurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_android_surface)": [ - { - "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-window-01248", - "text": " window must point to a valid Android ANativeWindow." - }, - { - "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateMirSurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ - { - "vuid": "VUID-vkCreateMirSurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateMirSurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkMirSurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateMirSurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateMirSurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkMirSurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-connection-01263", - "text": " connection must point to a valid MirConnection." - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-surface-01264", - "text": " surface must point to a valid MirSurface." - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkMirSurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateWaylandSurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ - { - "vuid": "VUID-vkCreateWaylandSurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateWaylandSurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkWaylandSurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateWaylandSurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateWaylandSurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkWaylandSurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ - { - "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-display-01304", - "text": " display must point to a valid Wayland wl_display." - }, - { - "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305", - "text": " surface must point to a valid Wayland wl_surface." - }, - { - "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateWin32SurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ - { - "vuid": "VUID-vkCreateWin32SurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateWin32SurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkWin32SurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateWin32SurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateWin32SurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkWin32SurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ - { - "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307", - "text": " hinstance must be a valid Win32 HINSTANCE." - }, - { - "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308", - "text": " hwnd must be a valid Win32 HWND." - }, - { - "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateXcbSurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ - { - "vuid": "VUID-vkCreateXcbSurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateXcbSurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkXcbSurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateXcbSurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateXcbSurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkXcbSurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ - { - "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-connection-01310", - "text": " connection must point to a valid X11 xcb_connection_t." - }, - { - "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-window-01311", - "text": " window must be a valid X11 xcb_window_t." - }, - { - "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateXlibSurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ - { - "vuid": "VUID-vkCreateXlibSurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateXlibSurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkXlibSurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateXlibSurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateXlibSurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkXlibSurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ - { - "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313", - "text": " dpy must point to a valid Xlib Display." - }, - { - "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-window-01314", - "text": " window must be a valid Xlib Window." - }, - { - "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateIOSSurfaceMVK": { - "(VK_KHR_surface)+(VK_MVK_ios_surface)": [ - { - "vuid": "VUID-vkCreateIOSSurfaceMVK-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateIOSSurfaceMVK-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkIOSSurfaceCreateInfoMVK structure" - }, - { - "vuid": "VUID-vkCreateIOSSurfaceMVK-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateIOSSurfaceMVK-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkIOSSurfaceCreateInfoMVK": { - "(VK_KHR_surface)+(VK_MVK_ios_surface)": [ - { - "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-pView-01316", - "text": " pView must be a valid UIView and must be backed by a CALayer instance of type CAMetalLayer." - }, - { - "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK" - }, - { - "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateMacOSSurfaceMVK": { - "(VK_KHR_surface)+(VK_MVK_macos_surface)": [ - { - "vuid": "VUID-vkCreateMacOSSurfaceMVK-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateMacOSSurfaceMVK-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkMacOSSurfaceCreateInfoMVK structure" - }, - { - "vuid": "VUID-vkCreateMacOSSurfaceMVK-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateMacOSSurfaceMVK-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkMacOSSurfaceCreateInfoMVK": { - "(VK_KHR_surface)+(VK_MVK_macos_surface)": [ - { - "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317", - "text": " pView must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer." - }, - { - "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK" - }, - { - "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkCreateViSurfaceNN": { - "(VK_KHR_surface)+(VK_NN_vi_surface)": [ - { - "vuid": "VUID-vkCreateViSurfaceNN-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateViSurfaceNN-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkViSurfaceCreateInfoNN structure" - }, - { - "vuid": "VUID-vkCreateViSurfaceNN-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateViSurfaceNN-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkViSurfaceCreateInfoNN": { - "(VK_KHR_surface)+(VK_NN_vi_surface)": [ - { - "vuid": "VUID-VkViSurfaceCreateInfoNN-window-01318", - "text": " window must be a valid nn::vi::NativeWindowHandle" - }, - { - "vuid": "VUID-VkViSurfaceCreateInfoNN-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN" - }, - { - "vuid": "VUID-VkViSurfaceCreateInfoNN-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkViSurfaceCreateInfoNN-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkDestroySurfaceKHR": { - "(VK_KHR_surface)": [ - { - "vuid": "VUID-vkDestroySurfaceKHR-surface-01266", - "text": " All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface" - }, - { - "vuid": "VUID-vkDestroySurfaceKHR-surface-01267", - "text": " If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroySurfaceKHR-surface-01268", - "text": " If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroySurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkDestroySurfaceKHR-surface-parameter", - "text": " If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkDestroySurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroySurfaceKHR-surface-parent", - "text": " If surface is a valid handle, it must have been created, allocated, or retrieved from instance" - } - ] - }, - "vkGetPhysicalDeviceDisplayPropertiesKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures" - } - ] - }, - "vkGetPhysicalDeviceDisplayProperties2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayProperties2KHR structures" - } - ] - }, - "VkDisplayProperties2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-VkDisplayProperties2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR" - }, - { - "vuid": "VUID-VkDisplayProperties2KHR-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkAcquireXlibDisplayEXT": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)": [ - { - "vuid": "VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkAcquireXlibDisplayEXT-dpy-parameter", - "text": " dpy must be a valid pointer to a Display value" - }, - { - "vuid": "VUID-vkAcquireXlibDisplayEXT-display-parameter", - "text": " display must be a valid VkDisplayKHR handle" - } - ] - }, - "vkGetRandROutputDisplayEXT": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_EXT_acquire_xlib_display)": [ - { - "vuid": "VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetRandROutputDisplayEXT-dpy-parameter", - "text": " dpy must be a valid pointer to a Display value" - }, - { - "vuid": "VUID-vkGetRandROutputDisplayEXT-pDisplay-parameter", - "text": " pDisplay must be a valid pointer to a VkDisplayKHR handle" - } - ] - }, - "vkReleaseDisplayEXT": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)": [ - { - "vuid": "VUID-vkReleaseDisplayEXT-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkReleaseDisplayEXT-display-parameter", - "text": " display must be a valid VkDisplayKHR handle" - } - ] - }, - "vkGetPhysicalDeviceDisplayPlanePropertiesKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlanePropertiesKHR structures" - } - ] - }, - "vkGetPhysicalDeviceDisplayPlaneProperties2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlaneProperties2KHR structures" - } - ] - }, - "VkDisplayPlaneProperties2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-VkDisplayPlaneProperties2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR" - }, - { - "vuid": "VUID-VkDisplayPlaneProperties2KHR-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetDisplayPlaneSupportedDisplaysKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249", - "text": " planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR" - }, - { - "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter", - "text": " pDisplayCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter", - "text": " If the value referenced by pDisplayCount is not 0, and pDisplays is not NULL, pDisplays must be a valid pointer to an array of pDisplayCount VkDisplayKHR handles" - } - ] - }, - "vkGetDisplayModePropertiesKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetDisplayModePropertiesKHR-display-parameter", - "text": " display must be a valid VkDisplayKHR handle" - }, - { - "vuid": "VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModePropertiesKHR structures" - } - ] - }, - "vkGetDisplayModeProperties2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetDisplayModeProperties2KHR-display-parameter", - "text": " display must be a valid VkDisplayKHR handle" - }, - { - "vuid": "VUID-vkGetDisplayModeProperties2KHR-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetDisplayModeProperties2KHR-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModeProperties2KHR structures" - } - ] - }, - "VkDisplayModeProperties2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-VkDisplayModeProperties2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR" - }, - { - "vuid": "VUID-VkDisplayModeProperties2KHR-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkCreateDisplayModeKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-vkCreateDisplayModeKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkCreateDisplayModeKHR-display-parameter", - "text": " display must be a valid VkDisplayKHR handle" - }, - { - "vuid": "VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDisplayModeCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateDisplayModeKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDisplayModeKHR-pMode-parameter", - "text": " pMode must be a valid pointer to a VkDisplayModeKHR handle" - } - ] - }, - "VkDisplayModeCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-VkDisplayModeCreateInfoKHR-width-01250", - "text": " The width and height members of the visibleRegion member of parameters must be greater than 0" - }, - { - "vuid": "VUID-VkDisplayModeCreateInfoKHR-refreshRate-01251", - "text": " The refreshRate member of parameters must be greater than 0" - }, - { - "vuid": "VUID-VkDisplayModeCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkDisplayModeCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - } - ] - }, - "vkGetDisplayPlaneCapabilitiesKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter", - "text": " mode must be a valid VkDisplayModeKHR handle" - }, - { - "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter", - "text": " pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilitiesKHR structure" - } - ] - }, - "vkGetDisplayPlaneCapabilities2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-pDisplayPlaneInfo-parameter", - "text": " pDisplayPlaneInfo must be a valid pointer to a valid VkDisplayPlaneInfo2KHR structure" - }, - { - "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-pCapabilities-parameter", - "text": " pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilities2KHR structure" - } - ] - }, - "VkDisplayPlaneInfo2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-VkDisplayPlaneInfo2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR" - }, - { - "vuid": "VUID-VkDisplayPlaneInfo2KHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDisplayPlaneInfo2KHR-mode-parameter", - "text": " mode must be a valid VkDisplayModeKHR handle" - } - ] - }, - "VkDisplayPlaneCapabilities2KHR": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ - { - "vuid": "VUID-VkDisplayPlaneCapabilities2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR" - }, - { - "vuid": "VUID-VkDisplayPlaneCapabilities2KHR-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkDisplayPowerControlEXT": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)": [ - { - "vuid": "VUID-vkDisplayPowerControlEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDisplayPowerControlEXT-display-parameter", - "text": " display must be a valid VkDisplayKHR handle" - }, - { - "vuid": "VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter", - "text": " pDisplayPowerInfo must be a valid pointer to a valid VkDisplayPowerInfoEXT structure" - } - ] - }, - "VkDisplayPowerInfoEXT": { - "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)": [ - { - "vuid": "VUID-VkDisplayPowerInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT" - }, - { - "vuid": "VUID-VkDisplayPowerInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDisplayPowerInfoEXT-powerState-parameter", - "text": " powerState must be a valid VkDisplayPowerStateEXT value" - } - ] - }, - "vkCreateDisplayPlaneSurfaceKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDisplaySurfaceCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter", - "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" - } - ] - }, - "VkDisplaySurfaceCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_display)": [ - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252", - "text": " planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253", - "text": " If the planeReorderPossible member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display corresponding to displayMode is VK_TRUE then planeStackIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR; otherwise planeStackIndex must equal the currentStackIndex member of VkDisplayPlanePropertiesKHR returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR for the display plane corresponding to displayMode" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254", - "text": " If alphaMode is VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR then globalAlpha must be between 0 and 1, inclusive" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255", - "text": " alphaMode must be 0 or one of the bits present in the supportedAlpha member of VkDisplayPlaneCapabilitiesKHR returned by vkGetDisplayPlaneCapabilitiesKHR for the display plane corresponding to displayMode" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-width-01256", - "text": " The width and height members of imageExtent must be less than the maxImageDimensions2D member of VkPhysicalDeviceLimits" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter", - "text": " displayMode must be a valid VkDisplayModeKHR handle" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter", - "text": " transform must be a valid VkSurfaceTransformFlagBitsKHR value" - }, - { - "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter", - "text": " alphaMode must be a valid VkDisplayPlaneAlphaFlagBitsKHR value" - } - ] - }, - "vkGetPhysicalDeviceSurfaceSupportKHR": { - "(VK_KHR_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter", - "text": " pSupported must be a valid pointer to a VkBool32 value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetPhysicalDeviceMirPresentationSupportKHR": { - "(VK_KHR_surface)+(VK_KHR_mir_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-queueFamilyIndex-01265", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMirPresentationSupportKHR-connection-parameter", - "text": " connection must be a valid pointer to a MirConnection value" - } - ] - }, - "vkGetPhysicalDeviceWaylandPresentationSupportKHR": { - "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-display-parameter", - "text": " display must be a valid pointer to a wl_display value" - } - ] - }, - "vkGetPhysicalDeviceWin32PresentationSupportKHR": { - "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - } - ] - }, - "vkGetPhysicalDeviceXcbPresentationSupportKHR": { - "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-connection-parameter", - "text": " connection must be a valid pointer to a xcb_connection_t value" - } - ] - }, - "vkGetPhysicalDeviceXlibPresentationSupportKHR": { - "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315", - "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-dpy-parameter", - "text": " dpy must be a valid pointer to a Display value" - } - ] - }, - "vkGetPhysicalDeviceSurfaceCapabilitiesKHR": { - "(VK_KHR_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter", - "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilitiesKHR structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetPhysicalDeviceSurfaceCapabilities2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter", - "text": " pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter", - "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2KHR structure" - } - ] - }, - "VkPhysicalDeviceSurfaceInfo2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ - { - "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR" - }, - { - "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - } - ] - }, - "VkSurfaceCapabilities2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ - { - "vuid": "VUID-VkSurfaceCapabilities2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR" - }, - { - "vuid": "VUID-VkSurfaceCapabilities2KHR-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkSharedPresentSurfaceCapabilitiesKHR" - } - ] - }, - "VkSharedPresentSurfaceCapabilitiesKHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR" - } - ] - }, - "vkGetPhysicalDeviceSurfaceCapabilities2EXT": { - "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter", - "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2EXT structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "VkSurfaceCapabilities2EXT": { - "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [ - { - "vuid": "VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246", - "text": " supportedSurfaceCounters must not include VK_SURFACE_COUNTER_VBLANK_EXT unless the surface queried is a &amp;lt;&amp;lt;wsi-display-surfaces,display surface&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkSurfaceCapabilities2EXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT" - }, - { - "vuid": "VUID-VkSurfaceCapabilities2EXT-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetPhysicalDeviceSurfaceFormatsKHR": { - "(VK_KHR_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter", - "text": " pSurfaceFormatCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter", - "text": " If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormatKHR structures" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetPhysicalDeviceSurfaceFormats2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter", - "text": " pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter", - "text": " pSurfaceFormatCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter", - "text": " If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormat2KHR structures" - } - ] - }, - "VkSurfaceFormat2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ - { - "vuid": "VUID-VkSurfaceFormat2KHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR" - }, - { - "vuid": "VUID-VkSurfaceFormat2KHR-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetPhysicalDeviceSurfacePresentModesKHR": { - "(VK_KHR_surface)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter", - "text": " pPresentModeCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter", - "text": " If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetDeviceGroupPresentCapabilitiesKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter", - "text": " pDeviceGroupPresentCapabilities must be a valid pointer to a VkDeviceGroupPresentCapabilitiesKHR structure" - } - ] - }, - "VkDeviceGroupPresentCapabilitiesKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR" - }, - { - "vuid": "VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetDeviceGroupSurfacePresentModesKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter", - "text": " pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value" - }, - { - "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent", - "text": " Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetPhysicalDevicePresentRectanglesKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter", - "text": " pRectCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter", - "text": " If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures" - }, - { - "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetRefreshCycleDurationGOOGLE": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [ - { - "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-pDisplayTimingProperties-parameter", - "text": " pDisplayTimingProperties must be a valid pointer to a VkRefreshCycleDurationGOOGLE structure" - }, - { - "vuid": "VUID-vkGetRefreshCycleDurationGOOGLE-commonparent", - "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetPastPresentationTimingGOOGLE": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [ - { - "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter", - "text": " pPresentationTimingCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter", - "text": " If the value referenced by pPresentationTimingCount is not 0, and pPresentationTimings is not NULL, pPresentationTimings must be a valid pointer to an array of pPresentationTimingCount VkPastPresentationTimingGOOGLE structures" - }, - { - "vuid": "VUID-vkGetPastPresentationTimingGOOGLE-commonparent", - "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkGetSwapchainStatusKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-vkGetSwapchainStatusKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetSwapchainStatusKHR-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-vkGetSwapchainStatusKHR-commonparent", - "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkCreateSwapchainKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-vkCreateSwapchainKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateSwapchainKHR-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure" - }, - { - "vuid": "VUID-vkCreateSwapchainKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateSwapchainKHR-pSwapchain-parameter", - "text": " pSwapchain must be a valid pointer to a VkSwapchainKHR handle" - } - ] - }, - "VkSwapchainCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-surface-01270", - "text": " surface must be a surface that is supported by the device as determined using vkGetPhysicalDeviceSurfaceSupportKHR" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01271", - "text": " minImageCount must be greater than or equal to the value returned in the minImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01272", - "text": " minImageCount must be less than or equal to the value returned in the maxImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface if the returned maxImageCount is not zero" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-01273", - "text": " imageFormat and imageColorSpace must match the format and colorSpace members, respectively, of one of the VkSurfaceFormatKHR structures returned by vkGetPhysicalDeviceSurfaceFormatsKHR for the surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageExtent-01274", - "text": " imageExtent must be between minImageExtent and maxImageExtent, inclusive, where minImageExtent and maxImageExtent are members of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageExtent-01689", - "text": " imageExtent members width and height must both be non-zero" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275", - "text": " imageArrayLayers must be greater than 0 and less than or equal to the maxImageArrayLayers member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277", - "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278", - "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-preTransform-01279", - "text": " preTransform must be one of the bits present in the supportedTransforms member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280", - "text": " compositeAlpha must be one of the bits present in the supportedCompositeAlpha member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-01281", - "text": " presentMode must be one of the VkPresentModeKHR values returned by vkGetPhysicalDeviceSurfacePresentModesKHR for the surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933", - "text": " If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-01778", - "text": " imageFormat, imageUsage, imageExtent, and imageArrayLayers must be supported for VK_IMAGE_TYPE_2D VK_IMAGE_TILING_OPTIMAL images as reported by vkGetPhysicalDeviceImageFormatProperties." - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHR or VkSwapchainCounterCreateInfoEXT" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-parameter", - "text": " flags must be a valid combination of VkSwapchainCreateFlagBitsKHR values" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter", - "text": " imageFormat must be a valid VkFormat value" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter", - "text": " imageColorSpace must be a valid VkColorSpaceKHR value" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter", - "text": " imageUsage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask", - "text": " imageUsage must not be 0" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter", - "text": " imageSharingMode must be a valid VkSharingMode value" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter", - "text": " preTransform must be a valid VkSurfaceTransformFlagBitsKHR value" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter", - "text": " compositeAlpha must be a valid VkCompositeAlphaFlagBitsKHR value" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-parameter", - "text": " presentMode must be a valid VkPresentModeKHR value" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter", - "text": " If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent", - "text": " If oldSwapchain is a valid handle, it must have been created, allocated, or retrieved from surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-commonparent", - "text": " Both of oldSwapchain, and surface that are valid handles must have been created, allocated, or retrieved from the same VkInstance" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01383", - "text": " minImageCount must be 1 if presentMode is either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-01427", - "text": " If presentMode is VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_FIFO_RELAXED_KHR, imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for surface" - }, - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-01384", - "text": " If presentMode is VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, imageUsage must be a subset of the supported usage flags present in the sharedPresentSupportedUsageFlags member of the VkSharedPresentSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-01276", - "text": " imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01393", - "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428", - "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429", - "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" - } - ] - }, - "VkDeviceGroupSwapchainCreateInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR" - }, - { - "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter", - "text": " modes must be a valid combination of VkDeviceGroupPresentModeFlagBitsKHR values" - }, - { - "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask", - "text": " modes must not be 0" - } - ] - }, - "VkSwapchainCounterCreateInfoEXT": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [ - { - "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244", - "text": " The bits in surfaceCounters must be supported by VkSwapchainCreateInfoKHR::surface, as reported by vkGetPhysicalDeviceSurfaceCapabilities2EXT." - }, - { - "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter", - "text": " surfaceCounters must be a valid combination of VkSurfaceCounterFlagBitsEXT values" - } - ] - }, - "vkGetSwapchainCounterEXT": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [ - { - "vuid": "VUID-vkGetSwapchainCounterEXT-swapchain-01245", - "text": " One or more present commands on swapchain must have been processed by the presentation engine." - }, - { - "vuid": "VUID-vkGetSwapchainCounterEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetSwapchainCounterEXT-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-vkGetSwapchainCounterEXT-counter-parameter", - "text": " counter must be a valid VkSurfaceCounterFlagBitsEXT value" - }, - { - "vuid": "VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter", - "text": " pCounterValue must be a valid pointer to a uint64_t value" - }, - { - "vuid": "VUID-vkGetSwapchainCounterEXT-commonparent", - "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkDestroySwapchainKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01282", - "text": " All uses of presentable images acquired from swapchain must have completed execution" - }, - { - "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01283", - "text": " If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01284", - "text": " If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroySwapchainKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDestroySwapchainKHR-swapchain-parameter", - "text": " If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-vkDestroySwapchainKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroySwapchainKHR-commonparent", - "text": " Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkCreateSharedSwapchainsKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ - { - "vuid": "VUID-vkCreateSharedSwapchainsKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter", - "text": " pCreateInfos must be a valid pointer to an array of swapchainCount valid VkSwapchainCreateInfoKHR structures" - }, - { - "vuid": "VUID-vkCreateSharedSwapchainsKHR-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter", - "text": " pSwapchains must be a valid pointer to an array of swapchainCount VkSwapchainKHR handles" - }, - { - "vuid": "VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength", - "text": " swapchainCount must be greater than 0" - } - ] - }, - "vkGetSwapchainImagesKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-vkGetSwapchainImagesKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkGetSwapchainImagesKHR-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter", - "text": " pSwapchainImageCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter", - "text": " If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles" - }, - { - "vuid": "VUID-vkGetSwapchainImagesKHR-commonparent", - "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkAcquireNextImageKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-vkAcquireNextImageKHR-swapchain-01285", - "text": " swapchain must not be in the retired state" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01286", - "text": " If semaphore is not VK_NULL_HANDLE it must be unsignaled" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01779", - "text": " If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-fence-01287", - "text": " If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01780", - "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-swapchain-01802", - "text": " If the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-semaphore-parameter", - "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-fence-parameter", - "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-pImageIndex-parameter", - "text": " pImageIndex must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-semaphore-parent", - "text": " If semaphore is a valid handle, it must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-fence-parent", - "text": " If fence is a valid handle, it must have been created, allocated, or retrieved from device" - }, - { - "vuid": "VUID-vkAcquireNextImageKHR-commonparent", - "text": " Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkAcquireNextImage2KHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-vkAcquireNextImage2KHR-swapchain-01803", - "text": " If the number of currently acquired images is greater than the difference between the number of images in the swapchain member of pAcquireInfo and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, the timeout member of pAcquireInfo must not be UINT64_MAX" - }, - { - "vuid": "VUID-vkAcquireNextImage2KHR-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter", - "text": " pAcquireInfo must be a valid pointer to a valid VkAcquireNextImageInfoKHR structure" - }, - { - "vuid": "VUID-vkAcquireNextImage2KHR-pImageIndex-parameter", - "text": " pImageIndex must be a valid pointer to a uint32_t value" - } - ] - }, - "VkAcquireNextImageInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-swapchain-01675", - "text": " swapchain must not be in the retired state" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01288", - "text": " If semaphore is not VK_NULL_HANDLE it must be unsignaled" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01781", - "text": " If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-fence-01289", - "text": " If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01782", - "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-deviceMask-01290", - "text": " deviceMask must be a valid device mask" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-deviceMask-01291", - "text": " deviceMask must not be zero" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01804", - "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE." - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-swapchain-parameter", - "text": " swapchain must be a valid VkSwapchainKHR handle" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-parameter", - "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-fence-parameter", - "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" - }, - { - "vuid": "VUID-VkAcquireNextImageInfoKHR-commonparent", - "text": " Each of fence, semaphore, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkQueuePresentKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-vkQueuePresentKHR-pSwapchains-01292", - "text": " Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR" - }, - { - "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01294", - "text": " When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, no other queue must be waiting on the same semaphore." - }, - { - "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01295", - "text": " All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have &amp;lt;&amp;lt;synchronization-semaphores-signaling, semaphore signal operations&amp;gt;&amp;gt; previously submitted for execution." - }, - { - "vuid": "VUID-vkQueuePresentKHR-queue-parameter", - "text": " queue must be a valid VkQueue handle" - }, - { - "vuid": "VUID-vkQueuePresentKHR-pPresentInfo-parameter", - "text": " pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ - { - "vuid": "VUID-vkQueuePresentKHR-pSwapchains-01293", - "text": " If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode" - } - ] - }, - "VkPresentInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-VkPresentInfoKHR-pImageIndices-01296", - "text": " Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR layout at the time the operation is executed on a VkDevice" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ - { - "vuid": "VUID-VkPresentInfoKHR-pImageIndices-01430", - "text": " Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice" - } - ], - "(VK_KHR_surface)+(VK_KHR_swapchain)": [ - { - "vuid": "VUID-VkPresentInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR" - }, - { - "vuid": "VUID-VkPresentInfoKHR-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupPresentInfoKHR, VkDisplayPresentInfoKHR, VkPresentRegionsKHR, or VkPresentTimesInfoGOOGLE" - }, - { - "vuid": "VUID-VkPresentInfoKHR-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - }, - { - "vuid": "VUID-VkPresentInfoKHR-pWaitSemaphores-parameter", - "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" - }, - { - "vuid": "VUID-VkPresentInfoKHR-pSwapchains-parameter", - "text": " pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles" - }, - { - "vuid": "VUID-VkPresentInfoKHR-pImageIndices-parameter", - "text": " pImageIndices must be a valid pointer to an array of swapchainCount uint32_t values" - }, - { - "vuid": "VUID-VkPresentInfoKHR-pResults-parameter", - "text": " If pResults is not NULL, pResults must be a valid pointer to an array of swapchainCount VkResult values" - }, - { - "vuid": "VUID-VkPresentInfoKHR-swapchainCount-arraylength", - "text": " swapchainCount must be greater than 0" - }, - { - "vuid": "VUID-VkPresentInfoKHR-commonparent", - "text": " Both of the elements of pSwapchains, and the elements of pWaitSemaphores that are valid handles must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "VkPresentRegionsKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ - { - "vuid": "VUID-VkPresentRegionsKHR-swapchainCount-01260", - "text": " swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext-chain of this VkPresentRegionsKHR structure." - }, - { - "vuid": "VUID-VkPresentRegionsKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR" - }, - { - "vuid": "VUID-VkPresentRegionsKHR-pRegions-parameter", - "text": " If pRegions is not NULL, pRegions must be a valid pointer to an array of swapchainCount valid VkPresentRegionKHR structures" - }, - { - "vuid": "VUID-VkPresentRegionsKHR-swapchainCount-arraylength", - "text": " swapchainCount must be greater than 0" - } - ] - }, - "VkPresentRegionKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ - { - "vuid": "VUID-VkPresentRegionKHR-pRectangles-parameter", - "text": " If rectangleCount is not 0, and pRectangles is not NULL, pRectangles must be a valid pointer to an array of rectangleCount VkRectLayerKHR structures" - } - ] - }, - "VkRectLayerKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ - { - "vuid": "VUID-VkRectLayerKHR-offset-01261", - "text": " The sum of offset and extent must be no greater than the imageExtent member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR." - }, - { - "vuid": "VUID-VkRectLayerKHR-layer-01262", - "text": " layer must be less than imageArrayLayers member of the VkSwapchainCreateInfoKHR structure given to vkCreateSwapchainKHR." - } - ] - }, - "VkDisplayPresentInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ - { - "vuid": "VUID-VkDisplayPresentInfoKHR-srcRect-01257", - "text": " srcRect must specify a rectangular region that is a subset of the image being presented" - }, - { - "vuid": "VUID-VkDisplayPresentInfoKHR-dstRect-01258", - "text": " dstRect must specify a rectangular region that is a subset of the visibleRegion parameter of the display mode the swapchain being presented uses" - }, - { - "vuid": "VUID-VkDisplayPresentInfoKHR-persistentContent-01259", - "text": " If the persistentContent member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display the present operation targets then persistent must be VK_FALSE" - }, - { - "vuid": "VUID-VkDisplayPresentInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR" - } - ] - }, - "VkDeviceGroupPresentInfoKHR": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297", - "text": " swapchainCount must equal 0 or VkPresentInfoKHR::swapchainCount" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01298", - "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01299", - "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and some physical device in the logical device must include that bit in its VkDeviceGroupPresentCapabilitiesKHR::presentMask." - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01300", - "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, then each element of pDeviceMasks must have a value for which all set bits are set in one of the elements of VkDeviceGroupPresentCapabilitiesKHR::presentMask" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01301", - "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, then for each bit set in each element of pDeviceMasks, the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302", - "text": " The value of each element of pDeviceMasks must be equal to the device mask passed in VkAcquireNextImageInfoKHR::deviceMask when the image index was last acquired" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01303", - "text": " mode must have exactly one bit set, and that bit must have been included in VkDeviceGroupSwapchainCreateInfoKHR::modes" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter", - "text": " If swapchainCount is not 0, pDeviceMasks must be a valid pointer to an array of swapchainCount uint32_t values" - }, - { - "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-parameter", - "text": " mode must be a valid VkDeviceGroupPresentModeFlagBitsKHR value" - } - ] - }, - "VkPresentTimesInfoGOOGLE": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [ - { - "vuid": "VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247", - "text": " swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is in the pNext chain of this VkPresentTimesInfoGOOGLE structure." - }, - { - "vuid": "VUID-VkPresentTimesInfoGOOGLE-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE" - }, - { - "vuid": "VUID-VkPresentTimesInfoGOOGLE-pTimes-parameter", - "text": " If pTimes is not NULL, pTimes must be a valid pointer to an array of swapchainCount VkPresentTimeGOOGLE structures" - }, - { - "vuid": "VUID-VkPresentTimesInfoGOOGLE-swapchainCount-arraylength", - "text": " swapchainCount must be greater than 0" - } - ] - }, - "vkSetHdrMetadataEXT": { - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)": [ - { - "vuid": "VUID-vkSetHdrMetadataEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkSetHdrMetadataEXT-pSwapchains-parameter", - "text": " pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles" - }, - { - "vuid": "VUID-vkSetHdrMetadataEXT-pMetadata-parameter", - "text": " pMetadata must be a valid pointer to an array of swapchainCount valid VkHdrMetadataEXT structures" - }, - { - "vuid": "VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength", - "text": " swapchainCount must be greater than 0" - }, - { - "vuid": "VUID-vkSetHdrMetadataEXT-commonparent", - "text": " Both of device, and the elements of pSwapchains must have been created, allocated, or retrieved from the same VkInstance" - } - ] - }, - "vkEnumerateInstanceLayerProperties": { - "core": [ - { - "vuid": "VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures" - } - ] - }, - "vkEnumerateDeviceLayerProperties": { - "core": [ - { - "vuid": "VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures" - } - ] - }, - "vkEnumerateInstanceExtensionProperties": { - "core": [ - { - "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter", - "text": " If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string" - }, - { - "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures" - } - ] - }, - "vkEnumerateDeviceExtensionProperties": { - "core": [ - { - "vuid": "VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter", - "text": " If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string" - }, - { - "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter", - "text": " pPropertyCount must be a valid pointer to a uint32_t value" - }, - { - "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter", - "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures" - } - ] - }, - "vkGetPhysicalDeviceFeatures": { - "core": [ - { - "vuid": "VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter", - "text": " pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure" - } - ] - }, - "vkGetPhysicalDeviceFeatures2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter", - "text": " pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure" - } - ] - }, - "VkPhysicalDeviceFeatures2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkPhysicalDeviceFeatures2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2" - } - ] - }, - "VkPhysicalDeviceVariablePointerFeatures": { - "(VK_VERSION_1_1,VK_KHR_variable_pointers)": [ - { - "vuid": "VUID-VkPhysicalDeviceVariablePointerFeatures-variablePointers-01431", - "text": " If variablePointers is enabled then variablePointersStorageBuffer must also be enabled." - }, - { - "vuid": "VUID-VkPhysicalDeviceVariablePointerFeatures-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES" - } - ] - }, - "VkPhysicalDeviceMultiviewFeatures": { - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580", - "text": " If multiviewGeometryShader is enabled then multiview must also be enabled." - }, - { - "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581", - "text": " If multiviewTessellationShader is enabled then multiview must also be enabled." - }, - { - "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES" - } - ] - }, - "VkPhysicalDevice16BitStorageFeatures": { - "(VK_VERSION_1_1,VK_KHR_16bit_storage)": [ - { - "vuid": "VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES" - } - ] - }, - "VkPhysicalDeviceSamplerYcbcrConversionFeatures": { - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES" - } - ] - }, - "VkPhysicalDeviceProtectedMemoryFeatures": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES" - } - ] - }, - "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT": { - "(VK_EXT_blend_operation_advanced)": [ - { - "vuid": "VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT" - } - ] - }, - "VkPhysicalDeviceShaderDrawParameterFeatures": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkPhysicalDeviceShaderDrawParameterFeatures-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES" - } - ] - }, - "VkPhysicalDeviceDescriptorIndexingFeaturesEXT": { - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkPhysicalDeviceDescriptorIndexingFeaturesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT" - } - ] - }, - "VkPhysicalDevicePushDescriptorPropertiesKHR": { - "(VK_KHR_push_descriptor)": [ - { - "vuid": "VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR" - } - ] - }, - "VkPhysicalDeviceMultiviewProperties": { - "(VK_VERSION_1_1,VK_KHR_multiview)": [ - { - "vuid": "VUID-VkPhysicalDeviceMultiviewProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES" - } - ] - }, - "VkPhysicalDeviceDiscardRectanglePropertiesEXT": { - "(VK_EXT_discard_rectangles)": [ - { - "vuid": "VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceSampleLocationsPropertiesEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceExternalMemoryHostPropertiesEXT": { - "(VK_EXT_external_memory_host)": [ - { - "vuid": "VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX": { - "(VK_NVX_multiview_per_view_attributes)": [ - { - "vuid": "VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX" - } - ] - }, - "VkPhysicalDevicePointClippingProperties": { - "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ - { - "vuid": "VUID-VkPhysicalDevicePointClippingProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES" - } - ] - }, - "VkPhysicalDeviceSubgroupProperties": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkPhysicalDeviceSubgroupProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES" - } - ] - }, - "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT": { - "(VK_EXT_blend_operation_advanced)": [ - { - "vuid": "VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT": { - "(VK_EXT_vertex_attribute_divisor)": [ - { - "vuid": "VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT": { - "(VK_EXT_sampler_filter_minmax)": [ - { - "vuid": "VUID-VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceProtectedMemoryProperties": { - "(VK_VERSION_1_1)": [ - { - "vuid": "VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES" - } - ] - }, - "VkPhysicalDeviceMaintenance3Properties": { - "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ - { - "vuid": "VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES" - } - ] - }, - "VkPhysicalDeviceDescriptorIndexingPropertiesEXT": { - "(VK_EXT_descriptor_indexing)": [ - { - "vuid": "VUID-VkPhysicalDeviceDescriptorIndexingPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceConservativeRasterizationPropertiesEXT": { - "(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT" - } - ] - }, - "VkPhysicalDeviceShaderCorePropertiesAMD": { - "(VK_AMD_shader_core_properties)": [ - { - "vuid": "VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD" - } - ] - }, - "vkGetPhysicalDeviceMultisamplePropertiesEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter", - "text": " samples must be a valid VkSampleCountFlagBits value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter", - "text": " pMultisampleProperties must be a valid pointer to a VkMultisamplePropertiesEXT structure" - } - ] - }, - "VkMultisamplePropertiesEXT": { - "(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-VkMultisamplePropertiesEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT" - }, - { - "vuid": "VUID-VkMultisamplePropertiesEXT-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetPhysicalDeviceFormatProperties": { - "core": [ - { - "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter", - "text": " pFormatProperties must be a valid pointer to a VkFormatProperties structure" - } - ] - }, - "vkGetPhysicalDeviceFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter", - "text": " pFormatProperties must be a valid pointer to a VkFormatProperties2 structure" - } - ] - }, - "VkFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkFormatProperties2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2" - }, - { - "vuid": "VUID-VkFormatProperties2-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetPhysicalDeviceImageFormatProperties": { - "core": [ - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter", - "text": " type must be a valid VkImageType value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter", - "text": " tiling must be a valid VkImageTiling value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter", - "text": " usage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter", - "text": " flags must be a valid combination of VkImageCreateFlagBits values" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter", - "text": " pImageFormatProperties must be a valid pointer to a VkImageFormatProperties structure" - } - ] - }, - "vkGetPhysicalDeviceExternalImageFormatPropertiesNV": { - "(VK_NV_external_memory_capabilities)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter", - "text": " type must be a valid VkImageType value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter", - "text": " tiling must be a valid VkImageTiling value" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter", - "text": " usage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter", - "text": " flags must be a valid combination of VkImageCreateFlagBits values" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter", - "text": " externalHandleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter", - "text": " pExternalImageFormatProperties must be a valid pointer to a VkExternalImageFormatPropertiesNV structure" - } - ] - }, - "vkGetPhysicalDeviceImageFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868", - "text": " If the pNext chain of pImageFormatProperties contains an instance of VkAndroidHardwareBufferUsageANDROID, the pNext chain of pImageFormatInfo must contain an instance of VkPhysicalDeviceExternalImageFormatInfo with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID." - } - ], - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter", - "text": " pImageFormatInfo must be a valid pointer to a valid VkPhysicalDeviceImageFormatInfo2 structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", - "text": " pImageFormatProperties must be a valid pointer to a VkImageFormatProperties2 structure" - } - ] - }, - "VkPhysicalDeviceImageFormatInfo2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2" - }, - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext", - "text": " pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceExternalImageFormatInfo" - }, - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter", - "text": " format must be a valid VkFormat value" - }, - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter", - "text": " type must be a valid VkImageType value" - }, - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter", - "text": " tiling must be a valid VkImageTiling value" - }, - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter", - "text": " usage must be a valid combination of VkImageUsageFlagBits values" - }, - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter", - "text": " flags must be a valid combination of VkImageCreateFlagBits values" - } - ] - }, - "VkImageFormatProperties2": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ - { - "vuid": "VUID-VkImageFormatProperties2-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2" - }, - { - "vuid": "VUID-VkImageFormatProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkSamplerYcbcrConversionImageFormatProperties, or VkTextureLODGatherFormatPropertiesAMD" - }, - { - "vuid": "VUID-VkImageFormatProperties2-sType-unique", - "text": " Each sType member in the pNext chain must be unique" - } - ] - }, - "VkPhysicalDeviceExternalImageFormatInfo": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ - { - "vuid": "VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter", - "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - } - ] - }, - "VkExternalImageFormatProperties": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ - { - "vuid": "VUID-VkExternalImageFormatProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES" - } - ] - }, - "VkSamplerYcbcrConversionImageFormatProperties": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ - { - "vuid": "VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES" - } - ] - }, - "VkAndroidHardwareBufferUsageANDROID": { - "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ - { - "vuid": "VUID-VkAndroidHardwareBufferUsageANDROID-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID" - } - ] - }, - "vkGetPhysicalDeviceExternalBufferProperties": { - "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter", - "text": " pExternalBufferInfo must be a valid pointer to a valid VkPhysicalDeviceExternalBufferInfo structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter", - "text": " pExternalBufferProperties must be a valid pointer to a VkExternalBufferProperties structure" - } - ] - }, - "VkPhysicalDeviceExternalBufferInfo": { - "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ - { - "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter", - "text": " flags must be a valid combination of VkBufferCreateFlagBits values" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter", - "text": " usage must be a valid combination of VkBufferUsageFlagBits values" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask", - "text": " usage must not be 0" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter", - "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" - } - ] - }, - "VkExternalBufferProperties": { - "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ - { - "vuid": "VUID-VkExternalBufferProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES" - }, - { - "vuid": "VUID-VkExternalBufferProperties-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetPhysicalDeviceExternalSemaphoreProperties": { - "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter", - "text": " pExternalSemaphoreInfo must be a valid pointer to a valid VkPhysicalDeviceExternalSemaphoreInfo structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter", - "text": " pExternalSemaphoreProperties must be a valid pointer to a VkExternalSemaphoreProperties structure" - } - ] - }, - "VkPhysicalDeviceExternalSemaphoreInfo": { - "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ - { - "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter", - "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" - } - ] - }, - "VkExternalSemaphoreProperties": { - "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ - { - "vuid": "VUID-VkExternalSemaphoreProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES" - }, - { - "vuid": "VUID-VkExternalSemaphoreProperties-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkGetPhysicalDeviceExternalFenceProperties": { - "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ - { - "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", - "text": " physicalDevice must be a valid VkPhysicalDevice handle" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter", - "text": " pExternalFenceInfo must be a valid pointer to a valid VkPhysicalDeviceExternalFenceInfo structure" - }, - { - "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter", - "text": " pExternalFenceProperties must be a valid pointer to a VkExternalFenceProperties structure" - } - ] - }, - "VkPhysicalDeviceExternalFenceInfo": { - "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ - { - "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter", - "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" - } - ] - }, - "VkExternalFenceProperties": { - "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ - { - "vuid": "VUID-VkExternalFenceProperties-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES" - }, - { - "vuid": "VUID-VkExternalFenceProperties-pNext-pNext", - "text": " pNext must be NULL" - } - ] - }, - "vkSetDebugUtilsObjectNameEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter", - "text": " pNameInfo must be a valid pointer to a valid VkDebugUtilsObjectNameInfoEXT structure" - } - ] - }, - "VkDebugUtilsObjectNameInfoEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-01905", - "text": " objectType must not be VK_OBJECT_TYPE_UNKNOWN" - }, - { - "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01906", - "text": " objectHandle must not be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectHandle-01907", - "text": " objectHandle must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debugging-object-types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT" - }, - { - "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter", - "text": " objectType must be a valid VkObjectType value" - }, - { - "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter", - "text": " If pObjectName is not NULL, pObjectName must be a null-terminated UTF-8 string" - } - ] - }, - "vkSetDebugUtilsObjectTagEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkSetDebugUtilsObjectTagEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter", - "text": " pTagInfo must be a valid pointer to a valid VkDebugUtilsObjectTagInfoEXT structure" - } - ] - }, - "VkDebugUtilsObjectTagInfoEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908", - "text": " objectType must not be VK_OBJECT_TYPE_UNKNOWN" - }, - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01909", - "text": " objectHandle must not be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910", - "text": " objectHandle must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debugging-object-types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT" - }, - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter", - "text": " objectType must be a valid VkObjectType value" - }, - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter", - "text": " pTag must be a valid pointer to an array of tagSize bytes" - }, - { - "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength", - "text": " tagSize must be greater than 0" - } - ] - }, - "vkQueueBeginDebugUtilsLabelEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter", - "text": " queue must be a valid VkQueue handle" - }, - { - "vuid": "VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter", - "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" - } - ] - }, - "VkDebugUtilsLabelEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-VkDebugUtilsLabelEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT" - }, - { - "vuid": "VUID-VkDebugUtilsLabelEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDebugUtilsLabelEXT-pLabelName-parameter", - "text": " pLabelName must be a null-terminated UTF-8 string" - } - ] - }, - "vkQueueEndDebugUtilsLabelEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkQueueEndDebugUtilsLabelEXT-None-01911", - "text": " There must be an outstanding vkQueueBeginDebugUtilsLabelEXT command prior to the vkQueueEndDebugUtilsLabelEXT on the queue" - }, - { - "vuid": "VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter", - "text": " queue must be a valid VkQueue handle" - } - ] - }, - "vkQueueInsertDebugUtilsLabelEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter", - "text": " queue must be a valid VkQueue handle" - }, - { - "vuid": "VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter", - "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" - } - ] - }, - "vkCmdBeginDebugUtilsLabelEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter", - "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" - }, - { - "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - } - ] - }, - "vkCmdEndDebugUtilsLabelEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912", - "text": " There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to" - }, - { - "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913", - "text": " If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT." - }, - { - "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - } - ] - }, - "vkCmdInsertDebugUtilsLabelEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter", - "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" - }, - { - "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - } - ] - }, - "vkCreateDebugUtilsMessengerEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDebugUtilsMessengerCreateInfoEXT structure" - }, - { - "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter", - "text": " pMessenger must be a valid pointer to a VkDebugUtilsMessengerEXT handle" - } - ] - }, - "VkDebugUtilsMessengerCreateInfoEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914", - "text": " pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter", - "text": " messageSeverity must be a valid combination of VkDebugUtilsMessageSeverityFlagBitsEXT values" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask", - "text": " messageSeverity must not be 0" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter", - "text": " messageType must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask", - "text": " messageType must not be 0" - } - ] - }, - "VkDebugUtilsMessengerCallbackDataEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask", - "text": " flags must be 0" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter", - "text": " If pMessageIdName is not NULL, pMessageIdName must be a null-terminated UTF-8 string" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter", - "text": " pMessage must be a null-terminated UTF-8 string" - }, - { - "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-objectCount-arraylength", - "text": " objectCount must be greater than 0" - } - ] - }, - "vkSubmitDebugUtilsMessageEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter", - "text": " messageSeverity must be a valid VkDebugUtilsMessageSeverityFlagBitsEXT value" - }, - { - "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter", - "text": " messageTypes must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values" - }, - { - "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask", - "text": " messageTypes must not be 0" - }, - { - "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter", - "text": " pCallbackData must be a valid pointer to a valid VkDebugUtilsMessengerCallbackDataEXT structure" - } - ] - }, - "vkDestroyDebugUtilsMessengerEXT": { - "(VK_EXT_debug_utils)": [ - { - "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915", - "text": " If VkAllocationCallbacks were provided when messenger was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916", - "text": " If no VkAllocationCallbacks were provided when messenger was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter", - "text": " messenger must be a valid VkDebugUtilsMessengerEXT handle" - }, - { - "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent", - "text": " messenger must have been created, allocated, or retrieved from instance" - } - ] - }, - "vkDebugMarkerSetObjectNameEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-vkDebugMarkerSetObjectNameEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDebugMarkerSetObjectNameEXT-pNameInfo-parameter", - "text": " pNameInfo must be a valid pointer to a valid VkDebugMarkerObjectNameInfoEXT structure" - } - ] - }, - "VkDebugMarkerObjectNameInfoEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490", - "text": " objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT" - }, - { - "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-object-01491", - "text": " object must not be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-object-01492", - "text": " object must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debug-report-object-types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT" - }, - { - "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-objectType-parameter", - "text": " objectType must be a valid VkDebugReportObjectTypeEXT value" - }, - { - "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-pObjectName-parameter", - "text": " pObjectName must be a null-terminated UTF-8 string" - } - ] - }, - "vkDebugMarkerSetObjectTagEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-vkDebugMarkerSetObjectTagEXT-device-parameter", - "text": " device must be a valid VkDevice handle" - }, - { - "vuid": "VUID-vkDebugMarkerSetObjectTagEXT-pTagInfo-parameter", - "text": " pTagInfo must be a valid pointer to a valid VkDebugMarkerObjectTagInfoEXT structure" - } - ] - }, - "VkDebugMarkerObjectTagInfoEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493", - "text": " objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT" - }, - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-object-01494", - "text": " object must not be VK_NULL_HANDLE" - }, - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-object-01495", - "text": " object must be a Vulkan object of the type associated with objectType as defined in &amp;lt;&amp;lt;debug-report-object-types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT" - }, - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-objectType-parameter", - "text": " objectType must be a valid VkDebugReportObjectTypeEXT value" - }, - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-pTag-parameter", - "text": " pTag must be a valid pointer to an array of tagSize bytes" - }, - { - "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-tagSize-arraylength", - "text": " tagSize must be greater than 0" - } - ] - }, - "vkCmdDebugMarkerBeginEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDebugMarkerBeginEXT-pMarkerInfo-parameter", - "text": " pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure" - }, - { - "vuid": "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - } - ] - }, - "VkDebugMarkerMarkerInfoEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-VkDebugMarkerMarkerInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT" - }, - { - "vuid": "VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext", - "text": " pNext must be NULL" - }, - { - "vuid": "VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter", - "text": " pMarkerName must be a null-terminated UTF-8 string" - } - ] - }, - "vkCmdDebugMarkerEndEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239", - "text": " There must be an outstanding vkCmdDebugMarkerBeginEXT command prior to the vkCmdDebugMarkerEndEXT on the queue that commandBuffer is submitted to" - }, - { - "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240", - "text": " If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT." - }, - { - "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - } - ] - }, - "vkCmdDebugMarkerInsertEXT": { - "(VK_EXT_debug_marker)": [ - { - "vuid": "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter", - "text": " commandBuffer must be a valid VkCommandBuffer handle" - }, - { - "vuid": "VUID-vkCmdDebugMarkerInsertEXT-pMarkerInfo-parameter", - "text": " pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure" - }, - { - "vuid": "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-recording", - "text": " commandBuffer must be in the &amp;lt;&amp;lt;commandbuffers-lifecycle, recording state&amp;gt;&amp;gt;" - }, - { - "vuid": "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" - } - ] - }, - "vkCreateDebugReportCallbackEXT": { - "(VK_EXT_debug_report)": [ - { - "vuid": "VUID-vkCreateDebugReportCallbackEXT-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkCreateDebugReportCallbackEXT-pCreateInfo-parameter", - "text": " pCreateInfo must be a valid pointer to a valid VkDebugReportCallbackCreateInfoEXT structure" - }, - { - "vuid": "VUID-vkCreateDebugReportCallbackEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkCreateDebugReportCallbackEXT-pCallback-parameter", - "text": " pCallback must be a valid pointer to a VkDebugReportCallbackEXT handle" - } - ] - }, - "VkDebugReportCallbackCreateInfoEXT": { - "(VK_EXT_debug_report)": [ - { - "vuid": "VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-01385", - "text": " pfnCallback must be a valid PFN_vkDebugReportCallbackEXT" - }, - { - "vuid": "VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT" - }, - { - "vuid": "VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter", - "text": " flags must be a valid combination of VkDebugReportFlagBitsEXT values" - } - ] - }, - "vkDebugReportMessageEXT": { - "(VK_EXT_debug_report)": [ - { - "vuid": "VUID-vkDebugReportMessageEXT-object-01241", - "text": " object must be a Vulkan object or VK_NULL_HANDLE" - }, - { - "vuid": "VUID-vkDebugReportMessageEXT-objectType-01498", - "text": " If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in &amp;lt;&amp;lt;debug-report-object-types&amp;gt;&amp;gt;." - }, - { - "vuid": "VUID-vkDebugReportMessageEXT-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkDebugReportMessageEXT-flags-parameter", - "text": " flags must be a valid combination of VkDebugReportFlagBitsEXT values" - }, - { - "vuid": "VUID-vkDebugReportMessageEXT-flags-requiredbitmask", - "text": " flags must not be 0" - }, - { - "vuid": "VUID-vkDebugReportMessageEXT-objectType-parameter", - "text": " objectType must be a valid VkDebugReportObjectTypeEXT value" - }, - { - "vuid": "VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter", - "text": " pLayerPrefix must be a null-terminated UTF-8 string" - }, - { - "vuid": "VUID-vkDebugReportMessageEXT-pMessage-parameter", - "text": " pMessage must be a null-terminated UTF-8 string" - } - ] - }, - "vkDestroyDebugReportCallbackEXT": { - "(VK_EXT_debug_report)": [ - { - "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01242", - "text": " If VkAllocationCallbacks were provided when callback was created, a compatible set of callbacks must be provided here" - }, - { - "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01243", - "text": " If no VkAllocationCallbacks were provided when callback was created, pAllocator must be NULL" - }, - { - "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-parameter", - "text": " instance must be a valid VkInstance handle" - }, - { - "vuid": "VUID-vkDestroyDebugReportCallbackEXT-callback-parameter", - "text": " callback must be a valid VkDebugReportCallbackEXT handle" - }, - { - "vuid": "VUID-vkDestroyDebugReportCallbackEXT-pAllocator-parameter", - "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" - }, - { - "vuid": "VUID-vkDestroyDebugReportCallbackEXT-callback-parent", - "text": " callback must have been created, allocated, or retrieved from instance" - } - ] - } - } -} \ No newline at end of file diff --git a/generator/Vulkan-Headers/registry/vk.xml b/generator/Vulkan-Headers/registry/vk.xml deleted file mode 100644 index 99f0c6a..0000000 --- a/generator/Vulkan-Headers/registry/vk.xml +++ /dev/null @@ -1,8842 +0,0 @@ - - - -Copyright (c) 2015-2018 The Khronos Group Inc. - -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. - ----- Exceptions to the Apache 2.0 License: ---- - -As an exception, if you use this Software to generate code and portions of -this Software are embedded into the generated code as a result, you may -redistribute such product without providing attribution as would otherwise -be required by Sections 4(a), 4(b) and 4(d) of the License. - -In addition, if you combine or link code generated by this Software with -software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1 -("`Combined Software`") and if a court of competent jurisdiction determines -that the patent provision (Section 3), the indemnity provision (Section 9) -or other Section of the License conflicts with the conditions of the -applicable GPL or LGPL license, you may retroactively and prospectively -choose to deem waived or otherwise exclude such Section(s) of the License, -but only in their entirety and only with respect to the Combined Software. - - - -This file, vk.xml, is the Vulkan API Registry. It is a critically important -and normative part of the Vulkan Specification, including a canonical -machine-readable definition of the API, parameter and member validation -language incorporated into the Specification and reference pages, and other -material which is registered by Khronos, such as tags used by extension and -layer authors. The authoritative public version of vk.xml is maintained in -the master branch of the Khronos Vulkan GitHub project. The authoritative -private version is maintained in the master branch of the member gitlab -server. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "vk_platform.h" - - WSI extensions - - - - - - - - - In the current header structure, each platform's interfaces - are confined to a platform-specific header (vulkan_xlib.h, - vulkan_win32.h, etc.). These headers are not self-contained, - and should not include native headers (X11/Xlib.h, - windows.h, etc.). Code should either include vulkan.h after - defining the appropriate VK_USE_PLATFORM_platform_KHR - macros, or include the required native headers prior to - explicitly including the corresponding platform header. - - To accomplish this, the dependencies of native types require - native headers, but the XML defines the content for those - native headers as empty. The actual native header includes - can be restored by modifying the native header tags above - to #include the header file in the 'name' attribute. - - - - - - - - - - - - - - - - - - - - - #define VK_MAKE_VERSION(major, minor, patch) \ - (((major) << 22) | ((minor) << 12) | (patch)) - #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) - #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) - #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) - - // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. -//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 - // Vulkan 1.0 version number -#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 - // Vulkan 1.1 version number -#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 - // Version of this file -#define VK_HEADER_VERSION 79 - - -#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; - - -#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) -#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; -#else - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; -#endif -#endif - - - -#define VK_NULL_HANDLE 0 - - - struct ANativeWindow; - struct AHardwareBuffer; - - typedef uint32_t VkSampleMask; - typedef uint32_t VkBool32; - typedef uint32_t VkFlags; - typedef uint64_t VkDeviceSize; - - Basic C types, pulled in via vk_platform.h - - - - - - - - - - - Bitmask types - typedef VkFlags VkFramebufferCreateFlags; - typedef VkFlags VkQueryPoolCreateFlags; - typedef VkFlags VkRenderPassCreateFlags; - typedef VkFlags VkSamplerCreateFlags; - typedef VkFlags VkPipelineLayoutCreateFlags; - typedef VkFlags VkPipelineCacheCreateFlags; - typedef VkFlags VkPipelineDepthStencilStateCreateFlags; - typedef VkFlags VkPipelineDynamicStateCreateFlags; - typedef VkFlags VkPipelineColorBlendStateCreateFlags; - typedef VkFlags VkPipelineMultisampleStateCreateFlags; - typedef VkFlags VkPipelineRasterizationStateCreateFlags; - typedef VkFlags VkPipelineViewportStateCreateFlags; - typedef VkFlags VkPipelineTessellationStateCreateFlags; - typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; - typedef VkFlags VkPipelineVertexInputStateCreateFlags; - typedef VkFlags VkPipelineShaderStageCreateFlags; - typedef VkFlags VkDescriptorSetLayoutCreateFlags; - typedef VkFlags VkBufferViewCreateFlags; - typedef VkFlags VkInstanceCreateFlags; - typedef VkFlags VkDeviceCreateFlags; - typedef VkFlags VkDeviceQueueCreateFlags; - typedef VkFlags VkQueueFlags; - typedef VkFlags VkMemoryPropertyFlags; - typedef VkFlags VkMemoryHeapFlags; - typedef VkFlags VkAccessFlags; - typedef VkFlags VkBufferUsageFlags; - typedef VkFlags VkBufferCreateFlags; - typedef VkFlags VkShaderStageFlags; - typedef VkFlags VkImageUsageFlags; - typedef VkFlags VkImageCreateFlags; - typedef VkFlags VkImageViewCreateFlags; - typedef VkFlags VkPipelineCreateFlags; - typedef VkFlags VkColorComponentFlags; - typedef VkFlags VkFenceCreateFlags; - typedef VkFlags VkSemaphoreCreateFlags; - typedef VkFlags VkFormatFeatureFlags; - typedef VkFlags VkQueryControlFlags; - typedef VkFlags VkQueryResultFlags; - typedef VkFlags VkShaderModuleCreateFlags; - typedef VkFlags VkEventCreateFlags; - typedef VkFlags VkCommandPoolCreateFlags; - typedef VkFlags VkCommandPoolResetFlags; - typedef VkFlags VkCommandBufferResetFlags; - typedef VkFlags VkCommandBufferUsageFlags; - typedef VkFlags VkQueryPipelineStatisticFlags; - typedef VkFlags VkMemoryMapFlags; - typedef VkFlags VkImageAspectFlags; - typedef VkFlags VkSparseMemoryBindFlags; - typedef VkFlags VkSparseImageFormatFlags; - typedef VkFlags VkSubpassDescriptionFlags; - typedef VkFlags VkPipelineStageFlags; - typedef VkFlags VkSampleCountFlags; - typedef VkFlags VkAttachmentDescriptionFlags; - typedef VkFlags VkStencilFaceFlags; - typedef VkFlags VkCullModeFlags; - typedef VkFlags VkDescriptorPoolCreateFlags; - typedef VkFlags VkDescriptorPoolResetFlags; - typedef VkFlags VkDependencyFlags; - typedef VkFlags VkSubgroupFeatureFlags; - typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; - typedef VkFlags VkObjectEntryUsageFlagsNVX; - - typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; - - - WSI extensions - typedef VkFlags VkCompositeAlphaFlagsKHR; - typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; - typedef VkFlags VkSurfaceTransformFlagsKHR; - typedef VkFlags VkSwapchainCreateFlagsKHR; - typedef VkFlags VkDisplayModeCreateFlagsKHR; - typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; - typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; - typedef VkFlags VkMirSurfaceCreateFlagsKHR; - typedef VkFlags VkViSurfaceCreateFlagsNN; - typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; - typedef VkFlags VkWin32SurfaceCreateFlagsKHR; - typedef VkFlags VkXlibSurfaceCreateFlagsKHR; - typedef VkFlags VkXcbSurfaceCreateFlagsKHR; - typedef VkFlags VkIOSSurfaceCreateFlagsMVK; - typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; - typedef VkFlags VkPeerMemoryFeatureFlags; - - typedef VkFlags VkMemoryAllocateFlags; - - typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; - - typedef VkFlags VkDebugReportFlagsEXT; - typedef VkFlags VkCommandPoolTrimFlags; - - typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; - typedef VkFlags VkExternalMemoryFeatureFlagsNV; - typedef VkFlags VkExternalMemoryHandleTypeFlags; - - typedef VkFlags VkExternalMemoryFeatureFlags; - - typedef VkFlags VkExternalSemaphoreHandleTypeFlags; - - typedef VkFlags VkExternalSemaphoreFeatureFlags; - - typedef VkFlags VkSemaphoreImportFlags; - - typedef VkFlags VkExternalFenceHandleTypeFlags; - - typedef VkFlags VkExternalFenceFeatureFlags; - - typedef VkFlags VkFenceImportFlags; - - typedef VkFlags VkSurfaceCounterFlagsEXT; - typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; - typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; - typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; - typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; - typedef VkFlags VkValidationCacheCreateFlagsEXT; - typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; - typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; - typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; - typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; - typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; - typedef VkFlags VkDescriptorBindingFlagsEXT; - - Types which can be void pointers or class pointers, selected at compile time - VK_DEFINE_HANDLE(VkInstance) - VK_DEFINE_HANDLE(VkPhysicalDevice) - VK_DEFINE_HANDLE(VkDevice) - VK_DEFINE_HANDLE(VkQueue) - VK_DEFINE_HANDLE(VkCommandBuffer) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) - - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) - - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) - - WSI extensions - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) - VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) - - Types generated from corresponding enums tags below - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Extensions - - - - - - - - - - - - - - - - - - WSI extensions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Enumerated types in the header, but not used by the API - - - The PFN_vk*Function types are used by VkAllocationCallbacks below - typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( - void* pUserData, - void* pOriginal, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - typedef void (VKAPI_PTR *PFN_vkFreeFunction)( - void* pUserData, - void* pMemory); - - The PFN_vkVoidFunction type are used by VkGet*ProcAddr below - typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); - - The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension - typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage, - void* pUserData); - - The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension - typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData); - - Struct types - - VkStructureType sType - struct VkBaseOutStructure* pNext - - - VkStructureType sType - const struct VkBaseInStructure* pNext - - - int32_t x - int32_t y - - - int32_t x - int32_t y - int32_t z - - - uint32_t width - uint32_t height - - - uint32_t width - uint32_t height - uint32_t depth - - - float x - float y - float width - float height - float minDepth - float maxDepth - - - VkOffset2D offset - VkExtent2D extent - - - VkRect2D rect - uint32_t baseArrayLayer - uint32_t layerCount - - - VkComponentSwizzle r - VkComponentSwizzle g - VkComponentSwizzle b - VkComponentSwizzle a - - - uint32_t apiVersion - uint32_t driverVersion - uint32_t vendorID - uint32_t deviceID - VkPhysicalDeviceType deviceType - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] - uint8_t pipelineCacheUUID[VK_UUID_SIZE] - VkPhysicalDeviceLimits limits - VkPhysicalDeviceSparseProperties sparseProperties - - - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]extension name - uint32_t specVersionversion of the extension specification implemented - - - char layerName[VK_MAX_EXTENSION_NAME_SIZE]layer name - uint32_t specVersionversion of the layer specification implemented - uint32_t implementationVersionbuild or release version of the layer's library - char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the layer - - - VkStructureType sType - const void* pNext - const char* pApplicationName - uint32_t applicationVersion - const char* pEngineName - uint32_t engineVersion - uint32_t apiVersion - - - void* pUserData - PFN_vkAllocationFunction pfnAllocation - PFN_vkReallocationFunction pfnReallocation - PFN_vkFreeFunction pfnFree - PFN_vkInternalAllocationNotification pfnInternalAllocation - PFN_vkInternalFreeNotification pfnInternalFree - - - VkStructureType sType - const void* pNext - VkDeviceQueueCreateFlags flags - uint32_t queueFamilyIndex - uint32_t queueCount - const float* pQueuePriorities - - - VkStructureType sType - const void* pNext - VkDeviceCreateFlags flags - uint32_t queueCreateInfoCount - const VkDeviceQueueCreateInfo* pQueueCreateInfos - uint32_t enabledLayerCount - const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled - uint32_t enabledExtensionCount - const char* const* ppEnabledExtensionNames - const VkPhysicalDeviceFeatures* pEnabledFeatures - - - VkStructureType sType - const void* pNext - VkInstanceCreateFlags flags - const VkApplicationInfo* pApplicationInfo - uint32_t enabledLayerCount - const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled - uint32_t enabledExtensionCount - const char* const* ppEnabledExtensionNamesExtension names to be enabled - - - VkQueueFlags queueFlagsQueue flags - uint32_t queueCount - uint32_t timestampValidBits - VkExtent3D minImageTransferGranularityMinimum alignment requirement for image transfers - - - uint32_t memoryTypeCount - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES] - uint32_t memoryHeapCount - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] - - - VkStructureType sType - const void* pNext - VkDeviceSize allocationSizeSize of memory allocation - uint32_t memoryTypeIndexIndex of the of the memory type to allocate from - - - VkDeviceSize sizeSpecified in bytes - VkDeviceSize alignmentSpecified in bytes - uint32_t memoryTypeBitsBitmask of the allowed memory type indices into memoryTypes[] for this object - - - VkImageAspectFlags aspectMask - VkExtent3D imageGranularity - VkSparseImageFormatFlags flags - - - VkSparseImageFormatProperties formatProperties - uint32_t imageMipTailFirstLod - VkDeviceSize imageMipTailSizeSpecified in bytes, must be a multiple of sparse block size in bytes / alignment - VkDeviceSize imageMipTailOffsetSpecified in bytes, must be a multiple of sparse block size in bytes / alignment - VkDeviceSize imageMipTailStrideSpecified in bytes, must be a multiple of sparse block size in bytes / alignment - - - VkMemoryPropertyFlags propertyFlagsMemory properties of this memory type - uint32_t heapIndexIndex of the memory heap allocations of this memory type are taken from - - - VkDeviceSize sizeAvailable memory in the heap - VkMemoryHeapFlags flagsFlags for the heap - - - VkStructureType sType - const void* pNext - VkDeviceMemory memoryMapped memory object - VkDeviceSize offsetOffset within the memory object where the range starts - VkDeviceSize sizeSize of the range within the memory object - - - VkFormatFeatureFlags linearTilingFeaturesFormat features in case of linear tiling - VkFormatFeatureFlags optimalTilingFeaturesFormat features in case of optimal tiling - VkFormatFeatureFlags bufferFeaturesFormat features supported by buffers - - - VkExtent3D maxExtentmax image dimensions for this resource type - uint32_t maxMipLevelsmax number of mipmap levels for this resource type - uint32_t maxArrayLayersmax array size for this resource type - VkSampleCountFlags sampleCountssupported sample counts for this resource type - VkDeviceSize maxResourceSizemax size (in bytes) of this resource type - - - VkBuffer bufferBuffer used for this descriptor slot when the descriptor is UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC]. VK_NULL_HANDLE otherwise. - VkDeviceSize offsetBase offset from buffer start in bytes to update in the descriptor set. - VkDeviceSize rangeSize in bytes of the buffer resource for this descriptor update. - - - VkSampler samplerSampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise. - VkImageView imageViewImage view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise. - VkImageLayout imageLayoutLayout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE). - - - VkStructureType sType - const void* pNext - VkDescriptorSet dstSetDestination descriptor set - uint32_t dstBindingBinding within the destination descriptor set to write - uint32_t dstArrayElementArray element within the destination binding to write - uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) - VkDescriptorType descriptorTypeDescriptor type to write (determines which members of the array pointed by pDescriptors are going to be used) - const VkDescriptorImageInfo* pImageInfoSampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types. - const VkDescriptorBufferInfo* pBufferInfoRaw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types. - const VkBufferView* pTexelBufferViewBuffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types. - - - VkStructureType sType - const void* pNext - VkDescriptorSet srcSetSource descriptor set - uint32_t srcBindingBinding within the source descriptor set to copy from - uint32_t srcArrayElementArray element within the source binding to copy from - VkDescriptorSet dstSetDestination descriptor set - uint32_t dstBindingBinding within the destination descriptor set to copy to - uint32_t dstArrayElementArray element within the destination binding to copy to - uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) - - - VkStructureType sType - const void* pNext - VkBufferCreateFlags flagsBuffer creation flags - VkDeviceSize sizeSpecified in bytes - VkBufferUsageFlags usageBuffer usage flags - VkSharingMode sharingMode - uint32_t queueFamilyIndexCount - const uint32_t* pQueueFamilyIndices - - - VkStructureType sType - const void* pNext - VkBufferViewCreateFlagsflags - VkBuffer buffer - VkFormat formatOptionally specifies format of elements - VkDeviceSize offsetSpecified in bytes - VkDeviceSize rangeView size specified in bytes - - - VkImageAspectFlags aspectMask - uint32_t mipLevel - uint32_t arrayLayer - - - VkImageAspectFlags aspectMask - uint32_t mipLevel - uint32_t baseArrayLayer - uint32_t layerCount - - - VkImageAspectFlags aspectMask - uint32_t baseMipLevel - uint32_t levelCount - uint32_t baseArrayLayer - uint32_t layerCount - - - VkStructureType sType - const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - - - VkStructureType sType - const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - uint32_t srcQueueFamilyIndexQueue family to transition ownership from - uint32_t dstQueueFamilyIndexQueue family to transition ownership to - VkBuffer bufferBuffer to sync - VkDeviceSize offsetOffset within the buffer to sync - VkDeviceSize sizeAmount of bytes to sync - - - VkStructureType sType - const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - VkImageLayout oldLayoutCurrent layout of the image - VkImageLayout newLayoutNew layout to transition the image to - uint32_t srcQueueFamilyIndexQueue family to transition ownership from - uint32_t dstQueueFamilyIndexQueue family to transition ownership to - VkImage imageImage to sync - VkImageSubresourceRange subresourceRangeSubresource range to sync - - - VkStructureType sType - const void* pNext - VkImageCreateFlags flagsImage creation flags - VkImageType imageType - VkFormat format - VkExtent3D extent - uint32_t mipLevels - uint32_t arrayLayers - VkSampleCountFlagBits samples - VkImageTiling tiling - VkImageUsageFlags usageImage usage flags - VkSharingMode sharingModeCross-queue-family sharing mode - uint32_t queueFamilyIndexCountNumber of queue families to share across - const uint32_t* pQueueFamilyIndicesArray of queue family indices to share across - VkImageLayout initialLayoutInitial image layout for all subresources - - - VkDeviceSize offsetSpecified in bytes - VkDeviceSize sizeSpecified in bytes - VkDeviceSize rowPitchSpecified in bytes - VkDeviceSize arrayPitchSpecified in bytes - VkDeviceSize depthPitchSpecified in bytes - - - VkStructureType sType - const void* pNext - VkImageViewCreateFlags flags - VkImage image - VkImageViewType viewType - VkFormat format - VkComponentMapping components - VkImageSubresourceRange subresourceRange - - - VkDeviceSize srcOffsetSpecified in bytes - VkDeviceSize dstOffsetSpecified in bytes - VkDeviceSize sizeSpecified in bytes - - - VkDeviceSize resourceOffsetSpecified in bytes - VkDeviceSize sizeSpecified in bytes - VkDeviceMemory memory - VkDeviceSize memoryOffsetSpecified in bytes - VkSparseMemoryBindFlagsflags - - - VkImageSubresource subresource - VkOffset3D offset - VkExtent3D extent - VkDeviceMemory memory - VkDeviceSize memoryOffsetSpecified in bytes - VkSparseMemoryBindFlagsflags - - - VkBuffer buffer - uint32_t bindCount - const VkSparseMemoryBind* pBinds - - - VkImage image - uint32_t bindCount - const VkSparseMemoryBind* pBinds - - - VkImage image - uint32_t bindCount - const VkSparseImageMemoryBind* pBinds - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - uint32_t bufferBindCount - const VkSparseBufferMemoryBindInfo* pBufferBinds - uint32_t imageOpaqueBindCount - const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds - uint32_t imageBindCount - const VkSparseImageMemoryBindInfo* pImageBinds - uint32_t signalSemaphoreCount - const VkSemaphore* pSignalSemaphores - - - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images - VkExtent3D extentSpecified in pixels for both compressed and uncompressed images - - - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images - - - VkDeviceSize bufferOffsetSpecified in bytes - uint32_t bufferRowLengthSpecified in texels - uint32_t bufferImageHeight - VkImageSubresourceLayers imageSubresource - VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images - VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images - - - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffset - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffset - VkExtent3D extent - - - VkStructureType sType - const void* pNext - VkShaderModuleCreateFlags flags - size_t codeSizeSpecified in bytes - const uint32_t* pCodeBinary code of size codeSize - - - uint32_t bindingBinding number for this entry - VkDescriptorType descriptorTypeType of the descriptors in this binding - uint32_t descriptorCountNumber of descriptors in this binding - VkShaderStageFlags stageFlagsShader stages this binding is visible to - const VkSampler* pImmutableSamplersImmutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements) - - - VkStructureType sType - const void* pNext - VkDescriptorSetLayoutCreateFlags flags - uint32_t bindingCountNumber of bindings in the descriptor set layout - const VkDescriptorSetLayoutBinding* pBindingsArray of descriptor set layout bindings - - - VkDescriptorType type - uint32_t descriptorCount - - - VkStructureType sType - const void* pNext - VkDescriptorPoolCreateFlags flags - uint32_t maxSets - uint32_t poolSizeCount - const VkDescriptorPoolSize* pPoolSizes - - - VkStructureType sType - const void* pNext - VkDescriptorPool descriptorPool - uint32_t descriptorSetCount - const VkDescriptorSetLayout* pSetLayouts - - - uint32_t constantIDThe SpecConstant ID specified in the BIL - uint32_t offsetOffset of the value in the data block - size_t sizeSize in bytes of the SpecConstant - - - uint32_t mapEntryCountNumber of entries in the map - const VkSpecializationMapEntry* pMapEntriesArray of map entries - size_t dataSizeSize in bytes of pData - const void* pDataPointer to SpecConstant data - - - VkStructureType sType - const void* pNext - VkPipelineShaderStageCreateFlags flags - VkShaderStageFlagBits stageShader stage - VkShaderModule moduleModule containing entry point - const char* pNameNull-terminated entry point name - const VkSpecializationInfo* pSpecializationInfo - - - VkStructureType sType - const void* pNext - VkPipelineCreateFlags flagsPipeline creation flags - VkPipelineShaderStageCreateInfo stage - VkPipelineLayout layoutInterface layout of the pipeline - VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of - int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of - - - uint32_t bindingVertex buffer binding id - uint32_t strideDistance between vertices in bytes (0 = no advancement) - VkVertexInputRate inputRateThe rate at which the vertex data is consumed - - - uint32_t locationlocation of the shader vertex attrib - uint32_t bindingVertex buffer binding id - VkFormat formatformat of source data - uint32_t offsetOffset of first element in bytes from base of vertex - - - VkStructureType sType - const void* pNext - VkPipelineVertexInputStateCreateFlags flags - uint32_t vertexBindingDescriptionCountnumber of bindings - const VkVertexInputBindingDescription* pVertexBindingDescriptions - uint32_t vertexAttributeDescriptionCountnumber of attributes - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions - - - VkStructureType sType - const void* pNext - VkPipelineInputAssemblyStateCreateFlags flags - VkPrimitiveTopology topology - VkBool32 primitiveRestartEnable - - - VkStructureType sType - const void* pNext - VkPipelineTessellationStateCreateFlags flags - uint32_t patchControlPoints - - - VkStructureType sType - const void* pNext - VkPipelineViewportStateCreateFlags flags - uint32_t viewportCount - const VkViewport* pViewports - uint32_t scissorCount - const VkRect2D* pScissors - - - VkStructureType sType - const void* pNext - VkPipelineRasterizationStateCreateFlags flags - VkBool32 depthClampEnable - VkBool32 rasterizerDiscardEnable - VkPolygonMode polygonModeoptional (GL45) - VkCullModeFlags cullMode - VkFrontFace frontFace - VkBool32 depthBiasEnable - float depthBiasConstantFactor - float depthBiasClamp - float depthBiasSlopeFactor - float lineWidth - - - VkStructureType sType - const void* pNext - VkPipelineMultisampleStateCreateFlags flags - VkSampleCountFlagBits rasterizationSamplesNumber of samples used for rasterization - VkBool32 sampleShadingEnableoptional (GL45) - float minSampleShadingoptional (GL45) - const VkSampleMask* pSampleMaskArray of sampleMask words - VkBool32 alphaToCoverageEnable - VkBool32 alphaToOneEnable - - - VkBool32 blendEnable - VkBlendFactor srcColorBlendFactor - VkBlendFactor dstColorBlendFactor - VkBlendOp colorBlendOp - VkBlendFactor srcAlphaBlendFactor - VkBlendFactor dstAlphaBlendFactor - VkBlendOp alphaBlendOp - VkColorComponentFlags colorWriteMask - - - VkStructureType sType - const void* pNext - VkPipelineColorBlendStateCreateFlags flags - VkBool32 logicOpEnable - VkLogicOp logicOp - uint32_t attachmentCount# of pAttachments - const VkPipelineColorBlendAttachmentState* pAttachments - float blendConstants[4] - - - VkStructureType sType - const void* pNext - VkPipelineDynamicStateCreateFlags flags - uint32_t dynamicStateCount - const VkDynamicState* pDynamicStates - - - VkStencilOp failOp - VkStencilOp passOp - VkStencilOp depthFailOp - VkCompareOp compareOp - uint32_t compareMask - uint32_t writeMask - uint32_t reference - - - VkStructureType sType - const void* pNext - VkPipelineDepthStencilStateCreateFlags flags - VkBool32 depthTestEnable - VkBool32 depthWriteEnable - VkCompareOp depthCompareOp - VkBool32 depthBoundsTestEnableoptional (depth_bounds_test) - VkBool32 stencilTestEnable - VkStencilOpState front - VkStencilOpState back - float minDepthBounds - float maxDepthBounds - - - VkStructureType sType - const void* pNext - VkPipelineCreateFlags flagsPipeline creation flags - uint32_t stageCount - const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage - const VkPipelineVertexInputStateCreateInfo* pVertexInputState - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState - const VkPipelineTessellationStateCreateInfo* pTessellationState - const VkPipelineViewportStateCreateInfo* pViewportState - const VkPipelineRasterizationStateCreateInfo* pRasterizationState - const VkPipelineMultisampleStateCreateInfo* pMultisampleState - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState - const VkPipelineColorBlendStateCreateInfo* pColorBlendState - const VkPipelineDynamicStateCreateInfo* pDynamicState - VkPipelineLayout layoutInterface layout of the pipeline - VkRenderPass renderPass - uint32_t subpass - VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of - int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of - - - VkStructureType sType - const void* pNext - VkPipelineCacheCreateFlags flags - size_t initialDataSizeSize of initial data to populate cache, in bytes - const void* pInitialDataInitial data to populate cache - - - VkShaderStageFlags stageFlagsWhich stages use the range - uint32_t offsetStart of the range, in bytes - uint32_t sizeSize of the range, in bytes - - - VkStructureType sType - const void* pNext - VkPipelineLayoutCreateFlags flags - uint32_t setLayoutCountNumber of descriptor sets interfaced by the pipeline - const VkDescriptorSetLayout* pSetLayoutsArray of setCount number of descriptor set layout objects defining the layout of the - uint32_t pushConstantRangeCountNumber of push-constant ranges used by the pipeline - const VkPushConstantRange* pPushConstantRangesArray of pushConstantRangeCount number of ranges used by various shader stages - - - VkStructureType sType - const void* pNext - VkSamplerCreateFlags flags - VkFilter magFilterFilter mode for magnification - VkFilter minFilterFilter mode for minifiation - VkSamplerMipmapMode mipmapModeMipmap selection mode - VkSamplerAddressMode addressModeU - VkSamplerAddressMode addressModeV - VkSamplerAddressMode addressModeW - float mipLodBias - VkBool32 anisotropyEnable - float maxAnisotropy - VkBool32 compareEnable - VkCompareOp compareOp - float minLod - float maxLod - VkBorderColor borderColor - VkBool32 unnormalizedCoordinates - - - VkStructureType sType - const void* pNext - VkCommandPoolCreateFlags flagsCommand pool creation flags - uint32_t queueFamilyIndex - - - VkStructureType sType - const void* pNext - VkCommandPool commandPool - VkCommandBufferLevel level - uint32_t commandBufferCount - - - VkStructureType sType - const void* pNext - VkRenderPass renderPassRender pass for secondary command buffers - uint32_t subpass - VkFramebuffer framebufferFramebuffer for secondary command buffers - VkBool32 occlusionQueryEnableWhether this secondary command buffer may be executed during an occlusion query - VkQueryControlFlags queryFlagsQuery flags used by this secondary command buffer, if executed during an occlusion query - VkQueryPipelineStatisticFlags pipelineStatisticsPipeline statistics that may be counted for this secondary command buffer - - - VkStructureType sType - const void* pNext - VkCommandBufferUsageFlags flagsCommand buffer usage flags - const VkCommandBufferInheritanceInfo* pInheritanceInfoPointer to inheritance info for secondary command buffers - - - VkStructureType sType - const void* pNext - VkRenderPass renderPass - VkFramebuffer framebuffer - VkRect2D renderArea - uint32_t clearValueCount - const VkClearValue* pClearValues - - - float float32[4] - int32_t int32[4] - uint32_t uint32[4] - - - float depth - uint32_t stencil - - - VkClearColorValue color - VkClearDepthStencilValue depthStencil - - - VkImageAspectFlags aspectMask - uint32_t colorAttachment - VkClearValue clearValue - - - VkAttachmentDescriptionFlags flags - VkFormat format - VkSampleCountFlagBits samples - VkAttachmentLoadOp loadOpLoad operation for color or depth data - VkAttachmentStoreOp storeOpStore operation for color or depth data - VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data - VkAttachmentStoreOp stencilStoreOpStore operation for stencil data - VkImageLayout initialLayout - VkImageLayout finalLayout - - - uint32_t attachment - VkImageLayout layout - - - VkSubpassDescriptionFlags flags - VkPipelineBindPoint pipelineBindPointMust be VK_PIPELINE_BIND_POINT_GRAPHICS for now - uint32_t inputAttachmentCount - const VkAttachmentReference* pInputAttachments - uint32_t colorAttachmentCount - const VkAttachmentReference* pColorAttachments - const VkAttachmentReference* pResolveAttachments - const VkAttachmentReference* pDepthStencilAttachment - uint32_t preserveAttachmentCount - const uint32_t* pPreserveAttachments - - - uint32_t srcSubpass - uint32_t dstSubpass - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize - VkDependencyFlags dependencyFlags - - - VkStructureType sType - const void* pNext - VkRenderPassCreateFlags flags - uint32_t attachmentCount - const VkAttachmentDescription* pAttachments - uint32_t subpassCount - const VkSubpassDescription* pSubpasses - uint32_t dependencyCount - const VkSubpassDependency* pDependencies - - - VkStructureType sType - const void* pNext - VkEventCreateFlags flagsEvent creation flags - - - VkStructureType sType - const void* pNext - VkFenceCreateFlags flagsFence creation flags - - - VkBool32 robustBufferAccessout of bounds buffer accesses are well defined - VkBool32 fullDrawIndexUint32full 32-bit range of indices for indexed draw calls - VkBool32 imageCubeArrayimage views which are arrays of cube maps - VkBool32 independentBlendblending operations are controlled per-attachment - VkBool32 geometryShadergeometry stage - VkBool32 tessellationShadertessellation control and evaluation stage - VkBool32 sampleRateShadingper-sample shading and interpolation - VkBool32 dualSrcBlendblend operations which take two sources - VkBool32 logicOplogic operations - VkBool32 multiDrawIndirectmulti draw indirect - VkBool32 drawIndirectFirstInstanceindirect draws can use non-zero firstInstance - VkBool32 depthClampdepth clamping - VkBool32 depthBiasClampdepth bias clamping - VkBool32 fillModeNonSolidpoint and wireframe fill modes - VkBool32 depthBoundsdepth bounds test - VkBool32 wideLineslines with width greater than 1 - VkBool32 largePointspoints with size greater than 1 - VkBool32 alphaToOnethe fragment alpha component can be forced to maximum representable alpha value - VkBool32 multiViewportviewport arrays - VkBool32 samplerAnisotropyanisotropic sampler filtering - VkBool32 textureCompressionETC2ETC texture compression formats - VkBool32 textureCompressionASTC_LDRASTC LDR texture compression formats - VkBool32 textureCompressionBCBC1-7 texture compressed formats - VkBool32 occlusionQueryPreciseprecise occlusion queries returning actual sample counts - VkBool32 pipelineStatisticsQuerypipeline statistics query - VkBool32 vertexPipelineStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages - VkBool32 fragmentStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in the fragment stage - VkBool32 shaderTessellationAndGeometryPointSizetessellation and geometry stages can export point size - VkBool32 shaderImageGatherExtendedimage gather with run-time values and independent offsets - VkBool32 shaderStorageImageExtendedFormatsthe extended set of formats can be used for storage images - VkBool32 shaderStorageImageMultisamplemultisample images can be used for storage images - VkBool32 shaderStorageImageReadWithoutFormatread from storage image does not require format qualifier - VkBool32 shaderStorageImageWriteWithoutFormatwrite to storage image does not require format qualifier - VkBool32 shaderUniformBufferArrayDynamicIndexingarrays of uniform buffers can be accessed with dynamically uniform indices - VkBool32 shaderSampledImageArrayDynamicIndexingarrays of sampled images can be accessed with dynamically uniform indices - VkBool32 shaderStorageBufferArrayDynamicIndexingarrays of storage buffers can be accessed with dynamically uniform indices - VkBool32 shaderStorageImageArrayDynamicIndexingarrays of storage images can be accessed with dynamically uniform indices - VkBool32 shaderClipDistanceclip distance in shaders - VkBool32 shaderCullDistancecull distance in shaders - VkBool32 shaderFloat6464-bit floats (doubles) in shaders - VkBool32 shaderInt6464-bit integers in shaders - VkBool32 shaderInt1616-bit integers in shaders - VkBool32 shaderResourceResidencyshader can use texture operations that return resource residency information (requires sparseNonResident support) - VkBool32 shaderResourceMinLodshader can use texture operations that specify minimum resource LOD - VkBool32 sparseBindingSparse resources support: Resource memory can be managed at opaque page level rather than object level - VkBool32 sparseResidencyBufferSparse resources support: GPU can access partially resident buffers - VkBool32 sparseResidencyImage2DSparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images - VkBool32 sparseResidencyImage3DSparse resources support: GPU can access partially resident 3D images - VkBool32 sparseResidency2SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 2 samples - VkBool32 sparseResidency4SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 4 samples - VkBool32 sparseResidency8SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 8 samples - VkBool32 sparseResidency16SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 16 samples - VkBool32 sparseResidencyAliasedSparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) - VkBool32 variableMultisampleRatemultisample rate must be the same for all pipelines in a subpass - VkBool32 inheritedQueriesQueries may be inherited from primary to secondary command buffers - - - VkBool32 residencyStandard2DBlockShapeSparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format) - VkBool32 residencyStandard2DMultisampleBlockShapeSparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format) - VkBool32 residencyStandard3DBlockShapeSparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format) - VkBool32 residencyAlignedMipSizeSparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail - VkBool32 residencyNonResidentStrictSparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded - - - resource maximum sizes - uint32_t maxImageDimension1Dmax 1D image dimension - uint32_t maxImageDimension2Dmax 2D image dimension - uint32_t maxImageDimension3Dmax 3D image dimension - uint32_t maxImageDimensionCubemax cubemap image dimension - uint32_t maxImageArrayLayersmax layers for image arrays - uint32_t maxTexelBufferElementsmax texel buffer size (fstexels) - uint32_t maxUniformBufferRangemax uniform buffer range (bytes) - uint32_t maxStorageBufferRangemax storage buffer range (bytes) - uint32_t maxPushConstantsSizemax size of the push constants pool (bytes) - memory limits - uint32_t maxMemoryAllocationCountmax number of device memory allocations supported - uint32_t maxSamplerAllocationCountmax number of samplers that can be allocated on a device - VkDeviceSize bufferImageGranularityGranularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage - VkDeviceSize sparseAddressSpaceSizeTotal address space available for sparse allocations (bytes) - descriptor set limits - uint32_t maxBoundDescriptorSetsmax number of descriptors sets that can be bound to a pipeline - uint32_t maxPerStageDescriptorSamplersmax number of samplers allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorUniformBuffersmax number of uniform buffers allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorStorageBuffersmax number of storage buffers allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorSampledImagesmax number of sampled images allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorStorageImagesmax number of storage images allowed per-stage in a descriptor set - uint32_t maxPerStageDescriptorInputAttachmentsmax number of input attachments allowed per-stage in a descriptor set - uint32_t maxPerStageResourcesmax number of resources allowed by a single stage - uint32_t maxDescriptorSetSamplersmax number of samplers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetUniformBuffersmax number of uniform buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetUniformBuffersDynamicmax number of dynamic uniform buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetStorageBuffersmax number of storage buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetStorageBuffersDynamicmax number of dynamic storage buffers allowed in all stages in a descriptor set - uint32_t maxDescriptorSetSampledImagesmax number of sampled images allowed in all stages in a descriptor set - uint32_t maxDescriptorSetStorageImagesmax number of storage images allowed in all stages in a descriptor set - uint32_t maxDescriptorSetInputAttachmentsmax number of input attachments allowed in all stages in a descriptor set - vertex stage limits - uint32_t maxVertexInputAttributesmax number of vertex input attribute slots - uint32_t maxVertexInputBindingsmax number of vertex input binding slots - uint32_t maxVertexInputAttributeOffsetmax vertex input attribute offset added to vertex buffer offset - uint32_t maxVertexInputBindingStridemax vertex input binding stride - uint32_t maxVertexOutputComponentsmax number of output components written by vertex shader - tessellation control stage limits - uint32_t maxTessellationGenerationLevelmax level supported by tessellation primitive generator - uint32_t maxTessellationPatchSizemax patch size (vertices) - uint32_t maxTessellationControlPerVertexInputComponentsmax number of input components per-vertex in TCS - uint32_t maxTessellationControlPerVertexOutputComponentsmax number of output components per-vertex in TCS - uint32_t maxTessellationControlPerPatchOutputComponentsmax number of output components per-patch in TCS - uint32_t maxTessellationControlTotalOutputComponentsmax total number of per-vertex and per-patch output components in TCS - tessellation evaluation stage limits - uint32_t maxTessellationEvaluationInputComponentsmax number of input components per vertex in TES - uint32_t maxTessellationEvaluationOutputComponentsmax number of output components per vertex in TES - geometry stage limits - uint32_t maxGeometryShaderInvocationsmax invocation count supported in geometry shader - uint32_t maxGeometryInputComponentsmax number of input components read in geometry stage - uint32_t maxGeometryOutputComponentsmax number of output components written in geometry stage - uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage - uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage - fragment stage limits - uint32_t maxFragmentInputComponentsmax number of input components read in fragment stage - uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage - uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending - uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers - compute stage limits - uint32_t maxComputeSharedMemorySizemax total storage size of work group local storage (bytes) - uint32_t maxComputeWorkGroupCount[3]max num of compute work groups that may be dispatched by a single command (x,y,z) - uint32_t maxComputeWorkGroupInvocationsmax total compute invocations in a single local work group - uint32_t maxComputeWorkGroupSize[3]max local size of a compute work group (x,y,z) - uint32_t subPixelPrecisionBitsnumber bits of subpixel precision in screen x and y - uint32_t subTexelPrecisionBitsnumber bits of precision for selecting texel weights - uint32_t mipmapPrecisionBitsnumber bits of precision for selecting mipmap weights - uint32_t maxDrawIndexedIndexValuemax index value for indexed draw calls (for 32-bit indices) - uint32_t maxDrawIndirectCountmax draw count for indirect draw calls - float maxSamplerLodBiasmax absolute sampler LOD bias - float maxSamplerAnisotropymax degree of sampler anisotropy - uint32_t maxViewportsmax number of active viewports - uint32_t maxViewportDimensions[2]max viewport dimensions (x,y) - float viewportBoundsRange[2]viewport bounds range (min,max) - uint32_t viewportSubPixelBitsnumber bits of subpixel precision for viewport - size_t minMemoryMapAlignmentmin required alignment of pointers returned by MapMemory (bytes) - VkDeviceSize minTexelBufferOffsetAlignmentmin required alignment for texel buffer offsets (bytes) - VkDeviceSize minUniformBufferOffsetAlignmentmin required alignment for uniform buffer sizes and offsets (bytes) - VkDeviceSize minStorageBufferOffsetAlignmentmin required alignment for storage buffer offsets (bytes) - int32_t minTexelOffsetmin texel offset for OpTextureSampleOffset - uint32_t maxTexelOffsetmax texel offset for OpTextureSampleOffset - int32_t minTexelGatherOffsetmin texel offset for OpTextureGatherOffset - uint32_t maxTexelGatherOffsetmax texel offset for OpTextureGatherOffset - float minInterpolationOffsetfurthest negative offset for interpolateAtOffset - float maxInterpolationOffsetfurthest positive offset for interpolateAtOffset - uint32_t subPixelInterpolationOffsetBitsnumber of subpixel bits for interpolateAtOffset - uint32_t maxFramebufferWidthmax width for a framebuffer - uint32_t maxFramebufferHeightmax height for a framebuffer - uint32_t maxFramebufferLayersmax layer count for a layered framebuffer - VkSampleCountFlags framebufferColorSampleCountssupported color sample counts for a framebuffer - VkSampleCountFlags framebufferDepthSampleCountssupported depth sample counts for a framebuffer - VkSampleCountFlags framebufferStencilSampleCountssupported stencil sample counts for a framebuffer - VkSampleCountFlags framebufferNoAttachmentsSampleCountssupported sample counts for a framebuffer with no attachments - uint32_t maxColorAttachmentsmax number of color attachments per subpass - VkSampleCountFlags sampledImageColorSampleCountssupported color sample counts for a non-integer sampled image - VkSampleCountFlags sampledImageIntegerSampleCountssupported sample counts for an integer image - VkSampleCountFlags sampledImageDepthSampleCountssupported depth sample counts for a sampled image - VkSampleCountFlags sampledImageStencilSampleCountssupported stencil sample counts for a sampled image - VkSampleCountFlags storageImageSampleCountssupported sample counts for a storage image - uint32_t maxSampleMaskWordsmax number of sample mask words - VkBool32 timestampComputeAndGraphicstimestamps on graphics and compute queues - float timestampPeriodnumber of nanoseconds it takes for timestamp query value to increment by 1 - uint32_t maxClipDistancesmax number of clip distances - uint32_t maxCullDistancesmax number of cull distances - uint32_t maxCombinedClipAndCullDistancesmax combined number of user clipping - uint32_t discreteQueuePrioritiesdistinct queue priorities available - float pointSizeRange[2]range (min,max) of supported point sizes - float lineWidthRange[2]range (min,max) of supported line widths - float pointSizeGranularitygranularity of supported point sizes - float lineWidthGranularitygranularity of supported line widths - VkBool32 strictLinesline rasterization follows preferred rules - VkBool32 standardSampleLocationssupports standard sample locations for all supported sample counts - VkDeviceSize optimalBufferCopyOffsetAlignmentoptimal offset of buffer copies - VkDeviceSize optimalBufferCopyRowPitchAlignmentoptimal pitch of buffer copies - VkDeviceSize nonCoherentAtomSizeminimum size and alignment for non-coherent host-mapped device memory access - - - VkStructureType sType - const void* pNext - VkSemaphoreCreateFlags flagsSemaphore creation flags - - - VkStructureType sType - const void* pNext - VkQueryPoolCreateFlags flags - VkQueryType queryType - uint32_t queryCount - VkQueryPipelineStatisticFlags pipelineStatisticsOptional - - - VkStructureType sType - const void* pNext - VkFramebufferCreateFlags flags - VkRenderPass renderPass - uint32_t attachmentCount - const VkImageView* pAttachments - uint32_t width - uint32_t height - uint32_t layers - - - uint32_t vertexCount - uint32_t instanceCount - uint32_t firstVertex - uint32_t firstInstance - - - uint32_t indexCount - uint32_t instanceCount - uint32_t firstIndex - int32_t vertexOffset - uint32_t firstInstance - - - uint32_t x - uint32_t y - uint32_t z - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - const VkPipelineStageFlags* pWaitDstStageMask - uint32_t commandBufferCount - const VkCommandBuffer* pCommandBuffers - uint32_t signalSemaphoreCount - const VkSemaphore* pSignalSemaphores - - WSI extensions - - VkDisplayKHR displayHandle of the display object - const char* displayNameName of the display - VkExtent2D physicalDimensionsIn millimeters? - VkExtent2D physicalResolutionMax resolution for CRT? - VkSurfaceTransformFlagsKHR supportedTransformsone or more bits from VkSurfaceTransformFlagsKHR - VkBool32 planeReorderPossibleVK_TRUE if the overlay plane's z-order can be changed on this display. - VkBool32 persistentContentVK_TRUE if this is a "smart" display that supports self-refresh/internal buffering. - - - VkDisplayKHR currentDisplayDisplay the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use. - uint32_t currentStackIndexCurrent z-order of the plane. - - - VkExtent2D visibleRegionVisible scanout region. - uint32_t refreshRateNumber of times per second the display is updated. - - - VkDisplayModeKHR displayModeHandle of this display mode. - VkDisplayModeParametersKHR parametersThe parameters this mode uses. - - - VkStructureType sType - const void* pNext - VkDisplayModeCreateFlagsKHR flags - VkDisplayModeParametersKHR parametersThe parameters this mode uses. - - - VkDisplayPlaneAlphaFlagsKHR supportedAlphaTypes of alpha blending supported, if any. - VkOffset2D minSrcPositionDoes the plane have any position and extent restrictions? - VkOffset2D maxSrcPosition - VkExtent2D minSrcExtent - VkExtent2D maxSrcExtent - VkOffset2D minDstPosition - VkOffset2D maxDstPosition - VkExtent2D minDstExtent - VkExtent2D maxDstExtent - - - VkStructureType sType - const void* pNext - VkDisplaySurfaceCreateFlagsKHR flags - VkDisplayModeKHR displayModeThe mode to use when displaying this surface - uint32_t planeIndexThe plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount. - uint32_t planeStackIndexThe z-order of the plane. - VkSurfaceTransformFlagBitsKHR transformTransform to apply to the images as part of the scanout operation - float globalAlphaGlobal alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR - VkDisplayPlaneAlphaFlagBitsKHR alphaModeWhat type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha. - VkExtent2D imageExtentsize of the images to use with this surface - - - VkStructureType sType - const void* pNext - VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display. - VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in. - VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. - - - uint32_t minImageCountSupported minimum number of images for the surface - uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited - VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined - VkExtent2D minImageExtentSupported minimum image width and height for the surface - VkExtent2D maxImageExtentSupported maximum image width and height for the surface - uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface - VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported - VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation - VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported - VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface - - - VkStructureType sType - const void* pNext - VkAndroidSurfaceCreateFlagsKHR flags - struct ANativeWindow* window - - - VkStructureType sType - const void* pNext - VkMirSurfaceCreateFlagsKHR flags - MirConnection* connection - MirSurface* mirSurface - - - VkStructureType sType - const void* pNext - VkViSurfaceCreateFlagsNN flags - void* window - - - VkStructureType sType - const void* pNext - VkWaylandSurfaceCreateFlagsKHR flags - struct wl_display* display - struct wl_surface* surface - - - VkStructureType sType - const void* pNext - VkWin32SurfaceCreateFlagsKHR flags - HINSTANCE hinstance - HWND hwnd - - - VkStructureType sType - const void* pNext - VkXlibSurfaceCreateFlagsKHR flags - Display* dpy - Window window - - - VkStructureType sType - const void* pNext - VkXcbSurfaceCreateFlagsKHR flags - xcb_connection_t* connection - xcb_window_t window - - - VkFormat formatSupported pair of rendering format - VkColorSpaceKHR colorSpaceand color space for the surface - - - VkStructureType sType - const void* pNext - VkSwapchainCreateFlagsKHR flags - VkSurfaceKHR surfaceThe swapchain's target surface - uint32_t minImageCountMinimum number of presentation images the application needs - VkFormat imageFormatFormat of the presentation images - VkColorSpaceKHR imageColorSpaceColorspace of the presentation images - VkExtent2D imageExtentDimensions of the presentation images - uint32_t imageArrayLayersDetermines the number of views for multiview/stereo presentation - VkImageUsageFlags imageUsageBits indicating how the presentation images will be used - VkSharingMode imageSharingModeSharing mode used for the presentation images - uint32_t queueFamilyIndexCountNumber of queue families having access to the images in case of concurrent sharing mode - const uint32_t* pQueueFamilyIndicesArray of queue family indices having access to the images in case of concurrent sharing mode - VkSurfaceTransformFlagBitsKHR preTransformThe transform, relative to the device's natural orientation, applied to the image content prior to presentation - VkCompositeAlphaFlagBitsKHR compositeAlphaThe alpha blending mode used when compositing this surface with other surfaces in the window system - VkPresentModeKHR presentModeWhich presentation mode to use for presents on this swap chain - VkBool32 clippedSpecifies whether presentable images may be affected by window clip regions - VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCountNumber of semaphores to wait for before presenting - const VkSemaphore* pWaitSemaphoresSemaphores to wait for before presenting - uint32_t swapchainCountNumber of swapchains to present in this call - const VkSwapchainKHR* pSwapchainsSwapchains to present an image from - const uint32_t* pImageIndicesIndices of which presentable images to present - VkResult* pResultsOptional (i.e. if non-NULL) VkResult for each swapchain - - - VkStructureType sType - const void* pNext - VkDebugReportFlagsEXT flagsIndicates which events call this callback - PFN_vkDebugReportCallbackEXT pfnCallbackFunction pointer of a callback function - void* pUserDataUser data provided to callback function - - - VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT - const void* pNext - uint32_t disabledValidationCheckCountNumber of validation checks to disable - VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable - - - VkStructureType sType - const void* pNext - VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline - - - VkStructureType sType - const void* pNext - VkDebugReportObjectTypeEXT objectTypeThe type of the object - uint64_t objectThe handle of the object, cast to uint64_t - const char* pObjectNameName to apply to the object - - - VkStructureType sType - const void* pNext - VkDebugReportObjectTypeEXT objectTypeThe type of the object - uint64_t objectThe handle of the object, cast to uint64_t - uint64_t tagNameThe name of the tag to set on the object - size_t tagSizeThe length in bytes of the tag data - const void* pTagTag data to attach to the object - - - VkStructureType sType - const void* pNext - const char* pMarkerNameName of the debug marker - float color[4]Optional color for debug marker - - - VkStructureType sType - const void* pNext - VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation - - - VkStructureType sType - const void* pNext - VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation - - - VkStructureType sType - const void* pNext - VkImage imageImage that this allocation will be bound to - VkBuffer bufferBuffer that this allocation will be bound to - - - VkImageFormatProperties imageFormatProperties - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleType - HANDLE handle - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - - - VkStructureType sType - const void* pNext - uint32_t acquireCount - const VkDeviceMemory* pAcquireSyncs - const uint64_t* pAcquireKeys - const uint32_t* pAcquireTimeoutMilliseconds - uint32_t releaseCount - const VkDeviceMemory* pReleaseSyncs - const uint64_t* pReleaseKeys - - - VkStructureType sType - const void* pNext - VkBool32 computeBindingPointSupport - - - VkStructureType sType - const void* pNext - uint32_t maxIndirectCommandsLayoutTokenCount - uint32_t maxObjectEntryCounts - uint32_t minSequenceCountBufferOffsetAlignment - uint32_t minSequenceIndexBufferOffsetAlignment - uint32_t minCommandsTokenBufferOffsetAlignment - - - VkIndirectCommandsTokenTypeNVX tokenType - VkBuffer bufferbuffer containing tableEntries and additional data for indirectCommands - VkDeviceSize offsetoffset from the base address of the buffer - - - VkIndirectCommandsTokenTypeNVX tokenType - uint32_t bindingUnitBinding unit for vertex attribute / descriptor set, offset for pushconstants - uint32_t dynamicCountNumber of variable dynamic values for descriptor set / push constants - uint32_t divisorRate the which the array is advanced per element (must be power of 2, minimum 1) - - - VkStructureType sType - const void* pNext - VkPipelineBindPoint pipelineBindPoint - VkIndirectCommandsLayoutUsageFlagsNVX flags - uint32_t tokenCount - const VkIndirectCommandsLayoutTokenNVX* pTokens - - - VkStructureType sType - const void* pNext - VkObjectTableNVX objectTable - VkIndirectCommandsLayoutNVX indirectCommandsLayout - uint32_t indirectCommandsTokenCount - const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens - uint32_t maxSequencesCount - VkCommandBuffer targetCommandBuffer - VkBuffer sequencesCountBuffer - VkDeviceSize sequencesCountOffset - VkBuffer sequencesIndexBuffer - VkDeviceSize sequencesIndexOffset - - - VkStructureType sType - const void* pNext - VkObjectTableNVX objectTable - VkIndirectCommandsLayoutNVX indirectCommandsLayout - uint32_t maxSequencesCount - - - VkStructureType sType - const void* pNext - uint32_t objectCount - const VkObjectEntryTypeNVX* pObjectEntryTypes - const uint32_t* pObjectEntryCounts - const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags - - uint32_t maxUniformBuffersPerDescriptor - uint32_t maxStorageBuffersPerDescriptor - uint32_t maxStorageImagesPerDescriptor - uint32_t maxSampledImagesPerDescriptor - uint32_t maxPipelineLayouts - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipeline pipeline - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipelineLayout pipelineLayout - VkDescriptorSet descriptorSet - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkBuffer buffer - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkBuffer buffer - VkIndexType indexType - - - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipelineLayout pipelineLayout - VkShaderStageFlags stageFlags - - - VkStructureType sType - void* pNext - VkPhysicalDeviceFeatures features - - - - VkStructureType sType - void* pNext - VkPhysicalDeviceProperties properties - - - - VkStructureType sType - void* pNext - VkFormatProperties formatProperties - - - - VkStructureType sType - void* pNext - VkImageFormatProperties imageFormatProperties - - - - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags - - - - VkStructureType sType - void* pNext - VkQueueFamilyProperties queueFamilyProperties - - - - VkStructureType sType - void* pNext - VkPhysicalDeviceMemoryProperties memoryProperties - - - - VkStructureType sType - void* pNext - VkSparseImageFormatProperties properties - - - - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkSampleCountFlagBits samples - VkImageUsageFlags usage - VkImageTiling tiling - - - - VkStructureType sType - void* pNext - uint32_t maxPushDescriptors - - - VkStructureType sType - const void* pNext - uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount - const VkPresentRegionKHR* pRegionsThe regions that have changed - - - uint32_t rectangleCountNumber of rectangles in pRectangles - const VkRectLayerKHR* pRectanglesArray of rectangles that have changed in a swapchain's image(s) - - - VkOffset2D offsetupper-left corner of a rectangle that has not changed, in pixels of a presentation images - VkExtent2D extentDimensions of a rectangle that has not changed, in pixels of a presentation images - uint32_t layerLayer of a swapchain's image(s), for stereoscopic-3D images - - - VkStructureType sType - void* pNext - VkBool32 variablePointersStorageBuffer - VkBool32 variablePointers - - - - VkExternalMemoryFeatureFlags externalMemoryFeatures - VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlags compatibleHandleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalMemoryProperties externalMemoryProperties - - - - VkStructureType sType - const void* pNext - VkBufferCreateFlags flags - VkBufferUsageFlags usage - VkExternalMemoryHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalMemoryProperties externalMemoryProperties - - - - VkStructureType sType - void* pNext - uint8_t deviceUUID[VK_UUID_SIZE] - uint8_t driverUUID[VK_UUID_SIZE] - uint8_t deviceLUID[VK_LUID_SIZE] - uint32_t deviceNodeMask - VkBool32 deviceLUIDValid - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - HANDLE handle - LPCWSTR name - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - LPCWSTR name - - - VkStructureType sType - void* pNext - uint32_t memoryTypeBits - - - VkStructureType sType - const void* pNext - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - int fd - - - VkStructureType sType - void* pNext - uint32_t memoryTypeBits - - - VkStructureType sType - const void* pNext - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - uint32_t acquireCount - const VkDeviceMemory* pAcquireSyncs - const uint64_t* pAcquireKeys - const uint32_t* pAcquireTimeouts - uint32_t releaseCount - const VkDeviceMemory* pReleaseSyncs - const uint64_t* pReleaseKeys - - - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures - - - - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkSemaphoreImportFlags flags - VkExternalSemaphoreHandleTypeFlagBits handleType - HANDLE handle - LPCWSTR name - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - LPCWSTR name - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreValuesCount - const uint64_t* pWaitSemaphoreValues - uint32_t signalSemaphoreValuesCount - const uint64_t* pSignalSemaphoreValues - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkSemaphoreImportFlags flags - VkExternalSemaphoreHandleTypeFlagBits handleType - int fd - - - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlagBits handleType - - - - VkStructureType sType - void* pNext - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes - VkExternalFenceHandleTypeFlags compatibleHandleTypes - VkExternalFenceFeatureFlags externalFenceFeatures - - - - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlags handleTypes - - - - VkStructureType sType - const void* pNext - VkFence fence - VkFenceImportFlags flags - VkExternalFenceHandleTypeFlagBits handleType - HANDLE handle - LPCWSTR name - - - VkStructureType sType - const void* pNext - const SECURITY_ATTRIBUTES* pAttributes - DWORD dwAccess - LPCWSTR name - - - VkStructureType sType - const void* pNext - VkFence fence - VkExternalFenceHandleTypeFlagBits handleType - - - VkStructureType sType - const void* pNext - VkFence fence - VkFenceImportFlags flags - VkExternalFenceHandleTypeFlagBits handleType - int fd - - - VkStructureType sType - const void* pNext - VkFence fence - VkExternalFenceHandleTypeFlagBits handleType - - - VkStructureType sType - void* pNext - VkBool32 multiviewMultiple views in a renderpass - VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader - VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader - - - - VkStructureType sType - void* pNext - uint32_t maxMultiviewViewCountmax number of views in a subpass - uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass - - - - VkStructureType sType - const void* pNext - uint32_t subpassCount - const uint32_t* pViewMasks - uint32_t dependencyCount - const int32_t* pViewOffsets - uint32_t correlationMaskCount - const uint32_t* pCorrelationMasks - - - - VkStructureType sType - void* pNext - uint32_t minImageCountSupported minimum number of images for the surface - uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited - VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined - VkExtent2D minImageExtentSupported minimum image width and height for the surface - VkExtent2D maxImageExtentSupported maximum image width and height for the surface - uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface - VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported - VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation - VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported - VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface - VkSurfaceCounterFlagsEXT supportedSurfaceCounters - - - VkStructureType sType - const void* pNext - VkDisplayPowerStateEXT powerState - - - VkStructureType sType - const void* pNext - VkDeviceEventTypeEXT deviceEvent - - - VkStructureType sType - const void* pNext - VkDisplayEventTypeEXT displayEvent - - - VkStructureType sType - const void* pNext - VkSurfaceCounterFlagsEXT surfaceCounters - - - VkStructureType sType - void* pNext - uint32_t physicalDeviceCount - VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE] - VkBool32 subsetAllocation - - - - VkStructureType sType - const void* pNext - VkMemoryAllocateFlags flags - uint32_t deviceMask - - - - VkStructureType sType - const void* pNext - VkBuffer buffer - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - - VkStructureType sType - const void* pNext - uint32_t deviceIndexCount - const uint32_t* pDeviceIndices - - - - VkStructureType sType - const void* pNext - VkImage image - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - - VkStructureType sType - const void* pNext - uint32_t deviceIndexCount - const uint32_t* pDeviceIndices - uint32_t splitInstanceBindRegionCount - const VkRect2D* pSplitInstanceBindRegions - - - - VkStructureType sType - const void* pNext - uint32_t deviceMask - uint32_t deviceRenderAreaCount - const VkRect2D* pDeviceRenderAreas - - - - VkStructureType sType - const void* pNext - uint32_t deviceMask - - - - VkStructureType sType - const void* pNext - uint32_t waitSemaphoreCount - const uint32_t* pWaitSemaphoreDeviceIndices - uint32_t commandBufferCount - const uint32_t* pCommandBufferDeviceMasks - uint32_t signalSemaphoreCount - const uint32_t* pSignalSemaphoreDeviceIndices - - - - VkStructureType sType - const void* pNext - uint32_t resourceDeviceIndex - uint32_t memoryDeviceIndex - - - - VkStructureType sType - const void* pNext - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE] - VkDeviceGroupPresentModeFlagsKHR modes - - - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - - - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - uint32_t imageIndex - - - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - uint64_t timeout - VkSemaphore semaphore - VkFence fence - uint32_t deviceMask - - - VkStructureType sType - const void* pNext - uint32_t swapchainCount - const uint32_t* pDeviceMasks - VkDeviceGroupPresentModeFlagBitsKHR mode - - - VkStructureType sType - const void* pNext - uint32_t physicalDeviceCount - const VkPhysicalDevice* pPhysicalDevices - - - - VkStructureType sType - const void* pNext - VkDeviceGroupPresentModeFlagsKHR modes - - - uint32_t dstBindingBinding within the destination descriptor set to write - uint32_t dstArrayElementArray element within the destination binding to write - uint32_t descriptorCountNumber of descriptors to write - VkDescriptorType descriptorTypeDescriptor type to write - size_t offsetOffset into pData where the descriptors to update are stored - size_t strideStride between two descriptors in pData when writing more than one descriptor - - - - VkStructureType sType - void* pNext - VkDescriptorUpdateTemplateCreateFlags flags - uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template - VkDescriptorUpdateTemplateType templateType - VkDescriptorSetLayout descriptorSetLayout - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayoutpipelineLayoutIf used for push descriptors, this is the only allowed layout - uint32_t set - - - - float x - float y - - - Display primary in chromaticity coordinates - VkStructureType sType - const void* pNext - From SMPTE 2086 - VkXYColorEXT displayPrimaryRedDisplay primary's Red - VkXYColorEXT displayPrimaryGreenDisplay primary's Green - VkXYColorEXT displayPrimaryBlueDisplay primary's Blue - VkXYColorEXT whitePointDisplay primary's Blue - float maxLuminanceDisplay maximum luminance - float minLuminanceDisplay minimum luminance - From CTA 861.3 - float maxContentLightLevelContent maximum luminance - float maxFrameAverageLightLevel - - - uint64_t refreshDurationNumber of nanoseconds from the start of one refresh cycle to the next - - - uint32_t presentIDApplication-provided identifier, previously given to vkQueuePresentKHR - uint64_t desiredPresentTimeEarliest time an image should have been presented, previously given to vkQueuePresentKHR - uint64_t actualPresentTimeTime the image was actually displayed - uint64_t earliestPresentTimeEarliest time the image could have been displayed - uint64_t presentMarginHow early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime - - - VkStructureType sType - const void* pNext - uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount - const VkPresentTimeGOOGLE* pTimesThe earliest times to present images - - - uint32_t presentIDApplication-provided identifier - uint64_t desiredPresentTimeEarliest time an image should be presented - - - VkStructureType sType - const void* pNext - VkIOSSurfaceCreateFlagsMVK flags - const void* pView - - - VkStructureType sType - const void* pNext - VkMacOSSurfaceCreateFlagsMVK flags - const void* pView - - - float xcoeff - float ycoeff - - - VkStructureType sType - const void* pNext - VkBool32 viewportWScalingEnable - uint32_t viewportCount - const VkViewportWScalingNV* pViewportWScalings - - - VkViewportCoordinateSwizzleNV x - VkViewportCoordinateSwizzleNV y - VkViewportCoordinateSwizzleNV z - VkViewportCoordinateSwizzleNV w - - - VkStructureType sType - const void* pNext - VkPipelineViewportSwizzleStateCreateFlagsNV flags - uint32_t viewportCount - const VkViewportSwizzleNV* pViewportSwizzles - - - VkStructureType sType - void* pNext - uint32_t maxDiscardRectanglesmax number of active discard rectangles - - - VkStructureType sType - const void* pNext - VkPipelineDiscardRectangleStateCreateFlagsEXT flags - VkDiscardRectangleModeEXT discardRectangleMode - uint32_t discardRectangleCount - const VkRect2D* pDiscardRectangles - - - VkStructureType sType - void* pNext - VkBool32 perViewPositionAllComponents - - - uint32_t subpass - uint32_t inputAttachmentIndex - VkImageAspectFlags aspectMask - - - - VkStructureType sType - const void* pNext - uint32_t aspectReferenceCount - const VkInputAttachmentAspectReference* pAspectReferences - - - - VkStructureType sType - const void* pNext - VkSurfaceKHR surface - - - VkStructureType sType - void* pNext - VkSurfaceCapabilitiesKHR surfaceCapabilities - - - VkStructureType sType - void* pNext - VkSurfaceFormatKHR surfaceFormat - - - VkStructureType sType - void* pNext - VkDisplayPropertiesKHR displayProperties - - - VkStructureType sType - void* pNext - VkDisplayPlanePropertiesKHR displayPlaneProperties - - - VkStructureType sType - void* pNext - VkDisplayModePropertiesKHR displayModeProperties - - - VkStructureType sType - const void* pNext - VkDisplayModeKHR mode - uint32_t planeIndex - - - VkStructureType sType - void* pNext - VkDisplayPlaneCapabilitiesKHR capabilities - - - VkStructureType sType - void* pNext - VkImageUsageFlags sharedPresentSupportedUsageFlagsSupported image usage flags if swapchain created using a shared present mode - - - VkStructureType sType - void* pNext - VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock - VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block - VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant - VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs - - - - VkStructureType sType - void* pNext - uint32_t subgroupSizeThe size of a subgroup for this queue. - VkShaderStageFlags supportedStagesBitfield of what shader stages support subgroup operations - VkSubgroupFeatureFlags supportedOperationsBitfield of what subgroup operations are supported. - VkBool32 quadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. - - - VkStructureType sType - const void* pNext - VkBuffer buffer - - - - VkStructureType sType - const void* pNext - VkImage image - - - - VkStructureType sType - const void* pNext - VkImage image - - - - VkStructureType sType - void* pNext - VkMemoryRequirements memoryRequirements - - - - VkStructureType sType - void* pNext - VkSparseImageMemoryRequirements memoryRequirements - - - - VkStructureType sType - void* pNext - VkPointClippingBehavior pointClippingBehavior - - - - VkStructureType sType - void* pNext - VkBool32 prefersDedicatedAllocation - VkBool32 requiresDedicatedAllocation - - - - VkStructureType sType - const void* pNext - VkImage imageImage that this allocation will be bound to - VkBuffer bufferBuffer that this allocation will be bound to - - - - VkStructureType sType - const void* pNext - VkImageUsageFlags usage - - - - VkStructureType sType - const void* pNext - VkTessellationDomainOrigin domainOrigin - - - - VkStructureType sType - const void* pNext - VkSamplerYcbcrConversion conversion - - - - VkStructureType sType - const void* pNext - VkFormat format - VkSamplerYcbcrModelConversion ycbcrModel - VkSamplerYcbcrRange ycbcrRange - VkComponentMapping components - VkChromaLocation xChromaOffset - VkChromaLocation yChromaOffset - VkFilter chromaFilter - VkBool32 forceExplicitReconstruction - - - - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect - - - - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect - - - - VkStructureType sType - void* pNext - VkBool32 samplerYcbcrConversionSampler color conversion supported - - - - VkStructureType sType - void* pNext - uint32_t combinedImageSamplerDescriptorCount - - - - VkStructureType sType - void* pNext - VkBool32 supportsTextureGatherLODBiasAMD - - - VkStructureType sType - const void* pNext - VkBool32 protectedSubmitSubmit protected command buffers - - - VkStructureType sType - void* pNext - VkBool32 protectedMemory - - - VkStructureType sType - void* pNext - VkBool32 protectedNoFault - - - VkStructureType sType - const void* pNext - VkDeviceQueueCreateFlags flags - uint32_t queueFamilyIndex - uint32_t queueIndex - - - VkStructureType sType - const void* pNext - VkPipelineCoverageToColorStateCreateFlagsNV flags - VkBool32 coverageToColorEnable - uint32_t coverageToColorLocation - - - VkStructureType sType - void* pNext - VkBool32 filterMinmaxSingleComponentFormats - VkBool32 filterMinmaxImageComponentMapping - - - float x - float y - - - VkStructureType sType - const void* pNext - VkSampleCountFlagBits sampleLocationsPerPixel - VkExtent2D sampleLocationGridSize - uint32_t sampleLocationsCount - const VkSampleLocationEXT* pSampleLocations - - - uint32_t attachmentIndex - VkSampleLocationsInfoEXT sampleLocationsInfo - - - uint32_t subpassIndex - VkSampleLocationsInfoEXT sampleLocationsInfo - - - VkStructureType sType - const void* pNext - uint32_t attachmentInitialSampleLocationsCount - const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations - uint32_t postSubpassSampleLocationsCount - const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations - - - VkStructureType sType - const void* pNext - VkBool32 sampleLocationsEnable - VkSampleLocationsInfoEXT sampleLocationsInfo - - - VkStructureType sType - void* pNext - VkSampleCountFlags sampleLocationSampleCounts - VkExtent2D maxSampleLocationGridSize - float sampleLocationCoordinateRange[2] - uint32_t sampleLocationSubPixelBits - VkBool32 variableSampleLocations - - - VkStructureType sType - void* pNext - VkExtent2D maxSampleLocationGridSize - - - VkStructureType sType - const void* pNext - VkSamplerReductionModeEXT reductionMode - - - VkStructureType sType - void* pNext - VkBool32 advancedBlendCoherentOperations - - - VkStructureType sType - void* pNext - uint32_t advancedBlendMaxColorAttachments - VkBool32 advancedBlendIndependentBlend - VkBool32 advancedBlendNonPremultipliedSrcColor - VkBool32 advancedBlendNonPremultipliedDstColor - VkBool32 advancedBlendCorrelatedOverlap - VkBool32 advancedBlendAllOperations - - - VkStructureType sType - const void* pNext - VkBool32 srcPremultiplied - VkBool32 dstPremultiplied - VkBlendOverlapEXT blendOverlap - - - VkStructureType sType - const void* pNext - VkPipelineCoverageModulationStateCreateFlagsNV flags - VkCoverageModulationModeNV coverageModulationMode - VkBool32 coverageModulationTableEnable - uint32_t coverageModulationTableCount - const float* pCoverageModulationTable - - - VkStructureType sType - const void* pNext - uint32_t viewFormatCount - const VkFormat* pViewFormats - - - VkStructureType sType - const void* pNext - VkValidationCacheCreateFlagsEXT flags - size_t initialDataSize - const void* pInitialData - - - VkStructureType sType - const void* pNext - VkValidationCacheEXT validationCache - - - VkStructureType sType - void* pNext - uint32_t maxPerSetDescriptors - VkDeviceSize maxMemoryAllocationSize - - - - VkStructureType sType - void* pNext - VkBool32 supported - - - - VkStructureType sType - void* pNext - VkBool32 shaderDrawParameters - - - VkStructureType sType - const void* pNext - const void* handle - int stride - int format - int usage - - - uint32_t numUsedVgprs - uint32_t numUsedSgprs - uint32_t ldsSizePerLocalWorkGroup - size_t ldsUsageSizeInBytes - size_t scratchMemUsageInBytes - - - VkShaderStageFlags shaderStageMask - VkShaderResourceUsageAMD resourceUsage - uint32_t numPhysicalVgprs - uint32_t numPhysicalSgprs - uint32_t numAvailableVgprs - uint32_t numAvailableSgprs - uint32_t computeWorkGroupSize[3] - - - VkStructureType sType - const void* pNext - VkQueueGlobalPriorityEXT globalPriority - - - VkStructureType sType - const void* pNext - VkObjectType objectType - uint64_t objectHandle - const char* pObjectName - - - VkStructureType sType - const void* pNext - VkObjectType objectType - uint64_t objectHandle - uint64_t tagName - size_t tagSize - const void* pTag - - - VkStructureType sType - const void* pNext - const char* pLabelName - float color[4] - - - VkStructureType sType - const void* pNext - VkDebugUtilsMessengerCreateFlagsEXT flags - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity - VkDebugUtilsMessageTypeFlagsEXT messageType - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback - void* pUserData - - - VkStructureType sType - const void* pNext - VkDebugUtilsMessengerCallbackDataFlagsEXT flags - const char* pMessageIdName - int32_t messageIdNumber - const char* pMessage - uint32_t queueLabelCount - VkDebugUtilsLabelEXT* pQueueLabels - uint32_t cmdBufLabelCount - VkDebugUtilsLabelEXT* pCmdBufLabels - uint32_t objectCount - VkDebugUtilsObjectNameInfoEXT* pObjects - - - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - void* pHostPointer - - - VkStructureType sType - void* pNext - uint32_t memoryTypeBits - - - VkStructureType sType - void* pNext - VkDeviceSize minImportedHostPointerAlignment - - - VkStructureType sType - void* pNextPointer to next structure - float primitiveOverestimationSizeThe size in pixels the primitive is enlarged at each edge during conservative rasterization - float maxExtraPrimitiveOverestimationSizeThe maximum additional overestimation the client can specify in the pipeline state - float extraPrimitiveOverestimationSizeGranularityThe granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize - VkBool32 primitiveUnderestimationtrue if the implementation supports conservative rasterization underestimation mode - VkBool32 conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines - VkBool32 degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized - VkBool32 degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized - VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable - VkBool32 conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask - - - VkStructureType sType - void* pNextPointer to next structure - uint32_t shaderEngineCountnumber of shader engines - uint32_t shaderArraysPerEngineCountnumber of shader arrays - uint32_t computeUnitsPerShaderArraynumber of CUs per shader array - uint32_t simdPerComputeUnitnumber of SIMDs per compute unit - uint32_t wavefrontsPerSimdnumber of wavefront slots in each SIMD - uint32_t wavefrontSizenumber of threads per wavefront - uint32_t sgprsPerSimdnumber of physical SGPRs per SIMD - uint32_t minSgprAllocationminimum number of SGPRs that can be allocated by a wave - uint32_t maxSgprAllocationnumber of available SGPRs - uint32_t sgprAllocationGranularitySGPRs are allocated in groups of this size - uint32_t vgprsPerSimdnumber of physical VGPRs per SIMD - uint32_t minVgprAllocationminimum number of VGPRs that can be allocated by a wave - uint32_t maxVgprAllocationnumber of available VGPRs - uint32_t vgprAllocationGranularityVGPRs are allocated in groups of this size - - - VkStructureType sType - const void* pNext - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags - VkConservativeRasterizationModeEXT conservativeRasterizationMode - float extraPrimitiveOverestimationSize - - - VkStructureType sType - void* pNext - VkBool32 shaderInputAttachmentArrayDynamicIndexing - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing - VkBool32 shaderUniformBufferArrayNonUniformIndexing - VkBool32 shaderSampledImageArrayNonUniformIndexing - VkBool32 shaderStorageBufferArrayNonUniformIndexing - VkBool32 shaderStorageImageArrayNonUniformIndexing - VkBool32 shaderInputAttachmentArrayNonUniformIndexing - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing - VkBool32 descriptorBindingUniformBufferUpdateAfterBind - VkBool32 descriptorBindingSampledImageUpdateAfterBind - VkBool32 descriptorBindingStorageImageUpdateAfterBind - VkBool32 descriptorBindingStorageBufferUpdateAfterBind - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind - VkBool32 descriptorBindingUpdateUnusedWhilePending - VkBool32 descriptorBindingPartiallyBound - VkBool32 descriptorBindingVariableDescriptorCount - VkBool32 runtimeDescriptorArray - - - VkStructureType sType - void* pNext - uint32_t maxUpdateAfterBindDescriptorsInAllPools - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative - VkBool32 shaderSampledImageArrayNonUniformIndexingNative - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative - VkBool32 shaderStorageImageArrayNonUniformIndexingNative - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative - VkBool32 robustBufferAccessUpdateAfterBind - VkBool32 quadDivergentImplicitLod - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments - uint32_t maxPerStageUpdateAfterBindResources - uint32_t maxDescriptorSetUpdateAfterBindSamplers - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic - uint32_t maxDescriptorSetUpdateAfterBindSampledImages - uint32_t maxDescriptorSetUpdateAfterBindStorageImages - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments - - - VkStructureType sType - const void* pNext - uint32_t bindingCount - const VkDescriptorBindingFlagsEXT* pBindingFlags - - - VkStructureType sType - const void* pNext - uint32_t descriptorSetCount - const uint32_t* pDescriptorCounts - - - VkStructureType sType - void* pNext - uint32_t maxVariableDescriptorCount - - - uint32_t binding - uint32_t divisor - - - VkStructureType sType - const void* pNext - uint32_t vertexBindingDivisorCount - const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors - - - VkStructureType sType - void* pNext - uint32_t maxVertexAttribDivisormax value of vertex attribute divisor - - - VkStructureType sType - const void* pNext - struct AHardwareBuffer* buffer - - - VkStructureType sType - void* pNext - uint64_t androidHardwareBufferUsage - - - VkStructureType sType - void* pNext - VkDeviceSize allocationSize - uint32_t memoryTypeBits - - - VkStructureType sType - const void* pNext - VkDeviceMemory memory - - - VkStructureType sType - void* pNext - VkFormat format - uint64_t externalFormat - VkFormatFeatureFlags formatFeatures - VkComponentMapping samplerYcbcrConversionComponents - VkSamplerYcbcrModelConversion suggestedYcbcrModel - VkSamplerYcbcrRange suggestedYcbcrRange - VkChromaLocation suggestedXChromaOffset - VkChromaLocation suggestedYChromaOffset - - - VkStructureType sType - void* pNext - uint64_t externalFormat - - - - Vulkan enumerant (token) definitions - - - - - - - - - - - - - - - - - - - - - - - - - - - - Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in - their own numeric namespaces. The "name" attribute is the C enum - type name, and is pulled in from a type tag definition above - (slightly clunky, but retains the type / enum distinction). "type" - attributes of "enum" or "bitmask" indicate that these values should - be generated inside an appropriate definition. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge - enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not - alias! - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Return codes (positive values) - - - - - - - Error codes (negative values) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Flags - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - WSI Extensions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Vendor IDs are now represented as enums instead of the old - <vendorids> tag, allowing them to be included in the - API headers. - - - - - - - - - VkResult vkCreateInstance - const VkInstanceCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkInstance* pInstance - - - void vkDestroyInstance - VkInstance instance - const VkAllocationCallbacks* pAllocator - - - VkResult vkEnumeratePhysicalDevices - VkInstance instance - uint32_t* pPhysicalDeviceCount - VkPhysicalDevice* pPhysicalDevices - - - PFN_vkVoidFunction vkGetDeviceProcAddr - VkDevice device - const char* pName - - - PFN_vkVoidFunction vkGetInstanceProcAddr - VkInstance instance - const char* pName - - - void vkGetPhysicalDeviceProperties - VkPhysicalDevice physicalDevice - VkPhysicalDeviceProperties* pProperties - - - void vkGetPhysicalDeviceQueueFamilyProperties - VkPhysicalDevice physicalDevice - uint32_t* pQueueFamilyPropertyCount - VkQueueFamilyProperties* pQueueFamilyProperties - - - void vkGetPhysicalDeviceMemoryProperties - VkPhysicalDevice physicalDevice - VkPhysicalDeviceMemoryProperties* pMemoryProperties - - - void vkGetPhysicalDeviceFeatures - VkPhysicalDevice physicalDevice - VkPhysicalDeviceFeatures* pFeatures - - - void vkGetPhysicalDeviceFormatProperties - VkPhysicalDevice physicalDevice - VkFormat format - VkFormatProperties* pFormatProperties - - - VkResult vkGetPhysicalDeviceImageFormatProperties - VkPhysicalDevice physicalDevice - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags - VkImageFormatProperties* pImageFormatProperties - - - VkResult vkCreateDevice - VkPhysicalDevice physicalDevice - const VkDeviceCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDevice* pDevice - - - void vkDestroyDevice - VkDevice device - const VkAllocationCallbacks* pAllocator - - - VkResult vkEnumerateInstanceVersion - uint32_t* pApiVersion - - - VkResult vkEnumerateInstanceLayerProperties - uint32_t* pPropertyCount - VkLayerProperties* pProperties - - - VkResult vkEnumerateInstanceExtensionProperties - const char* pLayerName - uint32_t* pPropertyCount - VkExtensionProperties* pProperties - - - VkResult vkEnumerateDeviceLayerProperties - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkLayerProperties* pProperties - - - VkResult vkEnumerateDeviceExtensionProperties - VkPhysicalDevice physicalDevice - const char* pLayerName - uint32_t* pPropertyCount - VkExtensionProperties* pProperties - - - void vkGetDeviceQueue - VkDevice device - uint32_t queueFamilyIndex - uint32_t queueIndex - VkQueue* pQueue - - - VkResult vkQueueSubmit - VkQueue queue - uint32_t submitCount - const VkSubmitInfo* pSubmits - VkFence fence - - - VkResult vkQueueWaitIdle - VkQueue queue - - - VkResult vkDeviceWaitIdle - VkDevice device - - all sname:VkQueue objects created from pname:device - - - - VkResult vkAllocateMemory - VkDevice device - const VkMemoryAllocateInfo* pAllocateInfo - const VkAllocationCallbacks* pAllocator - VkDeviceMemory* pMemory - - - void vkFreeMemory - VkDevice device - VkDeviceMemory memory - const VkAllocationCallbacks* pAllocator - - - VkResult vkMapMemory - VkDevice device - VkDeviceMemory memory - VkDeviceSize offset - VkDeviceSize size - VkMemoryMapFlags flags - void** ppData - - - void vkUnmapMemory - VkDevice device - VkDeviceMemory memory - - - VkResult vkFlushMappedMemoryRanges - VkDevice device - uint32_t memoryRangeCount - const VkMappedMemoryRange* pMemoryRanges - - - VkResult vkInvalidateMappedMemoryRanges - VkDevice device - uint32_t memoryRangeCount - const VkMappedMemoryRange* pMemoryRanges - - - void vkGetDeviceMemoryCommitment - VkDevice device - VkDeviceMemory memory - VkDeviceSize* pCommittedMemoryInBytes - - - void vkGetBufferMemoryRequirements - VkDevice device - VkBuffer buffer - VkMemoryRequirements* pMemoryRequirements - - - VkResult vkBindBufferMemory - VkDevice device - VkBuffer buffer - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - void vkGetImageMemoryRequirements - VkDevice device - VkImage image - VkMemoryRequirements* pMemoryRequirements - - - VkResult vkBindImageMemory - VkDevice device - VkImage image - VkDeviceMemory memory - VkDeviceSize memoryOffset - - - void vkGetImageSparseMemoryRequirements - VkDevice device - VkImage image - uint32_t* pSparseMemoryRequirementCount - VkSparseImageMemoryRequirements* pSparseMemoryRequirements - - - void vkGetPhysicalDeviceSparseImageFormatProperties - VkPhysicalDevice physicalDevice - VkFormat format - VkImageType type - VkSampleCountFlagBits samples - VkImageUsageFlags usage - VkImageTiling tiling - uint32_t* pPropertyCount - VkSparseImageFormatProperties* pProperties - - - VkResult vkQueueBindSparse - VkQueue queue - uint32_t bindInfoCount - const VkBindSparseInfo* pBindInfo - VkFence fence - - - VkResult vkCreateFence - VkDevice device - const VkFenceCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkFence* pFence - - - void vkDestroyFence - VkDevice device - VkFence fence - const VkAllocationCallbacks* pAllocator - - - VkResult vkResetFences - VkDevice device - uint32_t fenceCount - const VkFence* pFences - - - VkResult vkGetFenceStatus - VkDevice device - VkFence fence - - - VkResult vkWaitForFences - VkDevice device - uint32_t fenceCount - const VkFence* pFences - VkBool32 waitAll - uint64_t timeout - - - VkResult vkCreateSemaphore - VkDevice device - const VkSemaphoreCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSemaphore* pSemaphore - - - void vkDestroySemaphore - VkDevice device - VkSemaphore semaphore - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateEvent - VkDevice device - const VkEventCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkEvent* pEvent - - - void vkDestroyEvent - VkDevice device - VkEvent event - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetEventStatus - VkDevice device - VkEvent event - - - VkResult vkSetEvent - VkDevice device - VkEvent event - - - VkResult vkResetEvent - VkDevice device - VkEvent event - - - VkResult vkCreateQueryPool - VkDevice device - const VkQueryPoolCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkQueryPool* pQueryPool - - - void vkDestroyQueryPool - VkDevice device - VkQueryPool queryPool - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetQueryPoolResults - VkDevice device - VkQueryPool queryPool - uint32_t firstQuery - uint32_t queryCount - size_t dataSize - void* pData - VkDeviceSize stride - VkQueryResultFlags flags - - - VkResult vkCreateBuffer - VkDevice device - const VkBufferCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkBuffer* pBuffer - - - void vkDestroyBuffer - VkDevice device - VkBuffer buffer - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateBufferView - VkDevice device - const VkBufferViewCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkBufferView* pView - - - void vkDestroyBufferView - VkDevice device - VkBufferView bufferView - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateImage - VkDevice device - const VkImageCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkImage* pImage - - - void vkDestroyImage - VkDevice device - VkImage image - const VkAllocationCallbacks* pAllocator - - - void vkGetImageSubresourceLayout - VkDevice device - VkImage image - const VkImageSubresource* pSubresource - VkSubresourceLayout* pLayout - - - VkResult vkCreateImageView - VkDevice device - const VkImageViewCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkImageView* pView - - - void vkDestroyImageView - VkDevice device - VkImageView imageView - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateShaderModule - VkDevice device - const VkShaderModuleCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkShaderModule* pShaderModule - - - void vkDestroyShaderModule - VkDevice device - VkShaderModule shaderModule - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreatePipelineCache - VkDevice device - const VkPipelineCacheCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkPipelineCache* pPipelineCache - - - void vkDestroyPipelineCache - VkDevice device - VkPipelineCache pipelineCache - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetPipelineCacheData - VkDevice device - VkPipelineCache pipelineCache - size_t* pDataSize - void* pData - - - VkResult vkMergePipelineCaches - VkDevice device - VkPipelineCache dstCache - uint32_t srcCacheCount - const VkPipelineCache* pSrcCaches - - - VkResult vkCreateGraphicsPipelines - VkDevice device - VkPipelineCache pipelineCache - uint32_t createInfoCount - const VkGraphicsPipelineCreateInfo* pCreateInfos - const VkAllocationCallbacks* pAllocator - VkPipeline* pPipelines - - - VkResult vkCreateComputePipelines - VkDevice device - VkPipelineCache pipelineCache - uint32_t createInfoCount - const VkComputePipelineCreateInfo* pCreateInfos - const VkAllocationCallbacks* pAllocator - VkPipeline* pPipelines - - - void vkDestroyPipeline - VkDevice device - VkPipeline pipeline - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreatePipelineLayout - VkDevice device - const VkPipelineLayoutCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkPipelineLayout* pPipelineLayout - - - void vkDestroyPipelineLayout - VkDevice device - VkPipelineLayout pipelineLayout - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateSampler - VkDevice device - const VkSamplerCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSampler* pSampler - - - void vkDestroySampler - VkDevice device - VkSampler sampler - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateDescriptorSetLayout - VkDevice device - const VkDescriptorSetLayoutCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDescriptorSetLayout* pSetLayout - - - void vkDestroyDescriptorSetLayout - VkDevice device - VkDescriptorSetLayout descriptorSetLayout - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateDescriptorPool - VkDevice device - const VkDescriptorPoolCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDescriptorPool* pDescriptorPool - - - void vkDestroyDescriptorPool - VkDevice device - VkDescriptorPool descriptorPool - const VkAllocationCallbacks* pAllocator - - - VkResult vkResetDescriptorPool - VkDevice device - VkDescriptorPool descriptorPool - VkDescriptorPoolResetFlags flags - - any sname:VkDescriptorSet objects allocated from pname:descriptorPool - - - - VkResult vkAllocateDescriptorSets - VkDevice device - const VkDescriptorSetAllocateInfo* pAllocateInfo - VkDescriptorSet* pDescriptorSets - - - VkResult vkFreeDescriptorSets - VkDevice device - VkDescriptorPool descriptorPool - uint32_t descriptorSetCount - const VkDescriptorSet* pDescriptorSets - - - void vkUpdateDescriptorSets - VkDevice device - uint32_t descriptorWriteCount - const VkWriteDescriptorSet* pDescriptorWrites - uint32_t descriptorCopyCount - const VkCopyDescriptorSet* pDescriptorCopies - - - VkResult vkCreateFramebuffer - VkDevice device - const VkFramebufferCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkFramebuffer* pFramebuffer - - - void vkDestroyFramebuffer - VkDevice device - VkFramebuffer framebuffer - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateRenderPass - VkDevice device - const VkRenderPassCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkRenderPass* pRenderPass - - - void vkDestroyRenderPass - VkDevice device - VkRenderPass renderPass - const VkAllocationCallbacks* pAllocator - - - void vkGetRenderAreaGranularity - VkDevice device - VkRenderPass renderPass - VkExtent2D* pGranularity - - - VkResult vkCreateCommandPool - VkDevice device - const VkCommandPoolCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkCommandPool* pCommandPool - - - void vkDestroyCommandPool - VkDevice device - VkCommandPool commandPool - const VkAllocationCallbacks* pAllocator - - - VkResult vkResetCommandPool - VkDevice device - VkCommandPool commandPool - VkCommandPoolResetFlags flags - - - VkResult vkAllocateCommandBuffers - VkDevice device - const VkCommandBufferAllocateInfo* pAllocateInfo - VkCommandBuffer* pCommandBuffers - - - void vkFreeCommandBuffers - VkDevice device - VkCommandPool commandPool - uint32_t commandBufferCount - const VkCommandBuffer* pCommandBuffers - - - VkResult vkBeginCommandBuffer - VkCommandBuffer commandBuffer - const VkCommandBufferBeginInfo* pBeginInfo - - the sname:VkCommandPool that pname:commandBuffer was allocated from - - - - VkResult vkEndCommandBuffer - VkCommandBuffer commandBuffer - - the sname:VkCommandPool that pname:commandBuffer was allocated from - - - - VkResult vkResetCommandBuffer - VkCommandBuffer commandBuffer - VkCommandBufferResetFlags flags - - - void vkCmdBindPipeline - VkCommandBuffer commandBuffer - VkPipelineBindPoint pipelineBindPoint - VkPipeline pipeline - - - void vkCmdSetViewport - VkCommandBuffer commandBuffer - uint32_t firstViewport - uint32_t viewportCount - const VkViewport* pViewports - - - void vkCmdSetScissor - VkCommandBuffer commandBuffer - uint32_t firstScissor - uint32_t scissorCount - const VkRect2D* pScissors - - - void vkCmdSetLineWidth - VkCommandBuffer commandBuffer - float lineWidth - - - void vkCmdSetDepthBias - VkCommandBuffer commandBuffer - float depthBiasConstantFactor - float depthBiasClamp - float depthBiasSlopeFactor - - - void vkCmdSetBlendConstants - VkCommandBuffer commandBuffer - const float blendConstants[4] - - - void vkCmdSetDepthBounds - VkCommandBuffer commandBuffer - float minDepthBounds - float maxDepthBounds - - - void vkCmdSetStencilCompareMask - VkCommandBuffer commandBuffer - VkStencilFaceFlags faceMask - uint32_t compareMask - - - void vkCmdSetStencilWriteMask - VkCommandBuffer commandBuffer - VkStencilFaceFlags faceMask - uint32_t writeMask - - - void vkCmdSetStencilReference - VkCommandBuffer commandBuffer - VkStencilFaceFlags faceMask - uint32_t reference - - - void vkCmdBindDescriptorSets - VkCommandBuffer commandBuffer - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayout layout - uint32_t firstSet - uint32_t descriptorSetCount - const VkDescriptorSet* pDescriptorSets - uint32_t dynamicOffsetCount - const uint32_t* pDynamicOffsets - - - void vkCmdBindIndexBuffer - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkIndexType indexType - - - void vkCmdBindVertexBuffers - VkCommandBuffer commandBuffer - uint32_t firstBinding - uint32_t bindingCount - const VkBuffer* pBuffers - const VkDeviceSize* pOffsets - - - void vkCmdDraw - VkCommandBuffer commandBuffer - uint32_t vertexCount - uint32_t instanceCount - uint32_t firstVertex - uint32_t firstInstance - - - void vkCmdDrawIndexed - VkCommandBuffer commandBuffer - uint32_t indexCount - uint32_t instanceCount - uint32_t firstIndex - int32_t vertexOffset - uint32_t firstInstance - - - void vkCmdDrawIndirect - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - uint32_t drawCount - uint32_t stride - - - void vkCmdDrawIndexedIndirect - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - uint32_t drawCount - uint32_t stride - - - void vkCmdDispatch - VkCommandBuffer commandBuffer - uint32_t groupCountX - uint32_t groupCountY - uint32_t groupCountZ - - - void vkCmdDispatchIndirect - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - - - void vkCmdCopyBuffer - VkCommandBuffer commandBuffer - VkBuffer srcBuffer - VkBuffer dstBuffer - uint32_t regionCount - const VkBufferCopy* pRegions - - - void vkCmdCopyImage - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkImageCopy* pRegions - - - void vkCmdBlitImage - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkImageBlit* pRegions - VkFilter filter - - - void vkCmdCopyBufferToImage - VkCommandBuffer commandBuffer - VkBuffer srcBuffer - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkBufferImageCopy* pRegions - - - void vkCmdCopyImageToBuffer - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkBuffer dstBuffer - uint32_t regionCount - const VkBufferImageCopy* pRegions - - - void vkCmdUpdateBuffer - VkCommandBuffer commandBuffer - VkBuffer dstBuffer - VkDeviceSize dstOffset - VkDeviceSize dataSize - const void* pData - - - void vkCmdFillBuffer - VkCommandBuffer commandBuffer - VkBuffer dstBuffer - VkDeviceSize dstOffset - VkDeviceSize size - uint32_t data - - - void vkCmdClearColorImage - VkCommandBuffer commandBuffer - VkImage image - VkImageLayout imageLayout - const VkClearColorValue* pColor - uint32_t rangeCount - const VkImageSubresourceRange* pRanges - - - void vkCmdClearDepthStencilImage - VkCommandBuffer commandBuffer - VkImage image - VkImageLayout imageLayout - const VkClearDepthStencilValue* pDepthStencil - uint32_t rangeCount - const VkImageSubresourceRange* pRanges - - - void vkCmdClearAttachments - VkCommandBuffer commandBuffer - uint32_t attachmentCount - const VkClearAttachment* pAttachments - uint32_t rectCount - const VkClearRect* pRects - - - void vkCmdResolveImage - VkCommandBuffer commandBuffer - VkImage srcImage - VkImageLayout srcImageLayout - VkImage dstImage - VkImageLayout dstImageLayout - uint32_t regionCount - const VkImageResolve* pRegions - - - void vkCmdSetEvent - VkCommandBuffer commandBuffer - VkEvent event - VkPipelineStageFlags stageMask - - - void vkCmdResetEvent - VkCommandBuffer commandBuffer - VkEvent event - VkPipelineStageFlags stageMask - - - void vkCmdWaitEvents - VkCommandBuffer commandBuffer - uint32_t eventCount - const VkEvent* pEvents - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - uint32_t memoryBarrierCount - const VkMemoryBarrier* pMemoryBarriers - uint32_t bufferMemoryBarrierCount - const VkBufferMemoryBarrier* pBufferMemoryBarriers - uint32_t imageMemoryBarrierCount - const VkImageMemoryBarrier* pImageMemoryBarriers - - - void vkCmdPipelineBarrier - VkCommandBuffer commandBuffer - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - VkDependencyFlags dependencyFlags - uint32_t memoryBarrierCount - const VkMemoryBarrier* pMemoryBarriers - uint32_t bufferMemoryBarrierCount - const VkBufferMemoryBarrier* pBufferMemoryBarriers - uint32_t imageMemoryBarrierCount - const VkImageMemoryBarrier* pImageMemoryBarriers - - - void vkCmdBeginQuery - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t query - VkQueryControlFlags flags - - - void vkCmdEndQuery - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t query - - - void vkCmdResetQueryPool - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t firstQuery - uint32_t queryCount - - - void vkCmdWriteTimestamp - VkCommandBuffer commandBuffer - VkPipelineStageFlagBits pipelineStage - VkQueryPool queryPool - uint32_t query - - - void vkCmdCopyQueryPoolResults - VkCommandBuffer commandBuffer - VkQueryPool queryPool - uint32_t firstQuery - uint32_t queryCount - VkBuffer dstBuffer - VkDeviceSize dstOffset - VkDeviceSize stride - VkQueryResultFlags flags - - - void vkCmdPushConstants - VkCommandBuffer commandBuffer - VkPipelineLayout layout - VkShaderStageFlags stageFlags - uint32_t offset - uint32_t size - const void* pValues - - - void vkCmdBeginRenderPass - VkCommandBuffer commandBuffer - const VkRenderPassBeginInfo* pRenderPassBegin - VkSubpassContents contents - - - void vkCmdNextSubpass - VkCommandBuffer commandBuffer - VkSubpassContents contents - - - void vkCmdEndRenderPass - VkCommandBuffer commandBuffer - - - void vkCmdExecuteCommands - VkCommandBuffer commandBuffer - uint32_t commandBufferCount - const VkCommandBuffer* pCommandBuffers - - - VkResult vkCreateAndroidSurfaceKHR - VkInstance instance - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkGetPhysicalDeviceDisplayPropertiesKHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayPropertiesKHR* pProperties - - - VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayPlanePropertiesKHR* pProperties - - - VkResult vkGetDisplayPlaneSupportedDisplaysKHR - VkPhysicalDevice physicalDevice - uint32_t planeIndex - uint32_t* pDisplayCount - VkDisplayKHR* pDisplays - - - VkResult vkGetDisplayModePropertiesKHR - VkPhysicalDevice physicalDevice - VkDisplayKHR display - uint32_t* pPropertyCount - VkDisplayModePropertiesKHR* pProperties - - - VkResult vkCreateDisplayModeKHR - VkPhysicalDevice physicalDevice - VkDisplayKHR display - const VkDisplayModeCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDisplayModeKHR* pMode - - - VkResult vkGetDisplayPlaneCapabilitiesKHR - VkPhysicalDevice physicalDevice - VkDisplayModeKHR mode - uint32_t planeIndex - VkDisplayPlaneCapabilitiesKHR* pCapabilities - - - VkResult vkCreateDisplayPlaneSurfaceKHR - VkInstance instance - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkCreateSharedSwapchainsKHR - VkDevice device - uint32_t swapchainCount - const VkSwapchainCreateInfoKHR* pCreateInfos - const VkAllocationCallbacks* pAllocator - VkSwapchainKHR* pSwapchains - - - VkResult vkCreateMirSurfaceKHR - VkInstance instance - const VkMirSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - MirConnection* connection - - - void vkDestroySurfaceKHR - VkInstance instance - VkSurfaceKHR surface - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetPhysicalDeviceSurfaceSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - VkSurfaceKHR surface - VkBool32* pSupported - - - VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities - - - VkResult vkGetPhysicalDeviceSurfaceFormatsKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - uint32_t* pSurfaceFormatCount - VkSurfaceFormatKHR* pSurfaceFormats - - - VkResult vkGetPhysicalDeviceSurfacePresentModesKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - uint32_t* pPresentModeCount - VkPresentModeKHR* pPresentModes - - - VkResult vkCreateSwapchainKHR - VkDevice device - const VkSwapchainCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSwapchainKHR* pSwapchain - - - void vkDestroySwapchainKHR - VkDevice device - VkSwapchainKHR swapchain - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetSwapchainImagesKHR - VkDevice device - VkSwapchainKHR swapchain - uint32_t* pSwapchainImageCount - VkImage* pSwapchainImages - - - VkResult vkAcquireNextImageKHR - VkDevice device - VkSwapchainKHR swapchain - uint64_t timeout - VkSemaphore semaphore - VkFence fence - uint32_t* pImageIndex - - - VkResult vkQueuePresentKHR - VkQueue queue - const VkPresentInfoKHR* pPresentInfo - - - VkResult vkCreateViSurfaceNN - VkInstance instance - const VkViSurfaceCreateInfoNN* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkCreateWaylandSurfaceKHR - VkInstance instance - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - struct wl_display* display - - - VkResult vkCreateWin32SurfaceKHR - VkInstance instance - const VkWin32SurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - - - VkResult vkCreateXlibSurfaceKHR - VkInstance instance - const VkXlibSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - Display* dpy - VisualID visualID - - - VkResult vkCreateXcbSurfaceKHR - VkInstance instance - const VkXcbSurfaceCreateInfoKHR* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR - VkPhysicalDevice physicalDevice - uint32_t queueFamilyIndex - xcb_connection_t* connection - xcb_visualid_t visual_id - - - VkResult vkCreateDebugReportCallbackEXT - VkInstance instance - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDebugReportCallbackEXT* pCallback - - - void vkDestroyDebugReportCallbackEXT - VkInstance instance - VkDebugReportCallbackEXT callback - const VkAllocationCallbacks* pAllocator - - - void vkDebugReportMessageEXT - VkInstance instance - VkDebugReportFlagsEXT flags - VkDebugReportObjectTypeEXT objectType - uint64_t object - size_t location - int32_t messageCode - const char* pLayerPrefix - const char* pMessage - - - VkResult vkDebugMarkerSetObjectNameEXT - VkDevice device - const VkDebugMarkerObjectNameInfoEXT* pNameInfo - - - VkResult vkDebugMarkerSetObjectTagEXT - VkDevice device - const VkDebugMarkerObjectTagInfoEXT* pTagInfo - - - void vkCmdDebugMarkerBeginEXT - VkCommandBuffer commandBuffer - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo - - - void vkCmdDebugMarkerEndEXT - VkCommandBuffer commandBuffer - - - void vkCmdDebugMarkerInsertEXT - VkCommandBuffer commandBuffer - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo - - - VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV - VkPhysicalDevice physicalDevice - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags - VkExternalMemoryHandleTypeFlagsNV externalHandleType - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties - - - VkResult vkGetMemoryWin32HandleNV - VkDevice device - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagsNV handleType - HANDLE* pHandle - - - void vkCmdDrawIndirectCountAMD - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - void vkCmdDrawIndexedIndirectCountAMD - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - void vkCmdProcessCommandsNVX - VkCommandBuffer commandBuffer - const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo - - - void vkCmdReserveSpaceForCommandsNVX - VkCommandBuffer commandBuffer - const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo - - - VkResult vkCreateIndirectCommandsLayoutNVX - VkDevice device - const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout - - - void vkDestroyIndirectCommandsLayoutNVX - VkDevice device - VkIndirectCommandsLayoutNVX indirectCommandsLayout - const VkAllocationCallbacks* pAllocator - - - VkResult vkCreateObjectTableNVX - VkDevice device - const VkObjectTableCreateInfoNVX* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkObjectTableNVX* pObjectTable - - - void vkDestroyObjectTableNVX - VkDevice device - VkObjectTableNVX objectTable - const VkAllocationCallbacks* pAllocator - - - VkResult vkRegisterObjectsNVX - VkDevice device - VkObjectTableNVX objectTable - uint32_t objectCount - const VkObjectTableEntryNVX* const* ppObjectTableEntries - const uint32_t* pObjectIndices - - - VkResult vkUnregisterObjectsNVX - VkDevice device - VkObjectTableNVX objectTable - uint32_t objectCount - const VkObjectEntryTypeNVX* pObjectEntryTypes - const uint32_t* pObjectIndices - - - void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX - VkPhysicalDevice physicalDevice - VkDeviceGeneratedCommandsFeaturesNVX* pFeatures - VkDeviceGeneratedCommandsLimitsNVX* pLimits - - - void vkGetPhysicalDeviceFeatures2 - VkPhysicalDevice physicalDevice - VkPhysicalDeviceFeatures2* pFeatures - - - - void vkGetPhysicalDeviceProperties2 - VkPhysicalDevice physicalDevice - VkPhysicalDeviceProperties2* pProperties - - - - void vkGetPhysicalDeviceFormatProperties2 - VkPhysicalDevice physicalDevice - VkFormat format - VkFormatProperties2* pFormatProperties - - - - VkResult vkGetPhysicalDeviceImageFormatProperties2 - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo - VkImageFormatProperties2* pImageFormatProperties - - - - void vkGetPhysicalDeviceQueueFamilyProperties2 - VkPhysicalDevice physicalDevice - uint32_t* pQueueFamilyPropertyCount - VkQueueFamilyProperties2* pQueueFamilyProperties - - - - void vkGetPhysicalDeviceMemoryProperties2 - VkPhysicalDevice physicalDevice - VkPhysicalDeviceMemoryProperties2* pMemoryProperties - - - - void vkGetPhysicalDeviceSparseImageFormatProperties2 - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo - uint32_t* pPropertyCount - VkSparseImageFormatProperties2* pProperties - - - - void vkCmdPushDescriptorSetKHR - VkCommandBuffer commandBuffer - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayout layout - uint32_t set - uint32_t descriptorWriteCount - const VkWriteDescriptorSet* pDescriptorWrites - - - void vkTrimCommandPool - VkDevice device - VkCommandPool commandPool - VkCommandPoolTrimFlags flags - - - - void vkGetPhysicalDeviceExternalBufferProperties - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo - VkExternalBufferProperties* pExternalBufferProperties - - - - VkResult vkGetMemoryWin32HandleKHR - VkDevice device - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo - HANDLE* pHandle - - - VkResult vkGetMemoryWin32HandlePropertiesKHR - VkDevice device - VkExternalMemoryHandleTypeFlagBits handleType - HANDLE handle - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties - - - VkResult vkGetMemoryFdKHR - VkDevice device - const VkMemoryGetFdInfoKHR* pGetFdInfo - int* pFd - - - VkResult vkGetMemoryFdPropertiesKHR - VkDevice device - VkExternalMemoryHandleTypeFlagBits handleType - int fd - VkMemoryFdPropertiesKHR* pMemoryFdProperties - - - void vkGetPhysicalDeviceExternalSemaphoreProperties - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo - VkExternalSemaphoreProperties* pExternalSemaphoreProperties - - - - VkResult vkGetSemaphoreWin32HandleKHR - VkDevice device - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo - HANDLE* pHandle - - - VkResult vkImportSemaphoreWin32HandleKHR - VkDevice device - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo - - - VkResult vkGetSemaphoreFdKHR - VkDevice device - const VkSemaphoreGetFdInfoKHR* pGetFdInfo - int* pFd - - - VkResult vkImportSemaphoreFdKHR - VkDevice device - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo - - - void vkGetPhysicalDeviceExternalFenceProperties - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo - VkExternalFenceProperties* pExternalFenceProperties - - - - VkResult vkGetFenceWin32HandleKHR - VkDevice device - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo - HANDLE* pHandle - - - VkResult vkImportFenceWin32HandleKHR - VkDevice device - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo - - - VkResult vkGetFenceFdKHR - VkDevice device - const VkFenceGetFdInfoKHR* pGetFdInfo - int* pFd - - - VkResult vkImportFenceFdKHR - VkDevice device - const VkImportFenceFdInfoKHR* pImportFenceFdInfo - - - VkResult vkReleaseDisplayEXT - VkPhysicalDevice physicalDevice - VkDisplayKHR display - - - VkResult vkAcquireXlibDisplayEXT - VkPhysicalDevice physicalDevice - Display* dpy - VkDisplayKHR display - - - VkResult vkGetRandROutputDisplayEXT - VkPhysicalDevice physicalDevice - Display* dpy - RROutput rrOutput - VkDisplayKHR* pDisplay - - - VkResult vkDisplayPowerControlEXT - VkDevice device - VkDisplayKHR display - const VkDisplayPowerInfoEXT* pDisplayPowerInfo - - - VkResult vkRegisterDeviceEventEXT - VkDevice device - const VkDeviceEventInfoEXT* pDeviceEventInfo - const VkAllocationCallbacks* pAllocator - VkFence* pFence - - - VkResult vkRegisterDisplayEventEXT - VkDevice device - VkDisplayKHR display - const VkDisplayEventInfoEXT* pDisplayEventInfo - const VkAllocationCallbacks* pAllocator - VkFence* pFence - - - VkResult vkGetSwapchainCounterEXT - VkDevice device - VkSwapchainKHR swapchain - VkSurfaceCounterFlagBitsEXT counter - uint64_t* pCounterValue - - - VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - VkSurfaceCapabilities2EXT* pSurfaceCapabilities - - - VkResult vkEnumeratePhysicalDeviceGroups - VkInstance instance - uint32_t* pPhysicalDeviceGroupCount - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties - - - - void vkGetDeviceGroupPeerMemoryFeatures - VkDevice device - uint32_t heapIndex - uint32_t localDeviceIndex - uint32_t remoteDeviceIndex - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures - - - - VkResult vkBindBufferMemory2 - VkDevice device - uint32_t bindInfoCount - const VkBindBufferMemoryInfo* pBindInfos - - - - VkResult vkBindImageMemory2 - VkDevice device - uint32_t bindInfoCount - const VkBindImageMemoryInfo* pBindInfos - - - - void vkCmdSetDeviceMask - VkCommandBuffer commandBuffer - uint32_t deviceMask - - - - VkResult vkGetDeviceGroupPresentCapabilitiesKHR - VkDevice device - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities - - - VkResult vkGetDeviceGroupSurfacePresentModesKHR - VkDevice device - VkSurfaceKHR surface - VkDeviceGroupPresentModeFlagsKHR* pModes - - - VkResult vkAcquireNextImage2KHR - VkDevice device - const VkAcquireNextImageInfoKHR* pAcquireInfo - uint32_t* pImageIndex - - - void vkCmdDispatchBase - VkCommandBuffer commandBuffer - uint32_t baseGroupX - uint32_t baseGroupY - uint32_t baseGroupZ - uint32_t groupCountX - uint32_t groupCountY - uint32_t groupCountZ - - - - VkResult vkGetPhysicalDevicePresentRectanglesKHR - VkPhysicalDevice physicalDevice - VkSurfaceKHR surface - uint32_t* pRectCount - VkRect2D* pRects - - - VkResult vkCreateDescriptorUpdateTemplate - VkDevice device - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate - - - - void vkDestroyDescriptorUpdateTemplate - VkDevice device - VkDescriptorUpdateTemplate descriptorUpdateTemplate - const VkAllocationCallbacks* pAllocator - - - - void vkUpdateDescriptorSetWithTemplate - VkDevice device - VkDescriptorSet descriptorSet - VkDescriptorUpdateTemplate descriptorUpdateTemplate - const void* pData - - - - void vkCmdPushDescriptorSetWithTemplateKHR - VkCommandBuffer commandBuffer - VkDescriptorUpdateTemplate descriptorUpdateTemplate - VkPipelineLayout layout - uint32_t set - const void* pData - - - void vkSetHdrMetadataEXT - VkDevice device - uint32_t swapchainCount - const VkSwapchainKHR* pSwapchains - const VkHdrMetadataEXT* pMetadata - - - VkResult vkGetSwapchainStatusKHR - VkDevice device - VkSwapchainKHR swapchain - - - VkResult vkGetRefreshCycleDurationGOOGLE - VkDevice device - VkSwapchainKHR swapchain - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties - - - VkResult vkGetPastPresentationTimingGOOGLE - VkDevice device - VkSwapchainKHR swapchain - uint32_t* pPresentationTimingCount - VkPastPresentationTimingGOOGLE* pPresentationTimings - - - VkResult vkCreateIOSSurfaceMVK - VkInstance instance - const VkIOSSurfaceCreateInfoMVK* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - VkResult vkCreateMacOSSurfaceMVK - VkInstance instance - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSurfaceKHR* pSurface - - - void vkCmdSetViewportWScalingNV - VkCommandBuffer commandBuffer - uint32_t firstViewport - uint32_t viewportCount - const VkViewportWScalingNV* pViewportWScalings - - - void vkCmdSetDiscardRectangleEXT - VkCommandBuffer commandBuffer - uint32_t firstDiscardRectangle - uint32_t discardRectangleCount - const VkRect2D* pDiscardRectangles - - - void vkCmdSetSampleLocationsEXT - VkCommandBuffer commandBuffer - const VkSampleLocationsInfoEXT* pSampleLocationsInfo - - - void vkGetPhysicalDeviceMultisamplePropertiesEXT - VkPhysicalDevice physicalDevice - VkSampleCountFlagBits samples - VkMultisamplePropertiesEXT* pMultisampleProperties - - - VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo - VkSurfaceCapabilities2KHR* pSurfaceCapabilities - - - VkResult vkGetPhysicalDeviceSurfaceFormats2KHR - VkPhysicalDevice physicalDevice - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo - uint32_t* pSurfaceFormatCount - VkSurfaceFormat2KHR* pSurfaceFormats - - - VkResult vkGetPhysicalDeviceDisplayProperties2KHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayProperties2KHR* pProperties - - - VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR - VkPhysicalDevice physicalDevice - uint32_t* pPropertyCount - VkDisplayPlaneProperties2KHR* pProperties - - - VkResult vkGetDisplayModeProperties2KHR - VkPhysicalDevice physicalDevice - VkDisplayKHR display - uint32_t* pPropertyCount - VkDisplayModeProperties2KHR* pProperties - - - VkResult vkGetDisplayPlaneCapabilities2KHR - VkPhysicalDevice physicalDevice - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo - VkDisplayPlaneCapabilities2KHR* pCapabilities - - - void vkGetBufferMemoryRequirements2 - VkDevice device - const VkBufferMemoryRequirementsInfo2* pInfo - VkMemoryRequirements2* pMemoryRequirements - - - - void vkGetImageMemoryRequirements2 - VkDevice device - const VkImageMemoryRequirementsInfo2* pInfo - VkMemoryRequirements2* pMemoryRequirements - - - - void vkGetImageSparseMemoryRequirements2 - VkDevice device - const VkImageSparseMemoryRequirementsInfo2* pInfo - uint32_t* pSparseMemoryRequirementCount - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements - - - - VkResult vkCreateSamplerYcbcrConversion - VkDevice device - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkSamplerYcbcrConversion* pYcbcrConversion - - - - void vkDestroySamplerYcbcrConversion - VkDevice device - VkSamplerYcbcrConversion ycbcrConversion - const VkAllocationCallbacks* pAllocator - - - - void vkGetDeviceQueue2 - VkDevice device - const VkDeviceQueueInfo2* pQueueInfo - VkQueue* pQueue - - - VkResult vkCreateValidationCacheEXT - VkDevice device - const VkValidationCacheCreateInfoEXT* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkValidationCacheEXT* pValidationCache - - - void vkDestroyValidationCacheEXT - VkDevice device - VkValidationCacheEXT validationCache - const VkAllocationCallbacks* pAllocator - - - VkResult vkGetValidationCacheDataEXT - VkDevice device - VkValidationCacheEXT validationCache - size_t* pDataSize - void* pData - - - VkResult vkMergeValidationCachesEXT - VkDevice device - VkValidationCacheEXT dstCache - uint32_t srcCacheCount - const VkValidationCacheEXT* pSrcCaches - - - void vkGetDescriptorSetLayoutSupport - VkDevice device - const VkDescriptorSetLayoutCreateInfo* pCreateInfo - VkDescriptorSetLayoutSupport* pSupport - - - - VkResult vkGetSwapchainGrallocUsageANDROID - VkDevice device - VkFormat format - VkImageUsageFlags imageUsage - int* grallocUsage - - - VkResult vkAcquireImageANDROID - VkDevice device - VkImage image - int nativeFenceFd - VkSemaphore semaphore - VkFence fence - - - VkResult vkQueueSignalReleaseImageANDROID - VkQueue queue - uint32_t waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - VkImage image - int* pNativeFenceFd - - - VkResult vkGetShaderInfoAMD - VkDevice device - VkPipeline pipeline - VkShaderStageFlagBits shaderStage - VkShaderInfoTypeAMD infoType - size_t* pInfoSize - void* pInfo - - - VkResult vkSetDebugUtilsObjectNameEXT - VkDevice device - const VkDebugUtilsObjectNameInfoEXT* pNameInfo - - - VkResult vkSetDebugUtilsObjectTagEXT - VkDevice device - const VkDebugUtilsObjectTagInfoEXT* pTagInfo - - - void vkQueueBeginDebugUtilsLabelEXT - VkQueue queue - const VkDebugUtilsLabelEXT* pLabelInfo - - - void vkQueueEndDebugUtilsLabelEXT - VkQueue queue - - - void vkQueueInsertDebugUtilsLabelEXT - VkQueue queue - const VkDebugUtilsLabelEXT* pLabelInfo - - - void vkCmdBeginDebugUtilsLabelEXT - VkCommandBuffer commandBuffer - const VkDebugUtilsLabelEXT* pLabelInfo - - - void vkCmdEndDebugUtilsLabelEXT - VkCommandBuffer commandBuffer - - - void vkCmdInsertDebugUtilsLabelEXT - VkCommandBuffer commandBuffer - const VkDebugUtilsLabelEXT* pLabelInfo - - - VkResult vkCreateDebugUtilsMessengerEXT - VkInstance instance - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo - const VkAllocationCallbacks* pAllocator - VkDebugUtilsMessengerEXT* pMessenger - - - void vkDestroyDebugUtilsMessengerEXT - VkInstance instance - VkDebugUtilsMessengerEXT messenger - const VkAllocationCallbacks* pAllocator - - - void vkSubmitDebugUtilsMessageEXT - VkInstance instance - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity - VkDebugUtilsMessageTypeFlagsEXT messageTypes - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData - - - VkResult vkGetMemoryHostPointerPropertiesEXT - VkDevice device - VkExternalMemoryHandleTypeFlagBits handleType - const void* pHostPointer - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties - - - void vkCmdWriteBufferMarkerAMD - VkCommandBuffer commandBuffer - VkPipelineStageFlagBits pipelineStage - VkBuffer dstBuffer - VkDeviceSize dstOffset - uint32_t marker - - - VkResult vkGetAndroidHardwareBufferPropertiesANDROID - VkDevice device - const struct AHardwareBuffer* buffer - VkAndroidHardwareBufferPropertiesANDROID* pProperties - - - VkResult vkGetMemoryAndroidHardwareBufferANDROID - VkDevice device - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo - struct AHardwareBuffer** pBuffer - - - void vkCmdDrawIndirectCountKHR - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - void vkCmdDrawIndexedIndirectCountKHR - VkCommandBuffer commandBuffer - VkBuffer buffer - VkDeviceSize offset - VkBuffer countBuffer - VkDeviceSize countBufferOffset - uint32_t maxDrawCount - uint32_t stride - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum - offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Additional dependent types / tokens extending enumerants, not explicitly mentioned - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Additional dependent types / tokens extending enumerants, not explicitly mentioned - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - This duplicates definitions in VK_KHR_device_group below - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - This duplicates definitions in other extensions, below - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - enum offset=0 was mistakenly used for the 1.1 core enum - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES - (value=1000094000). Fortunately, no conflict resulted. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From 2623e23f7735544567135b31450545018205f721 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 29 Jul 2018 23:16:42 +0200 Subject: [PATCH 028/122] Properly add the vulkan headers submodule --- generator/--force | 1 + 1 file changed, 1 insertion(+) create mode 160000 generator/--force diff --git a/generator/--force b/generator/--force new file mode 160000 index 0000000..82e7301 --- /dev/null +++ b/generator/--force @@ -0,0 +1 @@ +Subproject commit 82e73015b0632833939349d767af39cb88836f29 From b2098bd942ff392e8d1cb32f45a71d6666e1fef5 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 30 Jul 2018 08:54:03 +0200 Subject: [PATCH 029/122] Cleanup from clippy --- generator/src/lib.rs | 75 +++++++++++++++----------------------------- 1 file changed, 25 insertions(+), 50 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 5ad486a..ccf7947 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -27,7 +27,7 @@ pub enum CType { } impl CType { - fn to_tokens(&self) -> Tokens { + fn to_tokens(self) -> Tokens { let term = match self { CType::USize => Term::intern("usize"), CType::U32 => Term::intern("u32"), @@ -458,50 +458,26 @@ impl Constant { } pub fn from_extension_enum(constant: &vkxml::ExtensionEnum) -> Option { - let number = constant.number.map(|n| Constant::Number(n)); + let number = constant.number.map(Constant::Number); let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); - let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); + let bitpos = constant.bitpos.map(Constant::BitPos); let expr = constant .c_expression .as_ref() .map(|e| Constant::CExpr(e.clone())); number.or(hex).or(bitpos).or(expr) } - pub fn from_extension_constant(constant: &vkxml::ExtensionConstant) -> Self { - let number = constant.number.map(|n| Constant::Number(n)); - let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); - let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); - let text = constant - .text - .as_ref() - .map(|bit| Constant::Text(bit.clone())); - let expr = constant - .c_expression - .as_ref() - .map(|e| Constant::CExpr(e.clone())); - number.or(hex).or(bitpos).or(expr).or(text).expect("") - } + pub fn from_constant(constant: &vkxml::Constant) -> Self { - let number = constant.number.map(|n| Constant::Number(n)); + let number = constant.number.map(Constant::Number); let hex = constant.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); - let bitpos = constant.bitpos.map(|bit| Constant::BitPos(bit)); + let bitpos = constant.bitpos.map(Constant::BitPos); let expr = constant .c_expression .as_ref() .map(|e| Constant::CExpr(e.clone())); number.or(hex).or(bitpos).or(expr).expect("") } - pub fn from_extension(extension: &vkxml::ExtensionConstant) -> Self { - let number = extension.number.map(|n| Constant::Number(n)); - let hex = extension.hex.as_ref().map(|hex| Constant::Hex(hex.clone())); - let bitpos = extension.bitpos.map(|bit| Constant::BitPos(bit)); - let expr = extension - .c_expression - .as_ref() - .map(|e| Constant::CExpr(e.clone())); - let text = extension.text.as_ref().map(|e| Constant::Text(e.clone())); - number.or(hex).or(bitpos).or(expr).or(text).expect("") - } } pub trait FeatureExt { @@ -540,8 +516,7 @@ impl CommandExt for vkxml::Command { fn function_type(&self) -> FunctionType { let is_first_param_device = self .param - .iter() - .nth(0) + .get(0) .map(|field| match field.basetype.as_str() { "VkDevice" | "VkCommandBuffer" | "VkQueue" => true, _ => false, @@ -643,7 +618,7 @@ impl FieldExt for vkxml::Field { let size = self .size .as_ref() - .or(self.size_enumref.as_ref()) + .or_else(|| self.size_enumref.as_ref()) .expect("Should have size"); let size = Term::intern(size); Some(quote!{ @@ -811,7 +786,7 @@ pub fn generate_extension_constants<'a>( extnumber, .. } => { - let ext_base = 1000000000; + let ext_base = 1_000_000_000; let ext_block_size = 1000; let extnumber = extnumber.unwrap_or_else(|| extension.number.expect("number")); let value = ext_base + (extnumber - 1) * ext_block_size + offset; @@ -825,7 +800,7 @@ pub fn generate_extension_constants<'a>( constant, }; let ident = name_to_tokens(&extends); - let impl_block = bitflags_impl_block(&ident, &extends, &[&ext_constant]); + let impl_block = bitflags_impl_block(ident, &extends, &[&ext_constant]); let doc_string = format!("Generated from '{}'", extension.name); let q = quote!{ #[doc = #doc_string] @@ -891,7 +866,7 @@ pub fn generate_typedef(typedef: &vkxml::Typedef) -> Tokens { } pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { // Workaround for empty bitmask - if bitmask.name.len() == 0 { + if bitmask.name.is_empty() { return None; } // If this enum has constants, then it will generated later in generate_enums. @@ -935,7 +910,7 @@ pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { } pub fn bitflags_impl_block( - ident: &Ident, + ident: Ident, enum_name: &str, constants: &[&impl ConstantExt], ) -> Tokens { @@ -998,7 +973,7 @@ pub fn generate_enum<'a>( .fold(0, |acc, next| acc | next.bits()); let all_bits_term = Term::intern(&format!("0b{:b}", all_bits)); - let impl_bitflags = bitflags_impl_block(&ident, &_enum.name, &constants); + let impl_bitflags = bitflags_impl_block(ident, &_enum.name, &constants); let q = quote!{ #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1008,7 +983,7 @@ pub fn generate_enum<'a>( }; EnumType::Bitflags(q) } else { - let impl_block = bitflags_impl_block(&ident, &_enum.name, &constants); + let impl_block = bitflags_impl_block(ident, &_enum.name, &constants); let enum_quote = quote!{ #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(C)] @@ -1017,7 +992,7 @@ pub fn generate_enum<'a>( }; let special_quote = match _name.as_str() { //"StructureType" => generate_structure_type(&_name, _enum, create_info_constants), - "Result" => generate_result(&ident, _enum), + "Result" => generate_result(ident, _enum), _ => { quote!{} } @@ -1031,7 +1006,7 @@ pub fn generate_enum<'a>( } } -pub fn generate_result(ident: &Ident, _enum: &vkxml::Enumeration) -> Tokens { +pub fn generate_result(ident: Ident, _enum: &vkxml::Enumeration) -> Tokens { let notation = _enum.elements.iter().filter_map(|elem| { let (variant_name, notation) = match *elem { vkxml::EnumerationElement::Enum(ref constant) => ( @@ -1178,11 +1153,11 @@ pub fn generate_feature(feature: &vkxml::Feature, commands: &CommandMap) -> quot .elements .iter() .flat_map(|feature| { - if let &vkxml::FeatureElement::Require(ref spec) = feature { + if let vkxml::FeatureElement::Require(ref spec) = feature { spec.elements .iter() .filter_map(|feature_spec| { - if let &vkxml::FeatureReference::CommandReference(ref cmd_ref) = + if let vkxml::FeatureReference::CommandReference(ref cmd_ref) = feature_spec { Some(cmd_ref) @@ -1274,7 +1249,7 @@ pub fn write_source_code(path: &Path) { .elements .iter() .filter_map(|elem| match elem { - &vkxml::RegistryElement::Commands(ref cmds) => Some(cmds), + vkxml::RegistryElement::Commands(ref cmds) => Some(cmds), _ => None, }) .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) @@ -1284,27 +1259,27 @@ pub fn write_source_code(path: &Path) { .elements .iter() .filter_map(|elem| match elem { - &vkxml::RegistryElement::Features(ref features) => Some(features), + vkxml::RegistryElement::Features(ref features) => Some(features), _ => None, }) - .flat_map(|features| features.elements.iter().map(|feature| feature)) + .flat_map(|features| features.elements.iter()) .collect(); let definitions: Vec<&vkxml::DefinitionsElement> = spec .elements .iter() .filter_map(|elem| match elem { - &vkxml::RegistryElement::Definitions(ref definitions) => Some(definitions), + vkxml::RegistryElement::Definitions(ref definitions) => Some(definitions), _ => None, }) - .flat_map(|definitions| definitions.elements.iter().map(|definition| definition)) + .flat_map(|definitions| definitions.elements.iter()) .collect(); let enums: Vec<&vkxml::Enumeration> = spec .elements .iter() .filter_map(|elem| match elem { - &vkxml::RegistryElement::Enums(ref enums) => Some(enums), + vkxml::RegistryElement::Enums(ref enums) => Some(enums), _ => None, }) .flat_map(|enums| { @@ -1319,7 +1294,7 @@ pub fn write_source_code(path: &Path) { .elements .iter() .filter_map(|elem| match elem { - &vkxml::RegistryElement::Constants(ref constants) => Some(constants), + vkxml::RegistryElement::Constants(ref constants) => Some(constants), _ => None, }) .flat_map(|constants| constants.elements.iter()) From 773c64cde1eba2ff02352f7f3fe99fa6f2bf97cd Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 30 Jul 2018 12:50:51 +0200 Subject: [PATCH 030/122] Implement automatic derive for Debug --- ash/src/vk.rs | 1296 ++++++++++++++++++++++++++++++------------ generator/src/lib.rs | 121 +++- 2 files changed, 1015 insertions(+), 402 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 5c63bf4..ae5edac 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -4848,45 +4848,45 @@ pub type PFN_vkDebugUtilsMessengerCallbackEXT = p_user_data: *const c_void, ) -> Bool32; #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BaseOutStructure { pub s_type: StructureType, pub p_next: *const BaseOutStructure, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BaseInStructure { pub s_type: StructureType, pub p_next: *const BaseInStructure, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Offset2D { pub x: int32_t, pub y: int32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Offset3D { pub x: int32_t, pub y: int32_t, pub z: int32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Extent2D { pub width: uint32_t, pub height: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Extent3D { pub width: uint32_t, pub height: uint32_t, pub depth: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Viewport { pub x: c_float, pub y: c_float, @@ -4896,20 +4896,20 @@ pub struct Viewport { pub max_depth: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Rect2D { pub offset: Offset2D, pub extent: Extent2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ClearRect { pub rect: Rect2D, pub base_array_layer: uint32_t, pub layer_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ComponentMapping { pub r: ComponentSwizzle, pub g: ComponentSwizzle, @@ -4929,12 +4929,41 @@ pub struct PhysicalDeviceProperties { pub limits: PhysicalDeviceLimits, pub sparse_properties: PhysicalDeviceSparseProperties, } +impl ::std::fmt::Debug for PhysicalDeviceProperties { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("PhysicalDeviceProperties") + .field("api_version", &self.api_version) + .field("driver_version", &self.driver_version) + .field("vendor_id", &self.vendor_id) + .field("device_id", &self.device_id) + .field("device_type", &self.device_type) + .field("device_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) + }) + .field("pipeline_cache_uuid", &unsafe { + ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) + }) + .field("limits", &self.limits) + .field("sparse_properties", &self.sparse_properties) + .finish() + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct ExtensionProperties { pub extension_name: [c_char; VK_MAX_EXTENSION_NAME_SIZE], pub spec_version: uint32_t, } +impl ::std::fmt::Debug for ExtensionProperties { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("ExtensionProperties") + .field("extension_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) + }) + .field("spec_version", &self.spec_version) + .finish() + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct LayerProperties { @@ -4943,8 +4972,22 @@ pub struct LayerProperties { pub implementation_version: uint32_t, pub description: [c_char; VK_MAX_DESCRIPTION_SIZE], } +impl ::std::fmt::Debug for LayerProperties { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("LayerProperties") + .field("layer_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) + }) + .field("spec_version", &self.spec_version) + .field("implementation_version", &self.implementation_version) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) + }) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ApplicationInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -4964,8 +5007,23 @@ pub struct AllocationCallbacks { pub pfn_internal_allocation: PFN_vkInternalAllocationNotification, pub pfn_internal_free: PFN_vkInternalFreeNotification, } +impl ::std::fmt::Debug for AllocationCallbacks { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("AllocationCallbacks") + .field("p_user_data", &self.p_user_data) + .field("pfn_allocation", &(self.pfn_allocation as *const ())) + .field("pfn_reallocation", &(self.pfn_reallocation as *const ())) + .field("pfn_free", &(self.pfn_free as *const ())) + .field( + "pfn_internal_allocation", + &(self.pfn_internal_allocation as *const ()), + ) + .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceQueueCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -4975,7 +5033,7 @@ pub struct DeviceQueueCreateInfo { pub p_queue_priorities: *const c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -4989,7 +5047,7 @@ pub struct DeviceCreateInfo { pub p_enabled_features: *const PhysicalDeviceFeatures, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct InstanceCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5001,7 +5059,7 @@ pub struct InstanceCreateInfo { pub pp_enabled_extension_names: *const c_char, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct QueueFamilyProperties { pub queue_flags: QueueFlags, pub queue_count: uint32_t, @@ -5016,8 +5074,22 @@ pub struct PhysicalDeviceMemoryProperties { pub memory_heap_count: uint32_t, pub memory_heaps: [MemoryHeap; VK_MAX_MEMORY_HEAPS], } +impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("PhysicalDeviceMemoryProperties") + .field("memory_type_count", &self.memory_type_count) + .field("memory_types", &unsafe { + ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) + }) + .field("memory_heap_count", &self.memory_heap_count) + .field("memory_heaps", &unsafe { + ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) + }) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryAllocateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5025,21 +5097,21 @@ pub struct MemoryAllocateInfo { pub memory_type_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryRequirements { pub size: DeviceSize, pub alignment: DeviceSize, pub memory_type_bits: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageFormatProperties { pub aspect_mask: ImageAspectFlags, pub image_granularity: Extent3D, pub flags: SparseImageFormatFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryRequirements { pub format_properties: SparseImageFormatProperties, pub image_mip_tail_first_lod: uint32_t, @@ -5048,19 +5120,19 @@ pub struct SparseImageMemoryRequirements { pub image_mip_tail_stride: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryType { pub property_flags: MemoryPropertyFlags, pub heap_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryHeap { pub size: DeviceSize, pub flags: MemoryHeapFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MappedMemoryRange { pub s_type: StructureType, pub p_next: *const c_void, @@ -5069,14 +5141,14 @@ pub struct MappedMemoryRange { pub size: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct FormatProperties { pub linear_tiling_features: FormatFeatureFlags, pub optimal_tiling_features: FormatFeatureFlags, pub buffer_features: FormatFeatureFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageFormatProperties { pub max_extent: Extent3D, pub max_mip_levels: uint32_t, @@ -5085,21 +5157,21 @@ pub struct ImageFormatProperties { pub max_resource_size: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorBufferInfo { pub buffer: Buffer, pub offset: DeviceSize, pub range: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorImageInfo { pub sampler: Sampler, pub image_view: ImageView, pub image_layout: ImageLayout, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct WriteDescriptorSet { pub s_type: StructureType, pub p_next: *const c_void, @@ -5113,7 +5185,7 @@ pub struct WriteDescriptorSet { pub p_texel_buffer_view: *const BufferView, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct CopyDescriptorSet { pub s_type: StructureType, pub p_next: *const c_void, @@ -5126,7 +5198,7 @@ pub struct CopyDescriptorSet { pub descriptor_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BufferCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5138,7 +5210,7 @@ pub struct BufferCreateInfo { pub p_queue_family_indices: *const uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BufferViewCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5149,14 +5221,14 @@ pub struct BufferViewCreateInfo { pub range: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageSubresource { pub aspect_mask: ImageAspectFlags, pub mip_level: uint32_t, pub array_layer: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageSubresourceLayers { pub aspect_mask: ImageAspectFlags, pub mip_level: uint32_t, @@ -5164,7 +5236,7 @@ pub struct ImageSubresourceLayers { pub layer_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageSubresourceRange { pub aspect_mask: ImageAspectFlags, pub base_mip_level: uint32_t, @@ -5173,7 +5245,7 @@ pub struct ImageSubresourceRange { pub layer_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryBarrier { pub s_type: StructureType, pub p_next: *const c_void, @@ -5181,7 +5253,7 @@ pub struct MemoryBarrier { pub dst_access_mask: AccessFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BufferMemoryBarrier { pub s_type: StructureType, pub p_next: *const c_void, @@ -5194,7 +5266,7 @@ pub struct BufferMemoryBarrier { pub size: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageMemoryBarrier { pub s_type: StructureType, pub p_next: *const c_void, @@ -5208,7 +5280,7 @@ pub struct ImageMemoryBarrier { pub subresource_range: ImageSubresourceRange, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5227,7 +5299,7 @@ pub struct ImageCreateInfo { pub initial_layout: ImageLayout, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SubresourceLayout { pub offset: DeviceSize, pub size: DeviceSize, @@ -5236,7 +5308,7 @@ pub struct SubresourceLayout { pub depth_pitch: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageViewCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5248,14 +5320,14 @@ pub struct ImageViewCreateInfo { pub subresource_range: ImageSubresourceRange, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BufferCopy { pub src_offset: DeviceSize, pub dst_offset: DeviceSize, pub size: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseMemoryBind { pub resource_offset: DeviceSize, pub size: DeviceSize, @@ -5264,7 +5336,7 @@ pub struct SparseMemoryBind { pub flags: SparseMemoryBindFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryBind { pub subresource: ImageSubresource, pub offset: Offset3D, @@ -5274,28 +5346,28 @@ pub struct SparseImageMemoryBind { pub flags: SparseMemoryBindFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseBufferMemoryBindInfo { pub buffer: Buffer, pub bind_count: uint32_t, pub p_binds: *const SparseMemoryBind, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageOpaqueMemoryBindInfo { pub image: Image, pub bind_count: uint32_t, pub p_binds: *const SparseMemoryBind, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryBindInfo { pub image: Image, pub bind_count: uint32_t, pub p_binds: *const SparseImageMemoryBind, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindSparseInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5311,7 +5383,7 @@ pub struct BindSparseInfo { pub p_signal_semaphores: *const Semaphore, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageCopy { pub src_subresource: ImageSubresourceLayers, pub src_offset: Offset3D, @@ -5327,8 +5399,22 @@ pub struct ImageBlit { pub dst_subresource: ImageSubresourceLayers, pub dst_offsets: [Offset3D; 2], } +impl ::std::fmt::Debug for ImageBlit { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("ImageBlit") + .field("src_subresource", &self.src_subresource) + .field("src_offsets", &unsafe { + ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) + }) + .field("dst_subresource", &self.dst_subresource) + .field("dst_offsets", &unsafe { + ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) + }) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BufferImageCopy { pub buffer_offset: DeviceSize, pub buffer_row_length: uint32_t, @@ -5338,7 +5424,7 @@ pub struct BufferImageCopy { pub image_extent: Extent3D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageResolve { pub src_subresource: ImageSubresourceLayers, pub src_offset: Offset3D, @@ -5347,7 +5433,7 @@ pub struct ImageResolve { pub extent: Extent3D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ShaderModuleCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5356,7 +5442,7 @@ pub struct ShaderModuleCreateInfo { pub p_code: *const uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutBinding { pub binding: uint32_t, pub descriptor_type: DescriptorType, @@ -5365,7 +5451,7 @@ pub struct DescriptorSetLayoutBinding { pub p_immutable_samplers: *const Sampler, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5374,13 +5460,13 @@ pub struct DescriptorSetLayoutCreateInfo { pub p_bindings: *const DescriptorSetLayoutBinding, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorPoolSize { pub ty: DescriptorType, pub descriptor_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorPoolCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5390,7 +5476,7 @@ pub struct DescriptorPoolCreateInfo { pub p_pool_sizes: *const DescriptorPoolSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetAllocateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5399,14 +5485,14 @@ pub struct DescriptorSetAllocateInfo { pub p_set_layouts: *const DescriptorSetLayout, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SpecializationMapEntry { pub constant_id: uint32_t, pub offset: uint32_t, pub size: size_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SpecializationInfo { pub map_entry_count: uint32_t, pub p_map_entries: *const SpecializationMapEntry, @@ -5414,7 +5500,7 @@ pub struct SpecializationInfo { pub p_data: *const c_void, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineShaderStageCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5425,7 +5511,7 @@ pub struct PipelineShaderStageCreateInfo { pub p_specialization_info: *const SpecializationInfo, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ComputePipelineCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5436,14 +5522,14 @@ pub struct ComputePipelineCreateInfo { pub base_pipeline_index: int32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct VertexInputBindingDescription { pub binding: uint32_t, pub stride: uint32_t, pub input_rate: VertexInputRate, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct VertexInputAttributeDescription { pub location: uint32_t, pub binding: uint32_t, @@ -5451,7 +5537,7 @@ pub struct VertexInputAttributeDescription { pub offset: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineVertexInputStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5462,7 +5548,7 @@ pub struct PipelineVertexInputStateCreateInfo { pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineInputAssemblyStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5471,7 +5557,7 @@ pub struct PipelineInputAssemblyStateCreateInfo { pub primitive_restart_enable: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineTessellationStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5479,7 +5565,7 @@ pub struct PipelineTessellationStateCreateInfo { pub patch_control_points: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineViewportStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5490,7 +5576,7 @@ pub struct PipelineViewportStateCreateInfo { pub p_scissors: *const Rect2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5507,7 +5593,7 @@ pub struct PipelineRasterizationStateCreateInfo { pub line_width: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineMultisampleStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5520,7 +5606,7 @@ pub struct PipelineMultisampleStateCreateInfo { pub alpha_to_one_enable: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineColorBlendAttachmentState { pub blend_enable: Bool32, pub src_color_blend_factor: BlendFactor, @@ -5543,8 +5629,24 @@ pub struct PipelineColorBlendStateCreateInfo { pub p_attachments: *const PipelineColorBlendAttachmentState, pub blend_constants: [c_float; 4], } +impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("PipelineColorBlendStateCreateInfo") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("logic_op_enable", &self.logic_op_enable) + .field("logic_op", &self.logic_op) + .field("attachment_count", &self.attachment_count) + .field("p_attachments", &self.p_attachments) + .field("blend_constants", &unsafe { + ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) + }) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineDynamicStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5553,7 +5655,7 @@ pub struct PipelineDynamicStateCreateInfo { pub p_dynamic_states: *const DynamicState, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct StencilOpState { pub fail_op: StencilOp, pub pass_op: StencilOp, @@ -5564,7 +5666,7 @@ pub struct StencilOpState { pub reference: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineDepthStencilStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5580,7 +5682,7 @@ pub struct PipelineDepthStencilStateCreateInfo { pub max_depth_bounds: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct GraphicsPipelineCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5603,7 +5705,7 @@ pub struct GraphicsPipelineCreateInfo { pub base_pipeline_index: int32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineCacheCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5612,14 +5714,14 @@ pub struct PipelineCacheCreateInfo { pub p_initial_data: *const c_void, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PushConstantRange { pub stage_flags: ShaderStageFlags, pub offset: uint32_t, pub size: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineLayoutCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5630,7 +5732,7 @@ pub struct PipelineLayoutCreateInfo { pub p_push_constant_ranges: *const PushConstantRange, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5652,7 +5754,7 @@ pub struct SamplerCreateInfo { pub unnormalized_coordinates: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct CommandPoolCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5660,7 +5762,7 @@ pub struct CommandPoolCreateInfo { pub queue_family_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct CommandBufferAllocateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5669,7 +5771,7 @@ pub struct CommandBufferAllocateInfo { pub command_buffer_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct CommandBufferInheritanceInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5681,7 +5783,7 @@ pub struct CommandBufferInheritanceInfo { pub pipeline_statistics: QueryPipelineStatisticFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct CommandBufferBeginInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5699,6 +5801,19 @@ pub struct RenderPassBeginInfo { pub clear_value_count: uint32_t, pub p_clear_values: *const ClearValue, } +impl ::std::fmt::Debug for RenderPassBeginInfo { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("RenderPassBeginInfo") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("render_pass", &self.render_pass) + .field("framebuffer", &self.framebuffer) + .field("render_area", &self.render_area) + .field("clear_value_count", &self.clear_value_count) + .field("p_clear_values", &"union") + .finish() + } +} #[repr(C)] #[derive(Copy, Clone)] pub union ClearColorValue { @@ -5707,7 +5822,7 @@ pub union ClearColorValue { pub uint32: [uint32_t; 4], } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ClearDepthStencilValue { pub depth: c_float, pub stencil: uint32_t, @@ -5725,8 +5840,17 @@ pub struct ClearAttachment { pub color_attachment: uint32_t, pub clear_value: ClearValue, } +impl ::std::fmt::Debug for ClearAttachment { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("ClearAttachment") + .field("aspect_mask", &self.aspect_mask) + .field("color_attachment", &self.color_attachment) + .field("clear_value", &"union") + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AttachmentDescription { pub flags: AttachmentDescriptionFlags, pub format: Format, @@ -5739,13 +5863,13 @@ pub struct AttachmentDescription { pub final_layout: ImageLayout, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AttachmentReference { pub attachment: uint32_t, pub layout: ImageLayout, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SubpassDescription { pub flags: SubpassDescriptionFlags, pub pipeline_bind_point: PipelineBindPoint, @@ -5759,7 +5883,7 @@ pub struct SubpassDescription { pub p_preserve_attachments: *const uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SubpassDependency { pub src_subpass: uint32_t, pub dst_subpass: uint32_t, @@ -5770,7 +5894,7 @@ pub struct SubpassDependency { pub dependency_flags: DependencyFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RenderPassCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5783,21 +5907,21 @@ pub struct RenderPassCreateInfo { pub p_dependencies: *const SubpassDependency, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct EventCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: EventCreateFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct FenceCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: FenceCreateFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceFeatures { pub robust_buffer_access: Bool32, pub full_draw_index_uint32: Bool32, @@ -5856,7 +5980,7 @@ pub struct PhysicalDeviceFeatures { pub inherited_queries: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSparseProperties { pub residency_standard2_d_block_shape: Bool32, pub residency_standard2_d_multisample_block_shape: Bool32, @@ -5974,15 +6098,310 @@ pub struct PhysicalDeviceLimits { pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, pub non_coherent_atom_size: DeviceSize, } +impl ::std::fmt::Debug for PhysicalDeviceLimits { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("PhysicalDeviceLimits") + .field("max_image_dimension1_d", &self.max_image_dimension1_d) + .field("max_image_dimension2_d", &self.max_image_dimension2_d) + .field("max_image_dimension3_d", &self.max_image_dimension3_d) + .field("max_image_dimension_cube", &self.max_image_dimension_cube) + .field("max_image_array_layers", &self.max_image_array_layers) + .field("max_texel_buffer_elements", &self.max_texel_buffer_elements) + .field("max_uniform_buffer_range", &self.max_uniform_buffer_range) + .field("max_storage_buffer_range", &self.max_storage_buffer_range) + .field("max_push_constants_size", &self.max_push_constants_size) + .field( + "max_memory_allocation_count", + &self.max_memory_allocation_count, + ) + .field( + "max_sampler_allocation_count", + &self.max_sampler_allocation_count, + ) + .field("buffer_image_granularity", &self.buffer_image_granularity) + .field("sparse_address_space_size", &self.sparse_address_space_size) + .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) + .field( + "max_per_stage_descriptor_samplers", + &self.max_per_stage_descriptor_samplers, + ) + .field( + "max_per_stage_descriptor_uniform_buffers", + &self.max_per_stage_descriptor_uniform_buffers, + ) + .field( + "max_per_stage_descriptor_storage_buffers", + &self.max_per_stage_descriptor_storage_buffers, + ) + .field( + "max_per_stage_descriptor_sampled_images", + &self.max_per_stage_descriptor_sampled_images, + ) + .field( + "max_per_stage_descriptor_storage_images", + &self.max_per_stage_descriptor_storage_images, + ) + .field( + "max_per_stage_descriptor_input_attachments", + &self.max_per_stage_descriptor_input_attachments, + ) + .field("max_per_stage_resources", &self.max_per_stage_resources) + .field( + "max_descriptor_set_samplers", + &self.max_descriptor_set_samplers, + ) + .field( + "max_descriptor_set_uniform_buffers", + &self.max_descriptor_set_uniform_buffers, + ) + .field( + "max_descriptor_set_uniform_buffers_dynamic", + &self.max_descriptor_set_uniform_buffers_dynamic, + ) + .field( + "max_descriptor_set_storage_buffers", + &self.max_descriptor_set_storage_buffers, + ) + .field( + "max_descriptor_set_storage_buffers_dynamic", + &self.max_descriptor_set_storage_buffers_dynamic, + ) + .field( + "max_descriptor_set_sampled_images", + &self.max_descriptor_set_sampled_images, + ) + .field( + "max_descriptor_set_storage_images", + &self.max_descriptor_set_storage_images, + ) + .field( + "max_descriptor_set_input_attachments", + &self.max_descriptor_set_input_attachments, + ) + .field( + "max_vertex_input_attributes", + &self.max_vertex_input_attributes, + ) + .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + .field( + "max_vertex_input_attribute_offset", + &self.max_vertex_input_attribute_offset, + ) + .field( + "max_vertex_input_binding_stride", + &self.max_vertex_input_binding_stride, + ) + .field( + "max_vertex_output_components", + &self.max_vertex_output_components, + ) + .field( + "max_tessellation_generation_level", + &self.max_tessellation_generation_level, + ) + .field( + "max_tessellation_patch_size", + &self.max_tessellation_patch_size, + ) + .field( + "max_tessellation_control_per_vertex_input_components", + &self.max_tessellation_control_per_vertex_input_components, + ) + .field( + "max_tessellation_control_per_vertex_output_components", + &self.max_tessellation_control_per_vertex_output_components, + ) + .field( + "max_tessellation_control_per_patch_output_components", + &self.max_tessellation_control_per_patch_output_components, + ) + .field( + "max_tessellation_control_total_output_components", + &self.max_tessellation_control_total_output_components, + ) + .field( + "max_tessellation_evaluation_input_components", + &self.max_tessellation_evaluation_input_components, + ) + .field( + "max_tessellation_evaluation_output_components", + &self.max_tessellation_evaluation_output_components, + ) + .field( + "max_geometry_shader_invocations", + &self.max_geometry_shader_invocations, + ) + .field( + "max_geometry_input_components", + &self.max_geometry_input_components, + ) + .field( + "max_geometry_output_components", + &self.max_geometry_output_components, + ) + .field( + "max_geometry_output_vertices", + &self.max_geometry_output_vertices, + ) + .field( + "max_geometry_total_output_components", + &self.max_geometry_total_output_components, + ) + .field( + "max_fragment_input_components", + &self.max_fragment_input_components, + ) + .field( + "max_fragment_output_attachments", + &self.max_fragment_output_attachments, + ) + .field( + "max_fragment_dual_src_attachments", + &self.max_fragment_dual_src_attachments, + ) + .field( + "max_fragment_combined_output_resources", + &self.max_fragment_combined_output_resources, + ) + .field( + "max_compute_shared_memory_size", + &self.max_compute_shared_memory_size, + ) + .field("max_compute_work_group_count", &unsafe { + ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) + }) + .field( + "max_compute_work_group_invocations", + &self.max_compute_work_group_invocations, + ) + .field("max_compute_work_group_size", &unsafe { + ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) + }) + .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) + .field("mipmap_precision_bits", &self.mipmap_precision_bits) + .field( + "max_draw_indexed_index_value", + &self.max_draw_indexed_index_value, + ) + .field("max_draw_indirect_count", &self.max_draw_indirect_count) + .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) + .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) + .field("max_viewports", &self.max_viewports) + .field("max_viewport_dimensions", &unsafe { + ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) + }) + .field("viewport_bounds_range", &unsafe { + ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) + }) + .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + .field("min_memory_map_alignment", &self.min_memory_map_alignment) + .field( + "min_texel_buffer_offset_alignment", + &self.min_texel_buffer_offset_alignment, + ) + .field( + "min_uniform_buffer_offset_alignment", + &self.min_uniform_buffer_offset_alignment, + ) + .field( + "min_storage_buffer_offset_alignment", + &self.min_storage_buffer_offset_alignment, + ) + .field("min_texel_offset", &self.min_texel_offset) + .field("max_texel_offset", &self.max_texel_offset) + .field("min_texel_gather_offset", &self.min_texel_gather_offset) + .field("max_texel_gather_offset", &self.max_texel_gather_offset) + .field("min_interpolation_offset", &self.min_interpolation_offset) + .field("max_interpolation_offset", &self.max_interpolation_offset) + .field( + "sub_pixel_interpolation_offset_bits", + &self.sub_pixel_interpolation_offset_bits, + ) + .field("max_framebuffer_width", &self.max_framebuffer_width) + .field("max_framebuffer_height", &self.max_framebuffer_height) + .field("max_framebuffer_layers", &self.max_framebuffer_layers) + .field( + "framebuffer_color_sample_counts", + &self.framebuffer_color_sample_counts, + ) + .field( + "framebuffer_depth_sample_counts", + &self.framebuffer_depth_sample_counts, + ) + .field( + "framebuffer_stencil_sample_counts", + &self.framebuffer_stencil_sample_counts, + ) + .field( + "framebuffer_no_attachments_sample_counts", + &self.framebuffer_no_attachments_sample_counts, + ) + .field("max_color_attachments", &self.max_color_attachments) + .field( + "sampled_image_color_sample_counts", + &self.sampled_image_color_sample_counts, + ) + .field( + "sampled_image_integer_sample_counts", + &self.sampled_image_integer_sample_counts, + ) + .field( + "sampled_image_depth_sample_counts", + &self.sampled_image_depth_sample_counts, + ) + .field( + "sampled_image_stencil_sample_counts", + &self.sampled_image_stencil_sample_counts, + ) + .field( + "storage_image_sample_counts", + &self.storage_image_sample_counts, + ) + .field("max_sample_mask_words", &self.max_sample_mask_words) + .field( + "timestamp_compute_and_graphics", + &self.timestamp_compute_and_graphics, + ) + .field("timestamp_period", &self.timestamp_period) + .field("max_clip_distances", &self.max_clip_distances) + .field("max_cull_distances", &self.max_cull_distances) + .field( + "max_combined_clip_and_cull_distances", + &self.max_combined_clip_and_cull_distances, + ) + .field("discrete_queue_priorities", &self.discrete_queue_priorities) + .field("point_size_range", &unsafe { + ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) + }) + .field("line_width_range", &unsafe { + ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) + }) + .field("point_size_granularity", &self.point_size_granularity) + .field("line_width_granularity", &self.line_width_granularity) + .field("strict_lines", &self.strict_lines) + .field("standard_sample_locations", &self.standard_sample_locations) + .field( + "optimal_buffer_copy_offset_alignment", + &self.optimal_buffer_copy_offset_alignment, + ) + .field( + "optimal_buffer_copy_row_pitch_alignment", + &self.optimal_buffer_copy_row_pitch_alignment, + ) + .field("non_coherent_atom_size", &self.non_coherent_atom_size) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SemaphoreCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: SemaphoreCreateFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct QueryPoolCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -5992,7 +6411,7 @@ pub struct QueryPoolCreateInfo { pub pipeline_statistics: QueryPipelineStatisticFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct FramebufferCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -6005,7 +6424,7 @@ pub struct FramebufferCreateInfo { pub layers: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DrawIndirectCommand { pub vertex_count: uint32_t, pub instance_count: uint32_t, @@ -6013,7 +6432,7 @@ pub struct DrawIndirectCommand { pub first_instance: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DrawIndexedIndirectCommand { pub index_count: uint32_t, pub instance_count: uint32_t, @@ -6022,14 +6441,14 @@ pub struct DrawIndexedIndirectCommand { pub first_instance: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DispatchIndirectCommand { pub x: uint32_t, pub y: uint32_t, pub z: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SubmitInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -6042,7 +6461,7 @@ pub struct SubmitInfo { pub p_signal_semaphores: *const Semaphore, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPropertiesKHR { pub display: DisplayKHR, pub display_name: *const c_char, @@ -6053,25 +6472,25 @@ pub struct DisplayPropertiesKHR { pub persistent_content: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPlanePropertiesKHR { pub current_display: DisplayKHR, pub current_stack_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayModeParametersKHR { pub visible_region: Extent2D, pub refresh_rate: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayModePropertiesKHR { pub display_mode: DisplayModeKHR, pub parameters: DisplayModeParametersKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayModeCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6079,7 +6498,7 @@ pub struct DisplayModeCreateInfoKHR { pub parameters: DisplayModeParametersKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPlaneCapabilitiesKHR { pub supported_alpha: DisplayPlaneAlphaFlagsKHR, pub min_src_position: Offset2D, @@ -6092,7 +6511,7 @@ pub struct DisplayPlaneCapabilitiesKHR { pub max_dst_extent: Extent2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplaySurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6106,7 +6525,7 @@ pub struct DisplaySurfaceCreateInfoKHR { pub image_extent: Extent2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPresentInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6115,7 +6534,7 @@ pub struct DisplayPresentInfoKHR { pub persistent: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilitiesKHR { pub min_image_count: uint32_t, pub max_image_count: uint32_t, @@ -6129,7 +6548,7 @@ pub struct SurfaceCapabilitiesKHR { pub supported_usage_flags: ImageUsageFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AndroidSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6137,7 +6556,7 @@ pub struct AndroidSurfaceCreateInfoKHR { pub window: *const ANativeWindow, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MirSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6146,7 +6565,7 @@ pub struct MirSurfaceCreateInfoKHR { pub mir_surface: *const MirSurface, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ViSurfaceCreateInfoNN { pub s_type: StructureType, pub p_next: *const c_void, @@ -6154,7 +6573,7 @@ pub struct ViSurfaceCreateInfoNN { pub window: *const c_void, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct WaylandSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6163,7 +6582,7 @@ pub struct WaylandSurfaceCreateInfoKHR { pub surface: *const wl_surface, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Win32SurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6172,7 +6591,7 @@ pub struct Win32SurfaceCreateInfoKHR { pub hwnd: HWND, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct XlibSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6181,7 +6600,7 @@ pub struct XlibSurfaceCreateInfoKHR { pub window: Window, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct XcbSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6190,13 +6609,13 @@ pub struct XcbSurfaceCreateInfoKHR { pub window: xcb_window_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SurfaceFormatKHR { pub format: Format, pub color_space: ColorSpaceKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SwapchainCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6218,7 +6637,7 @@ pub struct SwapchainCreateInfoKHR { pub old_swapchain: SwapchainKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PresentInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6238,8 +6657,19 @@ pub struct DebugReportCallbackCreateInfoEXT { pub pfn_callback: PFN_vkDebugReportCallbackEXT, pub p_user_data: *const c_void, } +impl ::std::fmt::Debug for DebugReportCallbackCreateInfoEXT { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("DebugReportCallbackCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("pfn_callback", &(self.pfn_callback as *const ())) + .field("p_user_data", &self.p_user_data) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ValidationFlagsEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -6247,14 +6677,14 @@ pub struct ValidationFlagsEXT { pub p_disabled_validation_checks: *const ValidationCheckEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationStateRasterizationOrderAMD { pub s_type: StructureType, pub p_next: *const c_void, pub rasterization_order: RasterizationOrderAMD, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DebugMarkerObjectNameInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -6263,7 +6693,7 @@ pub struct DebugMarkerObjectNameInfoEXT { pub p_object_name: *const c_char, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DebugMarkerObjectTagInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -6281,22 +6711,34 @@ pub struct DebugMarkerMarkerInfoEXT { pub p_marker_name: *const c_char, pub color: [c_float; 4], } +impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("DebugMarkerMarkerInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("p_marker_name", &self.p_marker_name) + .field("color", &unsafe { + ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) + }) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationImageCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, pub dedicated_allocation: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationBufferCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, pub dedicated_allocation: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationMemoryAllocateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -6304,7 +6746,7 @@ pub struct DedicatedAllocationMemoryAllocateInfoNV { pub buffer: Buffer, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalImageFormatPropertiesNV { pub image_format_properties: ImageFormatProperties, pub external_memory_features: ExternalMemoryFeatureFlagsNV, @@ -6312,21 +6754,21 @@ pub struct ExternalImageFormatPropertiesNV { pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalMemoryImageCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlagsNV, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportMemoryAllocateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlagsNV, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportMemoryWin32HandleInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -6334,7 +6776,7 @@ pub struct ImportMemoryWin32HandleInfoNV { pub handle: HANDLE, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportMemoryWin32HandleInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -6342,7 +6784,7 @@ pub struct ExportMemoryWin32HandleInfoNV { pub dw_access: DWORD, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Win32KeyedMutexAcquireReleaseInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -6355,14 +6797,14 @@ pub struct Win32KeyedMutexAcquireReleaseInfoNV { pub p_release_keys: *const uint64_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGeneratedCommandsFeaturesNVX { pub s_type: StructureType, pub p_next: *const c_void, pub compute_binding_point_support: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGeneratedCommandsLimitsNVX { pub s_type: StructureType, pub p_next: *const c_void, @@ -6373,14 +6815,14 @@ pub struct DeviceGeneratedCommandsLimitsNVX { pub min_commands_token_buffer_offset_alignment: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct IndirectCommandsTokenNVX { pub token_type: IndirectCommandsTokenTypeNVX, pub buffer: Buffer, pub offset: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct IndirectCommandsLayoutTokenNVX { pub token_type: IndirectCommandsTokenTypeNVX, pub binding_unit: uint32_t, @@ -6388,7 +6830,7 @@ pub struct IndirectCommandsLayoutTokenNVX { pub divisor: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct IndirectCommandsLayoutCreateInfoNVX { pub s_type: StructureType, pub p_next: *const c_void, @@ -6398,7 +6840,7 @@ pub struct IndirectCommandsLayoutCreateInfoNVX { pub p_tokens: *const IndirectCommandsLayoutTokenNVX, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct CmdProcessCommandsInfoNVX { pub s_type: StructureType, pub p_next: *const c_void, @@ -6414,7 +6856,7 @@ pub struct CmdProcessCommandsInfoNVX { pub sequences_index_offset: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct CmdReserveSpaceForCommandsInfoNVX { pub s_type: StructureType, pub p_next: *const c_void, @@ -6423,7 +6865,7 @@ pub struct CmdReserveSpaceForCommandsInfoNVX { pub max_sequences_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ObjectTableCreateInfoNVX { pub s_type: StructureType, pub p_next: *const c_void, @@ -6438,20 +6880,20 @@ pub struct ObjectTableCreateInfoNVX { pub max_pipeline_layouts: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ObjectTableEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ObjectTablePipelineEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, pub pipeline: Pipeline, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ObjectTableDescriptorSetEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, @@ -6459,14 +6901,14 @@ pub struct ObjectTableDescriptorSetEntryNVX { pub descriptor_set: DescriptorSet, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ObjectTableVertexBufferEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, pub buffer: Buffer, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ObjectTableIndexBufferEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, @@ -6474,7 +6916,7 @@ pub struct ObjectTableIndexBufferEntryNVX { pub index_type: IndexType, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ObjectTablePushConstantEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, @@ -6482,47 +6924,47 @@ pub struct ObjectTablePushConstantEntryNVX { pub stage_flags: ShaderStageFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceFeatures2 { pub s_type: StructureType, pub p_next: *const c_void, pub features: PhysicalDeviceFeatures, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceFeatures2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProperties2 { pub s_type: StructureType, pub p_next: *const c_void, pub properties: PhysicalDeviceProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProperties2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct FormatProperties2 { pub s_type: StructureType, pub p_next: *const c_void, pub format_properties: FormatProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct FormatProperties2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageFormatProperties2 { pub s_type: StructureType, pub p_next: *const c_void, pub image_format_properties: ImageFormatProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageFormatProperties2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceImageFormatInfo2 { pub s_type: StructureType, pub p_next: *const c_void, @@ -6533,40 +6975,40 @@ pub struct PhysicalDeviceImageFormatInfo2 { pub flags: ImageCreateFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceImageFormatInfo2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct QueueFamilyProperties2 { pub s_type: StructureType, pub p_next: *const c_void, pub queue_family_properties: QueueFamilyProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct QueueFamilyProperties2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMemoryProperties2 { pub s_type: StructureType, pub p_next: *const c_void, pub memory_properties: PhysicalDeviceMemoryProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMemoryProperties2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageFormatProperties2 { pub s_type: StructureType, pub p_next: *const c_void, pub properties: SparseImageFormatProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageFormatProperties2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSparseImageFormatInfo2 { pub s_type: StructureType, pub p_next: *const c_void, @@ -6577,17 +7019,17 @@ pub struct PhysicalDeviceSparseImageFormatInfo2 { pub tiling: ImageTiling, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSparseImageFormatInfo2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePushDescriptorPropertiesKHR { pub s_type: StructureType, pub p_next: *const c_void, pub max_push_descriptors: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PresentRegionsKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6595,20 +7037,20 @@ pub struct PresentRegionsKHR { pub p_regions: *const PresentRegionKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PresentRegionKHR { pub rectangle_count: uint32_t, pub p_rectangles: *const RectLayerKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RectLayerKHR { pub offset: Offset2D, pub extent: Extent2D, pub layer: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVariablePointerFeatures { pub s_type: StructureType, pub p_next: *const c_void, @@ -6616,40 +7058,40 @@ pub struct PhysicalDeviceVariablePointerFeatures { pub variable_pointers: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVariablePointerFeaturesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalMemoryProperties { pub external_memory_features: ExternalMemoryFeatureFlags, pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, pub compatible_handle_types: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalMemoryPropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalImageFormatInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalImageFormatInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalImageFormatProperties { pub s_type: StructureType, pub p_next: *const c_void, pub external_memory_properties: ExternalMemoryProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalImageFormatPropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalBufferInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -6658,17 +7100,17 @@ pub struct PhysicalDeviceExternalBufferInfo { pub handle_type: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalBufferInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalBufferProperties { pub s_type: StructureType, pub p_next: *const c_void, pub external_memory_properties: ExternalMemoryProperties, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalBufferPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone)] @@ -6681,41 +7123,60 @@ pub struct PhysicalDeviceIDProperties { pub device_node_mask: uint32_t, pub device_luid_valid: Bool32, } +impl ::std::fmt::Debug for PhysicalDeviceIDProperties { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("PhysicalDeviceIDProperties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("device_uuid", &unsafe { + ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) + }) + .field("driver_uuid", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) + }) + .field("device_luid", &unsafe { + ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) + }) + .field("device_node_mask", &self.device_node_mask) + .field("device_luid_valid", &self.device_luid_valid) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceIDPropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalMemoryImageCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalMemoryImageCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalMemoryBufferCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalMemoryBufferCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportMemoryAllocateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportMemoryAllocateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportMemoryWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6724,7 +7185,7 @@ pub struct ImportMemoryWin32HandleInfoKHR { pub name: LPCWSTR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportMemoryWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6733,14 +7194,14 @@ pub struct ExportMemoryWin32HandleInfoKHR { pub name: LPCWSTR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryWin32HandlePropertiesKHR { pub s_type: StructureType, pub p_next: *const c_void, pub memory_type_bits: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryGetWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6748,7 +7209,7 @@ pub struct MemoryGetWin32HandleInfoKHR { pub handle_type: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportMemoryFdInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6756,14 +7217,14 @@ pub struct ImportMemoryFdInfoKHR { pub fd: c_int, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryFdPropertiesKHR { pub s_type: StructureType, pub p_next: *const c_void, pub memory_type_bits: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryGetFdInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6771,7 +7232,7 @@ pub struct MemoryGetFdInfoKHR { pub handle_type: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Win32KeyedMutexAcquireReleaseInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6784,17 +7245,17 @@ pub struct Win32KeyedMutexAcquireReleaseInfoKHR { pub p_release_keys: *const uint64_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalSemaphoreInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalSemaphoreHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalSemaphoreInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalSemaphoreProperties { pub s_type: StructureType, pub p_next: *const c_void, @@ -6803,20 +7264,20 @@ pub struct ExternalSemaphoreProperties { pub external_semaphore_features: ExternalSemaphoreFeatureFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalSemaphorePropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportSemaphoreCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalSemaphoreHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportSemaphoreCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportSemaphoreWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6827,7 +7288,7 @@ pub struct ImportSemaphoreWin32HandleInfoKHR { pub name: LPCWSTR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportSemaphoreWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6836,7 +7297,7 @@ pub struct ExportSemaphoreWin32HandleInfoKHR { pub name: LPCWSTR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct D3D12FenceSubmitInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6846,7 +7307,7 @@ pub struct D3D12FenceSubmitInfoKHR { pub p_signal_semaphore_values: *const uint64_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SemaphoreGetWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6854,7 +7315,7 @@ pub struct SemaphoreGetWin32HandleInfoKHR { pub handle_type: ExternalSemaphoreHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportSemaphoreFdInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6864,7 +7325,7 @@ pub struct ImportSemaphoreFdInfoKHR { pub fd: c_int, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SemaphoreGetFdInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6872,17 +7333,17 @@ pub struct SemaphoreGetFdInfoKHR { pub handle_type: ExternalSemaphoreHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalFenceInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalFenceHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalFenceInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalFenceProperties { pub s_type: StructureType, pub p_next: *const c_void, @@ -6891,20 +7352,20 @@ pub struct ExternalFenceProperties { pub external_fence_features: ExternalFenceFeatureFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalFencePropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportFenceCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalFenceHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportFenceCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportFenceWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6915,7 +7376,7 @@ pub struct ImportFenceWin32HandleInfoKHR { pub name: LPCWSTR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExportFenceWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6924,7 +7385,7 @@ pub struct ExportFenceWin32HandleInfoKHR { pub name: LPCWSTR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct FenceGetWin32HandleInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6932,7 +7393,7 @@ pub struct FenceGetWin32HandleInfoKHR { pub handle_type: ExternalFenceHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportFenceFdInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6942,7 +7403,7 @@ pub struct ImportFenceFdInfoKHR { pub fd: c_int, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct FenceGetFdInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -6950,7 +7411,7 @@ pub struct FenceGetFdInfoKHR { pub handle_type: ExternalFenceHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewFeatures { pub s_type: StructureType, pub p_next: *const c_void, @@ -6959,10 +7420,10 @@ pub struct PhysicalDeviceMultiviewFeatures { pub multiview_tessellation_shader: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewFeaturesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewProperties { pub s_type: StructureType, pub p_next: *const c_void, @@ -6970,10 +7431,10 @@ pub struct PhysicalDeviceMultiviewProperties { pub max_multiview_instance_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewPropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RenderPassMultiviewCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -6985,10 +7446,10 @@ pub struct RenderPassMultiviewCreateInfo { pub p_correlation_masks: *const uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RenderPassMultiviewCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2EXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7005,28 +7466,28 @@ pub struct SurfaceCapabilities2EXT { pub supported_surface_counters: SurfaceCounterFlagsEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPowerInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub power_state: DisplayPowerStateEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceEventInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub device_event: DeviceEventTypeEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayEventInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub display_event: DisplayEventTypeEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SwapchainCounterCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7041,11 +7502,24 @@ pub struct PhysicalDeviceGroupProperties { pub physical_devices: [PhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, } +impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("PhysicalDeviceGroupProperties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("physical_device_count", &self.physical_device_count) + .field("physical_devices", &unsafe { + ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) + }) + .field("subset_allocation", &self.subset_allocation) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceGroupPropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryAllocateFlagsInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7053,10 +7527,10 @@ pub struct MemoryAllocateFlagsInfo { pub device_mask: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryAllocateFlagsInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7065,10 +7539,10 @@ pub struct BindBufferMemoryInfo { pub memory_offset: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryDeviceGroupInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7076,10 +7550,10 @@ pub struct BindBufferMemoryDeviceGroupInfo { pub p_device_indices: *const uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryDeviceGroupInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindImageMemoryInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7088,10 +7562,10 @@ pub struct BindImageMemoryInfo { pub memory_offset: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindImageMemoryInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindImageMemoryDeviceGroupInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7101,10 +7575,10 @@ pub struct BindImageMemoryDeviceGroupInfo { pub p_split_instance_bind_regions: *const Rect2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindImageMemoryDeviceGroupInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupRenderPassBeginInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7113,20 +7587,20 @@ pub struct DeviceGroupRenderPassBeginInfo { pub p_device_render_areas: *const Rect2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupRenderPassBeginInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupCommandBufferBeginInfo { pub s_type: StructureType, pub p_next: *const c_void, pub device_mask: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupCommandBufferBeginInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupSubmitInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7138,10 +7612,10 @@ pub struct DeviceGroupSubmitInfo { pub p_signal_semaphore_device_indices: *const uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupSubmitInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupBindSparseInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7149,7 +7623,7 @@ pub struct DeviceGroupBindSparseInfo { pub memory_device_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupBindSparseInfoKHR {} #[repr(C)] #[derive(Copy, Clone)] @@ -7159,15 +7633,27 @@ pub struct DeviceGroupPresentCapabilitiesKHR { pub present_mask: [uint32_t; VK_MAX_DEVICE_GROUP_SIZE], pub modes: DeviceGroupPresentModeFlagsKHR, } +impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("DeviceGroupPresentCapabilitiesKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("present_mask", &unsafe { + ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) + }) + .field("modes", &self.modes) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageSwapchainCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain: SwapchainKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindImageMemorySwapchainInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -7175,7 +7661,7 @@ pub struct BindImageMemorySwapchainInfoKHR { pub image_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AcquireNextImageInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -7186,7 +7672,7 @@ pub struct AcquireNextImageInfoKHR { pub device_mask: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupPresentInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -7195,7 +7681,7 @@ pub struct DeviceGroupPresentInfoKHR { pub mode: DeviceGroupPresentModeFlagsKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupDeviceCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7203,17 +7689,17 @@ pub struct DeviceGroupDeviceCreateInfo { pub p_physical_devices: *const PhysicalDevice, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupDeviceCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupSwapchainCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub modes: DeviceGroupPresentModeFlagsKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorUpdateTemplateEntry { pub dst_binding: uint32_t, pub dst_array_element: uint32_t, @@ -7223,10 +7709,10 @@ pub struct DescriptorUpdateTemplateEntry { pub stride: size_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorUpdateTemplateEntryKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorUpdateTemplateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7240,16 +7726,16 @@ pub struct DescriptorUpdateTemplateCreateInfo { pub set: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorUpdateTemplateCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct XYColorEXT { pub x: c_float, pub y: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct HdrMetadataEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7263,12 +7749,12 @@ pub struct HdrMetadataEXT { pub max_frame_average_light_level: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RefreshCycleDurationGOOGLE { pub refresh_duration: uint64_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PastPresentationTimingGOOGLE { pub present_id: uint32_t, pub desired_present_time: uint64_t, @@ -7277,7 +7763,7 @@ pub struct PastPresentationTimingGOOGLE { pub present_margin: uint64_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PresentTimesInfoGOOGLE { pub s_type: StructureType, pub p_next: *const c_void, @@ -7285,13 +7771,13 @@ pub struct PresentTimesInfoGOOGLE { pub p_times: *const PresentTimeGOOGLE, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PresentTimeGOOGLE { pub present_id: uint32_t, pub desired_present_time: uint64_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct IOSSurfaceCreateInfoMVK { pub s_type: StructureType, pub p_next: *const c_void, @@ -7299,7 +7785,7 @@ pub struct IOSSurfaceCreateInfoMVK { pub p_view: *const c_void, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MacOSSurfaceCreateInfoMVK { pub s_type: StructureType, pub p_next: *const c_void, @@ -7307,13 +7793,13 @@ pub struct MacOSSurfaceCreateInfoMVK { pub p_view: *const c_void, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ViewportWScalingNV { pub xcoeff: c_float, pub ycoeff: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineViewportWScalingStateCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -7322,7 +7808,7 @@ pub struct PipelineViewportWScalingStateCreateInfoNV { pub p_viewport_w_scalings: *const ViewportWScalingNV, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ViewportSwizzleNV { pub x: ViewportCoordinateSwizzleNV, pub y: ViewportCoordinateSwizzleNV, @@ -7330,7 +7816,7 @@ pub struct ViewportSwizzleNV { pub w: ViewportCoordinateSwizzleNV, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineViewportSwizzleStateCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -7339,14 +7825,14 @@ pub struct PipelineViewportSwizzleStateCreateInfoNV { pub p_viewport_swizzles: *const ViewportSwizzleNV, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, pub max_discard_rectangles: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineDiscardRectangleStateCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7356,24 +7842,24 @@ pub struct PipelineDiscardRectangleStateCreateInfoEXT { pub p_discard_rectangles: *const Rect2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { pub s_type: StructureType, pub p_next: *const c_void, pub per_view_position_all_components: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct InputAttachmentAspectReference { pub subpass: uint32_t, pub input_attachment_index: uint32_t, pub aspect_mask: ImageAspectFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct InputAttachmentAspectReferenceKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RenderPassInputAttachmentAspectCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7381,52 +7867,52 @@ pub struct RenderPassInputAttachmentAspectCreateInfo { pub p_aspect_references: *const InputAttachmentAspectReference, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RenderPassInputAttachmentAspectCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSurfaceInfo2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub surface: SurfaceKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub surface_capabilities: SurfaceCapabilitiesKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SurfaceFormat2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub surface_format: SurfaceFormatKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayProperties2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub display_properties: DisplayPropertiesKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPlaneProperties2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub display_plane_properties: DisplayPlanePropertiesKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayModeProperties2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub display_mode_properties: DisplayModePropertiesKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPlaneInfo2KHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -7434,21 +7920,21 @@ pub struct DisplayPlaneInfo2KHR { pub plane_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DisplayPlaneCapabilities2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub capabilities: DisplayPlaneCapabilitiesKHR, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SharedPresentSurfaceCapabilitiesKHR { pub s_type: StructureType, pub p_next: *const c_void, pub shared_present_supported_usage_flags: ImageUsageFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDevice16BitStorageFeatures { pub s_type: StructureType, pub p_next: *const c_void, @@ -7458,10 +7944,10 @@ pub struct PhysicalDevice16BitStorageFeatures { pub storage_input_output16: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDevice16BitStorageFeaturesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSubgroupProperties { pub s_type: StructureType, pub p_next: *const c_void, @@ -7471,67 +7957,67 @@ pub struct PhysicalDeviceSubgroupProperties { pub quad_operations_in_all_stages: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BufferMemoryRequirementsInfo2 { pub s_type: StructureType, pub p_next: *const c_void, pub buffer: Buffer, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BufferMemoryRequirementsInfo2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageMemoryRequirementsInfo2 { pub s_type: StructureType, pub p_next: *const c_void, pub image: Image, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageMemoryRequirementsInfo2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageSparseMemoryRequirementsInfo2 { pub s_type: StructureType, pub p_next: *const c_void, pub image: Image, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageSparseMemoryRequirementsInfo2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryRequirements2 { pub s_type: StructureType, pub p_next: *const c_void, pub memory_requirements: MemoryRequirements, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryRequirements2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryRequirements2 { pub s_type: StructureType, pub p_next: *const c_void, pub memory_requirements: SparseImageMemoryRequirements, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryRequirements2KHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePointClippingProperties { pub s_type: StructureType, pub p_next: *const c_void, pub point_clipping_behavior: PointClippingBehavior, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePointClippingPropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedRequirements { pub s_type: StructureType, pub p_next: *const c_void, @@ -7539,10 +8025,10 @@ pub struct MemoryDedicatedRequirements { pub requires_dedicated_allocation: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedRequirementsKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedAllocateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7550,40 +8036,40 @@ pub struct MemoryDedicatedAllocateInfo { pub buffer: Buffer, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedAllocateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageViewUsageCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub usage: ImageUsageFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageViewUsageCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineTessellationDomainOriginStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub domain_origin: TessellationDomainOrigin, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineTessellationDomainOriginStateCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionInfo { pub s_type: StructureType, pub p_next: *const c_void, pub conversion: SamplerYcbcrConversion, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -7597,78 +8083,78 @@ pub struct SamplerYcbcrConversionCreateInfo { pub force_explicit_reconstruction: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindImagePlaneMemoryInfo { pub s_type: StructureType, pub p_next: *const c_void, pub plane_aspect: ImageAspectFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct BindImagePlaneMemoryInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImagePlaneMemoryRequirementsInfo { pub s_type: StructureType, pub p_next: *const c_void, pub plane_aspect: ImageAspectFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImagePlaneMemoryRequirementsInfoKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { pub s_type: StructureType, pub p_next: *const c_void, pub sampler_ycbcr_conversion: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionImageFormatProperties { pub s_type: StructureType, pub p_next: *const c_void, pub combined_image_sampler_descriptor_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionImageFormatPropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct TextureLODGatherFormatPropertiesAMD { pub s_type: StructureType, pub p_next: *const c_void, pub supports_texture_gather_lod_bias_amd: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ProtectedSubmitInfo { pub s_type: StructureType, pub p_next: *const c_void, pub protected_submit: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryFeatures { pub s_type: StructureType, pub p_next: *const c_void, pub protected_memory: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryProperties { pub s_type: StructureType, pub p_next: *const c_void, pub protected_no_fault: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceQueueInfo2 { pub s_type: StructureType, pub p_next: *const c_void, @@ -7677,7 +8163,7 @@ pub struct DeviceQueueInfo2 { pub queue_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineCoverageToColorStateCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -7686,7 +8172,7 @@ pub struct PipelineCoverageToColorStateCreateInfoNV { pub coverage_to_color_location: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7694,13 +8180,13 @@ pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { pub filter_minmax_image_component_mapping: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SampleLocationEXT { pub x: c_float, pub y: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SampleLocationsInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7710,19 +8196,19 @@ pub struct SampleLocationsInfoEXT { pub p_sample_locations: *const SampleLocationEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AttachmentSampleLocationsEXT { pub attachment_index: uint32_t, pub sample_locations_info: SampleLocationsInfoEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SubpassSampleLocationsEXT { pub subpass_index: uint32_t, pub sample_locations_info: SampleLocationsInfoEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct RenderPassSampleLocationsBeginInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7732,7 +8218,7 @@ pub struct RenderPassSampleLocationsBeginInfoEXT { pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineSampleLocationsStateCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7750,29 +8236,55 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub sample_location_sub_pixel_bits: uint32_t, pub variable_sample_locations: Bool32, } +impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("PhysicalDeviceSampleLocationsPropertiesEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field( + "sample_location_sample_counts", + &self.sample_location_sample_counts, + ) + .field( + "max_sample_location_grid_size", + &self.max_sample_location_grid_size, + ) + .field("sample_location_coordinate_range", &unsafe { + ::std::ffi::CStr::from_ptr( + self.sample_location_coordinate_range.as_ptr() as *const i8 + ) + }) + .field( + "sample_location_sub_pixel_bits", + &self.sample_location_sub_pixel_bits, + ) + .field("variable_sample_locations", &self.variable_sample_locations) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MultisamplePropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, pub max_sample_location_grid_size: Extent2D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct SamplerReductionModeCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub reduction_mode: SamplerReductionModeEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { pub s_type: StructureType, pub p_next: *const c_void, pub advanced_blend_coherent_operations: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7784,7 +8296,7 @@ pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { pub advanced_blend_all_operations: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7793,7 +8305,7 @@ pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { pub blend_overlap: BlendOverlapEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineCoverageModulationStateCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, @@ -7804,7 +8316,7 @@ pub struct PipelineCoverageModulationStateCreateInfoNV { pub p_coverage_modulation_table: *const c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageFormatListCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, @@ -7812,7 +8324,7 @@ pub struct ImageFormatListCreateInfoKHR { pub p_view_formats: *const Format, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ValidationCacheCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7821,14 +8333,14 @@ pub struct ValidationCacheCreateInfoEXT { pub p_initial_data: *const c_void, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ShaderModuleValidationCacheCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub validation_cache: ValidationCacheEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMaintenance3Properties { pub s_type: StructureType, pub p_next: *const c_void, @@ -7836,27 +8348,27 @@ pub struct PhysicalDeviceMaintenance3Properties { pub max_memory_allocation_size: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMaintenance3PropertiesKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutSupport { pub s_type: StructureType, pub p_next: *const c_void, pub supported: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutSupportKHR {} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderDrawParameterFeatures { pub s_type: StructureType, pub p_next: *const c_void, pub shader_draw_parameters: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct NativeBufferANDROID { pub s_type: StructureType, pub p_next: *const c_void, @@ -7866,7 +8378,7 @@ pub struct NativeBufferANDROID { pub usage: c_int, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ShaderResourceUsageAMD { pub num_used_vgprs: uint32_t, pub num_used_sgprs: uint32_t, @@ -7885,15 +8397,30 @@ pub struct ShaderStatisticsInfoAMD { pub num_available_sgprs: uint32_t, pub compute_work_group_size: [uint32_t; 3], } +impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("ShaderStatisticsInfoAMD") + .field("shader_stage_mask", &self.shader_stage_mask) + .field("resource_usage", &self.resource_usage) + .field("num_physical_vgprs", &self.num_physical_vgprs) + .field("num_physical_sgprs", &self.num_physical_sgprs) + .field("num_available_vgprs", &self.num_available_vgprs) + .field("num_available_sgprs", &self.num_available_sgprs) + .field("compute_work_group_size", &unsafe { + ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) + }) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceQueueGlobalPriorityCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub global_priority: QueueGlobalPriorityEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DebugUtilsObjectNameInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7902,7 +8429,7 @@ pub struct DebugUtilsObjectNameInfoEXT { pub p_object_name: *const c_char, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DebugUtilsObjectTagInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7920,6 +8447,18 @@ pub struct DebugUtilsLabelEXT { pub p_label_name: *const c_char, pub color: [c_float; 4], } +impl ::std::fmt::Debug for DebugUtilsLabelEXT { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("DebugUtilsLabelEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("p_label_name", &self.p_label_name) + .field("color", &unsafe { + ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) + }) + .finish() + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct DebugUtilsMessengerCreateInfoEXT { @@ -7931,8 +8470,21 @@ pub struct DebugUtilsMessengerCreateInfoEXT { pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, pub p_user_data: *const c_void, } +impl ::std::fmt::Debug for DebugUtilsMessengerCreateInfoEXT { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("message_severity", &self.message_severity) + .field("message_type", &self.message_type) + .field("pfn_user_callback", &(self.pfn_user_callback as *const ())) + .field("p_user_data", &self.p_user_data) + .finish() + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DebugUtilsMessengerCallbackDataEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7948,7 +8500,7 @@ pub struct DebugUtilsMessengerCallbackDataEXT { pub p_objects: *const DebugUtilsObjectNameInfoEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportMemoryHostPointerInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7956,21 +8508,21 @@ pub struct ImportMemoryHostPointerInfoEXT { pub p_host_pointer: *const c_void, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryHostPointerPropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, pub memory_type_bits: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, pub min_imported_host_pointer_alignment: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -7985,7 +8537,7 @@ pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { pub conservative_rasterization_post_depth_coverage: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderCorePropertiesAMD { pub s_type: StructureType, pub p_next: *const c_void, @@ -8005,7 +8557,7 @@ pub struct PhysicalDeviceShaderCorePropertiesAMD { pub vgpr_allocation_granularity: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationConservativeStateCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -8014,7 +8566,7 @@ pub struct PipelineRasterizationConservativeStateCreateInfoEXT { pub extra_primitive_overestimation_size: c_float, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingFeaturesEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -8040,7 +8592,7 @@ pub struct PhysicalDeviceDescriptorIndexingFeaturesEXT { pub runtime_descriptor_array: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -8069,7 +8621,7 @@ pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { pub max_descriptor_set_update_after_bind_input_attachments: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -8077,7 +8629,7 @@ pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { pub p_binding_flags: *const DescriptorBindingFlagsEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -8085,20 +8637,20 @@ pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { pub p_descriptor_counts: *const uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { pub s_type: StructureType, pub p_next: *const c_void, pub max_variable_descriptor_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct VertexInputBindingDivisorDescriptionEXT { pub binding: uint32_t, pub divisor: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineVertexInputDivisorStateCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -8106,28 +8658,28 @@ pub struct PipelineVertexInputDivisorStateCreateInfoEXT { pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { pub s_type: StructureType, pub p_next: *const c_void, pub max_vertex_attrib_divisor: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImportAndroidHardwareBufferInfoANDROID { pub s_type: StructureType, pub p_next: *const c_void, pub buffer: *const AHardwareBuffer, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferUsageANDROID { pub s_type: StructureType, pub p_next: *const c_void, pub android_hardware_buffer_usage: uint64_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferPropertiesANDROID { pub s_type: StructureType, pub p_next: *const c_void, @@ -8135,14 +8687,14 @@ pub struct AndroidHardwareBufferPropertiesANDROID { pub memory_type_bits: uint32_t, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct MemoryGetAndroidHardwareBufferInfoANDROID { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferFormatPropertiesANDROID { pub s_type: StructureType, pub p_next: *const c_void, @@ -8156,7 +8708,7 @@ pub struct AndroidHardwareBufferFormatPropertiesANDROID { pub suggested_y_chroma_offset: ChromaLocation, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ExternalFormatANDROID { pub s_type: StructureType, pub p_next: *const c_void, diff --git a/generator/src/lib.rs b/generator/src/lib.rs index ccf7947..ae7e00b 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -826,9 +826,7 @@ pub fn generate_extension_commands( .filter_map(|ext_item| match ext_item { vk_parse::ExtensionItem::Require { items, .. } => { Some(items.iter().filter_map(|item| match item { - vk_parse::InterfaceItem::Command { name, .. } => { - cmd_map.get(name).map(|c| *c) - } + vk_parse::InterfaceItem::Command { name, .. } => cmd_map.get(name).map(|c| *c), _ => None, })) } @@ -1041,9 +1039,75 @@ pub fn generate_result(ident: Ident, _enum: &vkxml::Enumeration) -> Tokens { } } } -pub trait StructExt {} -pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { - let name = to_type_tokens(&_struct.name, None); + +fn is_static_array(field: &vkxml::Field) -> bool { + field + .array + .as_ref() + .map(|ty| match ty { + vkxml::ArrayType::Static => true, + _ => false, + }) + .unwrap_or(false) +} +pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Option { + let name = name_to_tokens(&_struct.name); + let members = _struct.elements.iter().filter_map(|elem| match *elem { + vkxml::StructElement::Member(ref field) => Some(field), + _ => None, + }); + let contains_pfn = members.clone().any(|field| { + field + .name + .as_ref() + .map(|n| n.contains("pfn")) + .unwrap_or(false) + }); + let contains_static_array = members.clone().any(is_static_array); + let contains_union = members + .clone() + .any(|field| union_types.contains(field.basetype.as_str())); + if !(contains_union || contains_static_array || contains_pfn) { + return None; + } + let debug_fields = members.clone().map(|field| { + let param_ident = field.param_ident(); + let param_str = param_ident.as_ref(); + let debug_value = if is_static_array(field) { + quote!{ + &unsafe { + ::std::ffi::CStr::from_ptr(self.#param_ident.as_ptr() as *const i8) + } + } + } else if param_ident.as_ref().contains("pfn") { + quote!{ + &(self.#param_ident as *const()) + } + } else if union_types.contains(field.basetype.as_str()) { + quote!(&"union") + } else { + quote!{ + &self.#param_ident + } + }; + quote!{ + .field(#param_str, #debug_value) + } + }); + let name_str = name.as_ref(); + let q = quote!{ + impl ::std::fmt::Debug for #name { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + fmt.debug_struct(#name_str) + #(#debug_fields)* + .finish() + } + } + }; + Some(q) +} +pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Tokens { + let name = name_to_tokens(&_struct.name); let members = _struct.elements.iter().filter_map(|elem| match *elem { vkxml::StructElement::Member(ref field) => Some(field), _ => None, @@ -1055,30 +1119,15 @@ pub fn generate_struct(_struct: &vkxml::Struct) -> Tokens { quote!{pub #param_ident: #param_ty_tokens} }); - let contains_pfn = members.clone().any(|field| { - field - .name - .as_ref() - .map(|n| n.contains("pfn")) - .unwrap_or(false) - }); - - let derive = if contains_pfn { - quote!{ - #[derive(Copy, Clone)] - } - } else { - // FIXME: Properly derive Debug - quote!{ - #[derive(Copy, Clone)] - } - }; + let debug_tokens = derive_debug(_struct, union_types); + let dbg_str = if debug_tokens.is_none() { quote!(Debug,) } else {quote!()}; quote!{ #[repr(C)] - #derive + #[derive(Copy, Clone, #dbg_str)] pub struct #name { #(#params,)* } + #debug_tokens } } @@ -1137,10 +1186,15 @@ fn generate_union(union: &vkxml::Union) -> Tokens { } } } -pub fn generate_definition(definition: &vkxml::DefinitionsElement) -> Option { +pub fn generate_definition( + definition: &vkxml::DefinitionsElement, + union_types: &HashSet<&str>, +) -> Option { match *definition { vkxml::DefinitionsElement::Typedef(ref typedef) => Some(generate_typedef(typedef)), - vkxml::DefinitionsElement::Struct(ref _struct) => Some(generate_struct(_struct)), + vkxml::DefinitionsElement::Struct(ref _struct) => { + Some(generate_struct(_struct, union_types)) + } vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask), vkxml::DefinitionsElement::Handle(ref handle) => generate_handle(handle), vkxml::DefinitionsElement::FuncPtr(ref fp) => Some(generate_funcptr(fp)), @@ -1157,8 +1211,7 @@ pub fn generate_feature(feature: &vkxml::Feature, commands: &CommandMap) -> quot spec.elements .iter() .filter_map(|feature_spec| { - if let vkxml::FeatureReference::CommandReference(ref cmd_ref) = - feature_spec + if let vkxml::FeatureReference::CommandReference(ref cmd_ref) = feature_spec { Some(cmd_ref) } else { @@ -1320,9 +1373,17 @@ pub fn write_source_code(path: &Path) { .filter_map(|ext| generate_extension(ext, &commands, &mut const_cache)) .collect_vec(); + let union_types = definitions + .iter() + .filter_map(|def| match def { + vkxml::DefinitionsElement::Union(ref union) => Some(union.name.as_str()), + _ => None, + }) + .collect::>(); + let definition_code: Vec<_> = definitions .into_iter() - .filter_map(generate_definition) + .filter_map(|def| generate_definition(def, &union_types)) .collect(); let feature_code: Vec<_> = features From aeb4ebea51ac422a5481938d18036cd36e9dcf4d Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 30 Jul 2018 19:53:12 +0200 Subject: [PATCH 031/122] Refactor generate_extension --- generator/src/lib.rs | 137 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 117 insertions(+), 20 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index ae7e00b..12158b3 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -92,12 +92,17 @@ pub fn define_handle_macro() -> Tokens { pub struct $name{ ptr: *mut u8 } + impl Default for $name{ + fn default() -> $name { + $name::null() + } + } unsafe impl Send for $name {} unsafe impl Sync for $name {} impl $name{ - pub unsafe fn null() -> Self{ + pub fn null() -> Self{ $name{ ptr: ::std::ptr::null_mut() } @@ -113,7 +118,7 @@ pub fn handle_nondispatchable_macro() -> Tokens { macro_rules! handle_nondispatchable { ($name: ident) => { #[repr(C)] - #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name (uint64_t); impl $name{ @@ -757,11 +762,12 @@ impl<'a> ConstantExt for ExtensionConstant<'a> { } pub fn generate_extension_constants<'a>( - extension: &'a vk_parse::Extension, + extension_name: &str, + extension_number: i64, + extension_items: &'a [vk_parse::ExtensionItem], const_cache: &mut HashSet<&'a str>, ) -> quote::Tokens { - let items = extension - .items + let items = extension_items .iter() .filter_map(|item| match item { vk_parse::ExtensionItem::Require { items, .. } => Some(items.iter()), @@ -788,12 +794,13 @@ pub fn generate_extension_constants<'a>( } => { let ext_base = 1_000_000_000; let ext_block_size = 1000; - let extnumber = extnumber.unwrap_or_else(|| extension.number.expect("number")); + let extnumber = extnumber.unwrap_or_else(|| extension_number); let value = ext_base + (extnumber - 1) * ext_block_size + offset; Some((Constant::Number(value as i32), Some(extends.clone()))) } _ => None, }?; + let extends = extends?; let ext_constant = ExtensionConstant { name: &_enum.name, @@ -801,7 +808,7 @@ pub fn generate_extension_constants<'a>( }; let ident = name_to_tokens(&extends); let impl_block = bitflags_impl_block(ident, &extends, &[&ext_constant]); - let doc_string = format!("Generated from '{}'", extension.name); + let doc_string = format!("Generated from '{}'", extension_name); let q = quote!{ #[doc = #doc_string] #impl_block @@ -817,11 +824,11 @@ pub fn generate_extension_constants<'a>( } } pub fn generate_extension_commands( - extension: &vk_parse::Extension, + extension_name: &str, + items: &[vk_parse::ExtensionItem], cmd_map: &CommandMap, ) -> Tokens { - let commands = extension - .items + let commands = items .iter() .filter_map(|ext_item| match ext_item { vk_parse::ExtensionItem::Require { items, .. } => { @@ -834,7 +841,7 @@ pub fn generate_extension_commands( }) .flat_map(|iter| iter) .collect_vec(); - let name = format!("{}Fn", extension.name.to_camel_case()); + let name = format!("{}Fn", extension_name.to_camel_case()); let ident = Ident::from(&name[2..]); generate_function_pointers(ident, &commands) } @@ -843,12 +850,17 @@ pub fn generate_extension<'a>( cmd_map: &CommandMap, const_cache: &mut HashSet<&'a str>, ) -> Option { - let _ = extension - .supported - .as_ref() - .filter(|s| s.as_str() == "vulkan")?; - let extension_tokens = generate_extension_constants(extension, const_cache); - let fp = generate_extension_commands(extension, cmd_map); + // let _ = extension + // .supported + // .as_ref() + // .filter(|s| s.as_str() == "vulkan")?; + let extension_tokens = generate_extension_constants( + &extension.name, + extension.number.unwrap_or(0), + &extension.items, + const_cache, + ); + let fp = generate_extension_commands(&extension.name, &extension.items, cmd_map); let q = quote!{ #fp #extension_tokens @@ -983,7 +995,7 @@ pub fn generate_enum<'a>( } else { let impl_block = bitflags_impl_block(ident, &_enum.name, &constants); let enum_quote = quote!{ - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct #ident(pub(crate) i32); #impl_block @@ -1050,6 +1062,70 @@ fn is_static_array(field: &vkxml::Field) -> bool { }) .unwrap_or(false) } +pub fn derive_default(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Option { + let name = name_to_tokens(&_struct.name); + let members = _struct.elements.iter().filter_map(|elem| match *elem { + vkxml::StructElement::Member(ref field) => Some(field), + _ => None, + }); + let is_structure_type = |field: &vkxml::Field| field.basetype == "VkStructureType"; + let is_pfn = |field: &vkxml::Field| { + field + .name + .as_ref() + .map(|n| n.contains("pfn")) + .unwrap_or(false) + }; + let contains_pfn = members.clone().any(is_pfn); + + let contains_ptr = members.clone().any(|field| field.reference.is_some()); + let contains_strucutre_type = members.clone().any(is_structure_type); + let contains_static_array = members.clone().any(is_static_array); + if !(contains_ptr || contains_pfn || contains_strucutre_type || contains_static_array) { + return None; + }; + let default_fields = members.clone().map(|field| { + let param_ident = field.param_ident(); + if is_structure_type(field) { + let ty = field + .type_enums + .as_ref() + .and_then(|ty| ty.split(',').nth(0)); + if let Some(variant) = ty { + let variant_ident = variant_ident("VkStructureType", variant); + + quote!{ + #param_ident: StructureType::#variant_ident + } + } else { + quote!{ + #param_ident: unsafe { ::std::mem::zeroed() } + } + } + } else if field.reference.is_some() || is_static_array(field) || is_pfn(field) { + quote!{ + #param_ident: unsafe { ::std::mem::zeroed() } + } + } else { + let ty = field.type_tokens(); + quote!{ + #param_ident: #ty::default() + } + } + }); + let q = quote!{ + impl ::std::default::Default for #name { + fn default() -> #name { + #name { + #( + #default_fields + ),* + } + } + } + }; + Some(q) +} pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Option { let name = name_to_tokens(&_struct.name); let members = _struct.elements.iter().filter_map(|elem| match *elem { @@ -1120,14 +1196,25 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> }); let debug_tokens = derive_debug(_struct, union_types); - let dbg_str = if debug_tokens.is_none() { quote!(Debug,) } else {quote!()}; + let default_tokens = derive_default(_struct, union_types); + let dbg_str = if debug_tokens.is_none() { + quote!(Debug,) + } else { + quote!() + }; + let default_str = if default_tokens.is_none() { + quote!(Default,) + } else { + quote!() + }; quote!{ #[repr(C)] - #[derive(Copy, Clone, #dbg_str)] + #[derive(Copy, Clone, #default_str #dbg_str)] pub struct #name { #(#params,)* } #debug_tokens + #default_tokens } } @@ -1184,6 +1271,11 @@ fn generate_union(union: &vkxml::Union) -> Tokens { pub union #name { #(#fields),* } + impl ::std::default::Default for #name { + fn default() -> #name { + unsafe { ::std::mem::zeroed() } + } + } } } pub fn generate_definition( @@ -1296,8 +1388,13 @@ pub fn write_source_code(path: &Path) { }) .nth(0) .expect("extension"); + spec2.0.iter().for_each(|item| match item { + vk_parse::RegistryItem::Enums { name, .. } => println!("{:?}", name), + _ => (), + }); let spec = vk_parse::parse_file_as_vkxml(path); + //println!("{:#?}", spec); let commands: HashMap = spec .elements .iter() From 37f9f9829714c1cec17085b95e5010e84300227d Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 30 Jul 2018 20:06:00 +0200 Subject: [PATCH 032/122] Add extension feature constants --- generator/src/lib.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 12158b3..fa2979c 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1375,6 +1375,21 @@ pub fn generate_constant<'a>( } } +pub fn generate_feature_extension<'a>( + registry: &'a vk_parse::Registry, + const_cache: &mut HashSet<&'a str>, +) -> Tokens { + let constants = registry.0.iter().filter_map(|item| match item { + vk_parse::RegistryItem::Feature { name, items, .. } => { + Some(generate_extension_constants(name, 0, items, const_cache)) + } + _ => None, + }); + quote!{ + #(#constants)* + } +} + pub fn write_source_code(path: &Path) { use std::fs::File; use std::io::Write; @@ -1487,6 +1502,7 @@ pub fn write_source_code(path: &Path) { .iter() .map(|feature| generate_feature(feature, &commands)) .collect(); + let feature_extensions_code = generate_feature_extension(&spec2, &mut const_cache); let mut file = File::create("../ash/src/vk.rs").expect("vk"); let bitflags_macro = vk_bitflags_wrapped_macro(); @@ -1517,6 +1533,7 @@ pub fn write_source_code(path: &Path) { pub mod extensions { use super::*; #(#extension_code)* + #feature_extensions_code } }; write!(&mut file, "{}", source_code).expect("Unable to write to file"); From 7201e786748f06dd23723dfbffa85989516a736d Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 30 Jul 2018 20:23:25 +0200 Subject: [PATCH 033/122] Don't implement Default for handles --- generator/src/lib.rs | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index fa2979c..b7028be 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -850,10 +850,12 @@ pub fn generate_extension<'a>( cmd_map: &CommandMap, const_cache: &mut HashSet<&'a str>, ) -> Option { - // let _ = extension - // .supported - // .as_ref() - // .filter(|s| s.as_str() == "vulkan")?; + // Okay this is a little bit odd. We need to generate all extensions, even disabled ones, + // because otherwise some StructureTypes won't get generated. But we don't generate extensions + // that are reserved + if extension.name.contains("RESERVED") { + return None; + } let extension_tokens = generate_extension_constants( &extension.name, extension.number.unwrap_or(0), @@ -1078,6 +1080,9 @@ pub fn derive_default(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> O }; let contains_pfn = members.clone().any(is_pfn); + // This are also pointers, and therefor also don't implement Default. The spec + // also doesn't mark them as pointers + let handles = ["LPCWSTR", "HANDLE", "HINSTANCE", "HWND"]; let contains_ptr = members.clone().any(|field| field.reference.is_some()); let contains_strucutre_type = members.clone().any(is_structure_type); let contains_static_array = members.clone().any(is_static_array); @@ -1102,7 +1107,11 @@ pub fn derive_default(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> O #param_ident: unsafe { ::std::mem::zeroed() } } } - } else if field.reference.is_some() || is_static_array(field) || is_pfn(field) { + } else if field.reference.is_some() + || is_static_array(field) + || is_pfn(field) + || handles.contains(&field.basetype.as_str()) + { quote!{ #param_ident: unsafe { ::std::mem::zeroed() } } @@ -1403,13 +1412,8 @@ pub fn write_source_code(path: &Path) { }) .nth(0) .expect("extension"); - spec2.0.iter().for_each(|item| match item { - vk_parse::RegistryItem::Enums { name, .. } => println!("{:?}", name), - _ => (), - }); let spec = vk_parse::parse_file_as_vkxml(path); - //println!("{:#?}", spec); let commands: HashMap = spec .elements .iter() From 6563754e322ef0315ed3cbff47c3ba8d457944d7 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 30 Jul 2018 20:25:54 +0200 Subject: [PATCH 034/122] Add new changes to vk.rs --- ash/src/vk.rs | 6112 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 5911 insertions(+), 201 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index ae5edac..24aa663 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -176,7 +176,7 @@ macro_rules! vk_bitflags_wrapped { macro_rules! handle_nondispatchable { ($name:ident) => { #[repr(C)] - #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(uint64_t); impl $name { pub fn null() -> $name { @@ -208,10 +208,15 @@ macro_rules! define_handle { pub struct $name { ptr: *mut u8, } + impl Default for $name { + fn default() -> $name { + $name::null() + } + } unsafe impl Send for $name {} unsafe impl Sync for $name {} impl $name { - pub unsafe fn null() -> Self { + pub fn null() -> Self { $name { ptr: ::std::ptr::null_mut(), } @@ -4853,40 +4858,56 @@ pub struct BaseOutStructure { pub s_type: StructureType, pub p_next: *const BaseOutStructure, } +impl ::std::default::Default for BaseOutStructure { + fn default() -> BaseOutStructure { + BaseOutStructure { + s_type: unsafe { ::std::mem::zeroed() }, + p_next: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BaseInStructure { pub s_type: StructureType, pub p_next: *const BaseInStructure, } +impl ::std::default::Default for BaseInStructure { + fn default() -> BaseInStructure { + BaseInStructure { + s_type: unsafe { ::std::mem::zeroed() }, + p_next: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct Offset2D { pub x: int32_t, pub y: int32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct Offset3D { pub x: int32_t, pub y: int32_t, pub z: int32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct Extent2D { pub width: uint32_t, pub height: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct Extent3D { pub width: uint32_t, pub height: uint32_t, pub depth: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct Viewport { pub x: c_float, pub y: c_float, @@ -4896,20 +4917,20 @@ pub struct Viewport { pub max_depth: c_float, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct Rect2D { pub offset: Offset2D, pub extent: Extent2D, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ClearRect { pub rect: Rect2D, pub base_array_layer: uint32_t, pub layer_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ComponentMapping { pub r: ComponentSwizzle, pub g: ComponentSwizzle, @@ -4948,6 +4969,21 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .finish() } } +impl ::std::default::Default for PhysicalDeviceProperties { + fn default() -> PhysicalDeviceProperties { + PhysicalDeviceProperties { + api_version: uint32_t::default(), + driver_version: uint32_t::default(), + vendor_id: uint32_t::default(), + device_id: uint32_t::default(), + device_type: PhysicalDeviceType::default(), + device_name: unsafe { ::std::mem::zeroed() }, + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + limits: PhysicalDeviceLimits::default(), + sparse_properties: PhysicalDeviceSparseProperties::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct ExtensionProperties { @@ -4964,6 +5000,14 @@ impl ::std::fmt::Debug for ExtensionProperties { .finish() } } +impl ::std::default::Default for ExtensionProperties { + fn default() -> ExtensionProperties { + ExtensionProperties { + extension_name: unsafe { ::std::mem::zeroed() }, + spec_version: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct LayerProperties { @@ -4986,6 +5030,16 @@ impl ::std::fmt::Debug for LayerProperties { .finish() } } +impl ::std::default::Default for LayerProperties { + fn default() -> LayerProperties { + LayerProperties { + layer_name: unsafe { ::std::mem::zeroed() }, + spec_version: uint32_t::default(), + implementation_version: uint32_t::default(), + description: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ApplicationInfo { @@ -4997,6 +5051,19 @@ pub struct ApplicationInfo { pub engine_version: uint32_t, pub api_version: uint32_t, } +impl ::std::default::Default for ApplicationInfo { + fn default() -> ApplicationInfo { + ApplicationInfo { + s_type: StructureType::APPLICATION_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + p_application_name: unsafe { ::std::mem::zeroed() }, + application_version: uint32_t::default(), + p_engine_name: unsafe { ::std::mem::zeroed() }, + engine_version: uint32_t::default(), + api_version: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct AllocationCallbacks { @@ -5022,6 +5089,18 @@ impl ::std::fmt::Debug for AllocationCallbacks { .finish() } } +impl ::std::default::Default for AllocationCallbacks { + fn default() -> AllocationCallbacks { + AllocationCallbacks { + p_user_data: unsafe { ::std::mem::zeroed() }, + pfn_allocation: unsafe { ::std::mem::zeroed() }, + pfn_reallocation: unsafe { ::std::mem::zeroed() }, + pfn_free: unsafe { ::std::mem::zeroed() }, + pfn_internal_allocation: unsafe { ::std::mem::zeroed() }, + pfn_internal_free: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceQueueCreateInfo { @@ -5032,6 +5111,18 @@ pub struct DeviceQueueCreateInfo { pub queue_count: uint32_t, pub p_queue_priorities: *const c_float, } +impl ::std::default::Default for DeviceQueueCreateInfo { + fn default() -> DeviceQueueCreateInfo { + DeviceQueueCreateInfo { + s_type: StructureType::DEVICE_QUEUE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DeviceQueueCreateFlags::default(), + queue_family_index: uint32_t::default(), + queue_count: uint32_t::default(), + p_queue_priorities: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceCreateInfo { @@ -5046,6 +5137,22 @@ pub struct DeviceCreateInfo { pub pp_enabled_extension_names: *const c_char, pub p_enabled_features: *const PhysicalDeviceFeatures, } +impl ::std::default::Default for DeviceCreateInfo { + fn default() -> DeviceCreateInfo { + DeviceCreateInfo { + s_type: StructureType::DEVICE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DeviceCreateFlags::default(), + queue_create_info_count: uint32_t::default(), + p_queue_create_infos: unsafe { ::std::mem::zeroed() }, + enabled_layer_count: uint32_t::default(), + pp_enabled_layer_names: unsafe { ::std::mem::zeroed() }, + enabled_extension_count: uint32_t::default(), + pp_enabled_extension_names: unsafe { ::std::mem::zeroed() }, + p_enabled_features: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct InstanceCreateInfo { @@ -5058,8 +5165,22 @@ pub struct InstanceCreateInfo { pub enabled_extension_count: uint32_t, pub pp_enabled_extension_names: *const c_char, } +impl ::std::default::Default for InstanceCreateInfo { + fn default() -> InstanceCreateInfo { + InstanceCreateInfo { + s_type: StructureType::INSTANCE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: InstanceCreateFlags::default(), + p_application_info: unsafe { ::std::mem::zeroed() }, + enabled_layer_count: uint32_t::default(), + pp_enabled_layer_names: unsafe { ::std::mem::zeroed() }, + enabled_extension_count: uint32_t::default(), + pp_enabled_extension_names: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct QueueFamilyProperties { pub queue_flags: QueueFlags, pub queue_count: uint32_t, @@ -5088,6 +5209,16 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .finish() } } +impl ::std::default::Default for PhysicalDeviceMemoryProperties { + fn default() -> PhysicalDeviceMemoryProperties { + PhysicalDeviceMemoryProperties { + memory_type_count: uint32_t::default(), + memory_types: unsafe { ::std::mem::zeroed() }, + memory_heap_count: uint32_t::default(), + memory_heaps: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryAllocateInfo { @@ -5096,22 +5227,32 @@ pub struct MemoryAllocateInfo { pub allocation_size: DeviceSize, pub memory_type_index: uint32_t, } +impl ::std::default::Default for MemoryAllocateInfo { + fn default() -> MemoryAllocateInfo { + MemoryAllocateInfo { + s_type: StructureType::MEMORY_ALLOCATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + allocation_size: DeviceSize::default(), + memory_type_index: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct MemoryRequirements { pub size: DeviceSize, pub alignment: DeviceSize, pub memory_type_bits: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SparseImageFormatProperties { pub aspect_mask: ImageAspectFlags, pub image_granularity: Extent3D, pub flags: SparseImageFormatFlags, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SparseImageMemoryRequirements { pub format_properties: SparseImageFormatProperties, pub image_mip_tail_first_lod: uint32_t, @@ -5120,13 +5261,13 @@ pub struct SparseImageMemoryRequirements { pub image_mip_tail_stride: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct MemoryType { pub property_flags: MemoryPropertyFlags, pub heap_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct MemoryHeap { pub size: DeviceSize, pub flags: MemoryHeapFlags, @@ -5140,15 +5281,26 @@ pub struct MappedMemoryRange { pub offset: DeviceSize, pub size: DeviceSize, } +impl ::std::default::Default for MappedMemoryRange { + fn default() -> MappedMemoryRange { + MappedMemoryRange { + s_type: StructureType::MAPPED_MEMORY_RANGE, + p_next: unsafe { ::std::mem::zeroed() }, + memory: DeviceMemory::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct FormatProperties { pub linear_tiling_features: FormatFeatureFlags, pub optimal_tiling_features: FormatFeatureFlags, pub buffer_features: FormatFeatureFlags, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageFormatProperties { pub max_extent: Extent3D, pub max_mip_levels: uint32_t, @@ -5157,14 +5309,14 @@ pub struct ImageFormatProperties { pub max_resource_size: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DescriptorBufferInfo { pub buffer: Buffer, pub offset: DeviceSize, pub range: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DescriptorImageInfo { pub sampler: Sampler, pub image_view: ImageView, @@ -5184,6 +5336,22 @@ pub struct WriteDescriptorSet { pub p_buffer_info: *const DescriptorBufferInfo, pub p_texel_buffer_view: *const BufferView, } +impl ::std::default::Default for WriteDescriptorSet { + fn default() -> WriteDescriptorSet { + WriteDescriptorSet { + s_type: StructureType::WRITE_DESCRIPTOR_SET, + p_next: unsafe { ::std::mem::zeroed() }, + dst_set: DescriptorSet::default(), + dst_binding: uint32_t::default(), + dst_array_element: uint32_t::default(), + descriptor_count: uint32_t::default(), + descriptor_type: DescriptorType::default(), + p_image_info: unsafe { ::std::mem::zeroed() }, + p_buffer_info: unsafe { ::std::mem::zeroed() }, + p_texel_buffer_view: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CopyDescriptorSet { @@ -5197,6 +5365,21 @@ pub struct CopyDescriptorSet { pub dst_array_element: uint32_t, pub descriptor_count: uint32_t, } +impl ::std::default::Default for CopyDescriptorSet { + fn default() -> CopyDescriptorSet { + CopyDescriptorSet { + s_type: StructureType::COPY_DESCRIPTOR_SET, + p_next: unsafe { ::std::mem::zeroed() }, + src_set: DescriptorSet::default(), + src_binding: uint32_t::default(), + src_array_element: uint32_t::default(), + dst_set: DescriptorSet::default(), + dst_binding: uint32_t::default(), + dst_array_element: uint32_t::default(), + descriptor_count: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferCreateInfo { @@ -5209,6 +5392,20 @@ pub struct BufferCreateInfo { pub queue_family_index_count: uint32_t, pub p_queue_family_indices: *const uint32_t, } +impl ::std::default::Default for BufferCreateInfo { + fn default() -> BufferCreateInfo { + BufferCreateInfo { + s_type: StructureType::BUFFER_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: BufferCreateFlags::default(), + size: DeviceSize::default(), + usage: BufferUsageFlags::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: uint32_t::default(), + p_queue_family_indices: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferViewCreateInfo { @@ -5220,15 +5417,28 @@ pub struct BufferViewCreateInfo { pub offset: DeviceSize, pub range: DeviceSize, } +impl ::std::default::Default for BufferViewCreateInfo { + fn default() -> BufferViewCreateInfo { + BufferViewCreateInfo { + s_type: StructureType::BUFFER_VIEW_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: BufferViewCreateFlags::default(), + buffer: Buffer::default(), + format: Format::default(), + offset: DeviceSize::default(), + range: DeviceSize::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresource { pub aspect_mask: ImageAspectFlags, pub mip_level: uint32_t, pub array_layer: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresourceLayers { pub aspect_mask: ImageAspectFlags, pub mip_level: uint32_t, @@ -5236,7 +5446,7 @@ pub struct ImageSubresourceLayers { pub layer_count: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresourceRange { pub aspect_mask: ImageAspectFlags, pub base_mip_level: uint32_t, @@ -5252,6 +5462,16 @@ pub struct MemoryBarrier { pub src_access_mask: AccessFlags, pub dst_access_mask: AccessFlags, } +impl ::std::default::Default for MemoryBarrier { + fn default() -> MemoryBarrier { + MemoryBarrier { + s_type: StructureType::MEMORY_BARRIER, + p_next: unsafe { ::std::mem::zeroed() }, + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferMemoryBarrier { @@ -5265,6 +5485,21 @@ pub struct BufferMemoryBarrier { pub offset: DeviceSize, pub size: DeviceSize, } +impl ::std::default::Default for BufferMemoryBarrier { + fn default() -> BufferMemoryBarrier { + BufferMemoryBarrier { + s_type: StructureType::BUFFER_MEMORY_BARRIER, + p_next: unsafe { ::std::mem::zeroed() }, + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + src_queue_family_index: uint32_t::default(), + dst_queue_family_index: uint32_t::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageMemoryBarrier { @@ -5279,6 +5514,22 @@ pub struct ImageMemoryBarrier { pub image: Image, pub subresource_range: ImageSubresourceRange, } +impl ::std::default::Default for ImageMemoryBarrier { + fn default() -> ImageMemoryBarrier { + ImageMemoryBarrier { + s_type: StructureType::IMAGE_MEMORY_BARRIER, + p_next: unsafe { ::std::mem::zeroed() }, + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + old_layout: ImageLayout::default(), + new_layout: ImageLayout::default(), + src_queue_family_index: uint32_t::default(), + dst_queue_family_index: uint32_t::default(), + image: Image::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageCreateInfo { @@ -5298,8 +5549,29 @@ pub struct ImageCreateInfo { pub p_queue_family_indices: *const uint32_t, pub initial_layout: ImageLayout, } +impl ::std::default::Default for ImageCreateInfo { + fn default() -> ImageCreateInfo { + ImageCreateInfo { + s_type: StructureType::IMAGE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: ImageCreateFlags::default(), + image_type: ImageType::default(), + format: Format::default(), + extent: Extent3D::default(), + mip_levels: uint32_t::default(), + array_layers: uint32_t::default(), + samples: SampleCountFlags::default(), + tiling: ImageTiling::default(), + usage: ImageUsageFlags::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: uint32_t::default(), + p_queue_family_indices: unsafe { ::std::mem::zeroed() }, + initial_layout: ImageLayout::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SubresourceLayout { pub offset: DeviceSize, pub size: DeviceSize, @@ -5319,15 +5591,29 @@ pub struct ImageViewCreateInfo { pub components: ComponentMapping, pub subresource_range: ImageSubresourceRange, } +impl ::std::default::Default for ImageViewCreateInfo { + fn default() -> ImageViewCreateInfo { + ImageViewCreateInfo { + s_type: StructureType::IMAGE_VIEW_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: ImageViewCreateFlags::default(), + image: Image::default(), + view_type: ImageViewType::default(), + format: Format::default(), + components: ComponentMapping::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BufferCopy { pub src_offset: DeviceSize, pub dst_offset: DeviceSize, pub size: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SparseMemoryBind { pub resource_offset: DeviceSize, pub size: DeviceSize, @@ -5336,7 +5622,7 @@ pub struct SparseMemoryBind { pub flags: SparseMemoryBindFlags, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SparseImageMemoryBind { pub subresource: ImageSubresource, pub offset: Offset3D, @@ -5352,6 +5638,15 @@ pub struct SparseBufferMemoryBindInfo { pub bind_count: uint32_t, pub p_binds: *const SparseMemoryBind, } +impl ::std::default::Default for SparseBufferMemoryBindInfo { + fn default() -> SparseBufferMemoryBindInfo { + SparseBufferMemoryBindInfo { + buffer: Buffer::default(), + bind_count: uint32_t::default(), + p_binds: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageOpaqueMemoryBindInfo { @@ -5359,6 +5654,15 @@ pub struct SparseImageOpaqueMemoryBindInfo { pub bind_count: uint32_t, pub p_binds: *const SparseMemoryBind, } +impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { + fn default() -> SparseImageOpaqueMemoryBindInfo { + SparseImageOpaqueMemoryBindInfo { + image: Image::default(), + bind_count: uint32_t::default(), + p_binds: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryBindInfo { @@ -5366,6 +5670,15 @@ pub struct SparseImageMemoryBindInfo { pub bind_count: uint32_t, pub p_binds: *const SparseImageMemoryBind, } +impl ::std::default::Default for SparseImageMemoryBindInfo { + fn default() -> SparseImageMemoryBindInfo { + SparseImageMemoryBindInfo { + image: Image::default(), + bind_count: uint32_t::default(), + p_binds: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindSparseInfo { @@ -5382,8 +5695,26 @@ pub struct BindSparseInfo { pub signal_semaphore_count: uint32_t, pub p_signal_semaphores: *const Semaphore, } +impl ::std::default::Default for BindSparseInfo { + fn default() -> BindSparseInfo { + BindSparseInfo { + s_type: StructureType::BIND_SPARSE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + wait_semaphore_count: uint32_t::default(), + p_wait_semaphores: unsafe { ::std::mem::zeroed() }, + buffer_bind_count: uint32_t::default(), + p_buffer_binds: unsafe { ::std::mem::zeroed() }, + image_opaque_bind_count: uint32_t::default(), + p_image_opaque_binds: unsafe { ::std::mem::zeroed() }, + image_bind_count: uint32_t::default(), + p_image_binds: unsafe { ::std::mem::zeroed() }, + signal_semaphore_count: uint32_t::default(), + p_signal_semaphores: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageCopy { pub src_subresource: ImageSubresourceLayers, pub src_offset: Offset3D, @@ -5413,8 +5744,18 @@ impl ::std::fmt::Debug for ImageBlit { .finish() } } +impl ::std::default::Default for ImageBlit { + fn default() -> ImageBlit { + ImageBlit { + src_subresource: ImageSubresourceLayers::default(), + src_offsets: unsafe { ::std::mem::zeroed() }, + dst_subresource: ImageSubresourceLayers::default(), + dst_offsets: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BufferImageCopy { pub buffer_offset: DeviceSize, pub buffer_row_length: uint32_t, @@ -5424,7 +5765,7 @@ pub struct BufferImageCopy { pub image_extent: Extent3D, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageResolve { pub src_subresource: ImageSubresourceLayers, pub src_offset: Offset3D, @@ -5441,6 +5782,17 @@ pub struct ShaderModuleCreateInfo { pub code_size: size_t, pub p_code: *const uint32_t, } +impl ::std::default::Default for ShaderModuleCreateInfo { + fn default() -> ShaderModuleCreateInfo { + ShaderModuleCreateInfo { + s_type: StructureType::SHADER_MODULE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: ShaderModuleCreateFlags::default(), + code_size: size_t::default(), + p_code: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutBinding { @@ -5450,6 +5802,17 @@ pub struct DescriptorSetLayoutBinding { pub stage_flags: ShaderStageFlags, pub p_immutable_samplers: *const Sampler, } +impl ::std::default::Default for DescriptorSetLayoutBinding { + fn default() -> DescriptorSetLayoutBinding { + DescriptorSetLayoutBinding { + binding: uint32_t::default(), + descriptor_type: DescriptorType::default(), + descriptor_count: uint32_t::default(), + stage_flags: ShaderStageFlags::default(), + p_immutable_samplers: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutCreateInfo { @@ -5459,8 +5822,19 @@ pub struct DescriptorSetLayoutCreateInfo { pub binding_count: uint32_t, pub p_bindings: *const DescriptorSetLayoutBinding, } +impl ::std::default::Default for DescriptorSetLayoutCreateInfo { + fn default() -> DescriptorSetLayoutCreateInfo { + DescriptorSetLayoutCreateInfo { + s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DescriptorSetLayoutCreateFlags::default(), + binding_count: uint32_t::default(), + p_bindings: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DescriptorPoolSize { pub ty: DescriptorType, pub descriptor_count: uint32_t, @@ -5475,6 +5849,18 @@ pub struct DescriptorPoolCreateInfo { pub pool_size_count: uint32_t, pub p_pool_sizes: *const DescriptorPoolSize, } +impl ::std::default::Default for DescriptorPoolCreateInfo { + fn default() -> DescriptorPoolCreateInfo { + DescriptorPoolCreateInfo { + s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DescriptorPoolCreateFlags::default(), + max_sets: uint32_t::default(), + pool_size_count: uint32_t::default(), + p_pool_sizes: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetAllocateInfo { @@ -5484,8 +5870,19 @@ pub struct DescriptorSetAllocateInfo { pub descriptor_set_count: uint32_t, pub p_set_layouts: *const DescriptorSetLayout, } +impl ::std::default::Default for DescriptorSetAllocateInfo { + fn default() -> DescriptorSetAllocateInfo { + DescriptorSetAllocateInfo { + s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + descriptor_pool: DescriptorPool::default(), + descriptor_set_count: uint32_t::default(), + p_set_layouts: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SpecializationMapEntry { pub constant_id: uint32_t, pub offset: uint32_t, @@ -5499,6 +5896,16 @@ pub struct SpecializationInfo { pub data_size: size_t, pub p_data: *const c_void, } +impl ::std::default::Default for SpecializationInfo { + fn default() -> SpecializationInfo { + SpecializationInfo { + map_entry_count: uint32_t::default(), + p_map_entries: unsafe { ::std::mem::zeroed() }, + data_size: size_t::default(), + p_data: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineShaderStageCreateInfo { @@ -5510,6 +5917,19 @@ pub struct PipelineShaderStageCreateInfo { pub p_name: *const c_char, pub p_specialization_info: *const SpecializationInfo, } +impl ::std::default::Default for PipelineShaderStageCreateInfo { + fn default() -> PipelineShaderStageCreateInfo { + PipelineShaderStageCreateInfo { + s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineShaderStageCreateFlags::default(), + stage: ShaderStageFlags::default(), + module: ShaderModule::default(), + p_name: unsafe { ::std::mem::zeroed() }, + p_specialization_info: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ComputePipelineCreateInfo { @@ -5521,15 +5941,28 @@ pub struct ComputePipelineCreateInfo { pub base_pipeline_handle: Pipeline, pub base_pipeline_index: int32_t, } +impl ::std::default::Default for ComputePipelineCreateInfo { + fn default() -> ComputePipelineCreateInfo { + ComputePipelineCreateInfo { + s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineCreateFlags::default(), + stage: PipelineShaderStageCreateInfo::default(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: int32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct VertexInputBindingDescription { pub binding: uint32_t, pub stride: uint32_t, pub input_rate: VertexInputRate, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct VertexInputAttributeDescription { pub location: uint32_t, pub binding: uint32_t, @@ -5547,6 +5980,19 @@ pub struct PipelineVertexInputStateCreateInfo { pub vertex_attribute_description_count: uint32_t, pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, } +impl ::std::default::Default for PipelineVertexInputStateCreateInfo { + fn default() -> PipelineVertexInputStateCreateInfo { + PipelineVertexInputStateCreateInfo { + s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineVertexInputStateCreateFlags::default(), + vertex_binding_description_count: uint32_t::default(), + p_vertex_binding_descriptions: unsafe { ::std::mem::zeroed() }, + vertex_attribute_description_count: uint32_t::default(), + p_vertex_attribute_descriptions: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineInputAssemblyStateCreateInfo { @@ -5556,6 +6002,17 @@ pub struct PipelineInputAssemblyStateCreateInfo { pub topology: PrimitiveTopology, pub primitive_restart_enable: Bool32, } +impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo { + fn default() -> PipelineInputAssemblyStateCreateInfo { + PipelineInputAssemblyStateCreateInfo { + s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineInputAssemblyStateCreateFlags::default(), + topology: PrimitiveTopology::default(), + primitive_restart_enable: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineTessellationStateCreateInfo { @@ -5564,6 +6021,16 @@ pub struct PipelineTessellationStateCreateInfo { pub flags: PipelineTessellationStateCreateFlags, pub patch_control_points: uint32_t, } +impl ::std::default::Default for PipelineTessellationStateCreateInfo { + fn default() -> PipelineTessellationStateCreateInfo { + PipelineTessellationStateCreateInfo { + s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineTessellationStateCreateFlags::default(), + patch_control_points: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineViewportStateCreateInfo { @@ -5575,6 +6042,19 @@ pub struct PipelineViewportStateCreateInfo { pub scissor_count: uint32_t, pub p_scissors: *const Rect2D, } +impl ::std::default::Default for PipelineViewportStateCreateInfo { + fn default() -> PipelineViewportStateCreateInfo { + PipelineViewportStateCreateInfo { + s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineViewportStateCreateFlags::default(), + viewport_count: uint32_t::default(), + p_viewports: unsafe { ::std::mem::zeroed() }, + scissor_count: uint32_t::default(), + p_scissors: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationStateCreateInfo { @@ -5592,6 +6072,25 @@ pub struct PipelineRasterizationStateCreateInfo { pub depth_bias_slope_factor: c_float, pub line_width: c_float, } +impl ::std::default::Default for PipelineRasterizationStateCreateInfo { + fn default() -> PipelineRasterizationStateCreateInfo { + PipelineRasterizationStateCreateInfo { + s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineRasterizationStateCreateFlags::default(), + depth_clamp_enable: Bool32::default(), + rasterizer_discard_enable: Bool32::default(), + polygon_mode: PolygonMode::default(), + cull_mode: CullModeFlags::default(), + front_face: FrontFace::default(), + depth_bias_enable: Bool32::default(), + depth_bias_constant_factor: c_float::default(), + depth_bias_clamp: c_float::default(), + depth_bias_slope_factor: c_float::default(), + line_width: c_float::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineMultisampleStateCreateInfo { @@ -5605,8 +6104,23 @@ pub struct PipelineMultisampleStateCreateInfo { pub alpha_to_coverage_enable: Bool32, pub alpha_to_one_enable: Bool32, } +impl ::std::default::Default for PipelineMultisampleStateCreateInfo { + fn default() -> PipelineMultisampleStateCreateInfo { + PipelineMultisampleStateCreateInfo { + s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineMultisampleStateCreateFlags::default(), + rasterization_samples: SampleCountFlags::default(), + sample_shading_enable: Bool32::default(), + min_sample_shading: c_float::default(), + p_sample_mask: unsafe { ::std::mem::zeroed() }, + alpha_to_coverage_enable: Bool32::default(), + alpha_to_one_enable: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PipelineColorBlendAttachmentState { pub blend_enable: Bool32, pub src_color_blend_factor: BlendFactor, @@ -5645,6 +6159,20 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .finish() } } +impl ::std::default::Default for PipelineColorBlendStateCreateInfo { + fn default() -> PipelineColorBlendStateCreateInfo { + PipelineColorBlendStateCreateInfo { + s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineColorBlendStateCreateFlags::default(), + logic_op_enable: Bool32::default(), + logic_op: LogicOp::default(), + attachment_count: uint32_t::default(), + p_attachments: unsafe { ::std::mem::zeroed() }, + blend_constants: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineDynamicStateCreateInfo { @@ -5654,8 +6182,19 @@ pub struct PipelineDynamicStateCreateInfo { pub dynamic_state_count: uint32_t, pub p_dynamic_states: *const DynamicState, } +impl ::std::default::Default for PipelineDynamicStateCreateInfo { + fn default() -> PipelineDynamicStateCreateInfo { + PipelineDynamicStateCreateInfo { + s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineDynamicStateCreateFlags::default(), + dynamic_state_count: uint32_t::default(), + p_dynamic_states: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct StencilOpState { pub fail_op: StencilOp, pub pass_op: StencilOp, @@ -5681,6 +6220,24 @@ pub struct PipelineDepthStencilStateCreateInfo { pub min_depth_bounds: c_float, pub max_depth_bounds: c_float, } +impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { + fn default() -> PipelineDepthStencilStateCreateInfo { + PipelineDepthStencilStateCreateInfo { + s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineDepthStencilStateCreateFlags::default(), + depth_test_enable: Bool32::default(), + depth_write_enable: Bool32::default(), + depth_compare_op: CompareOp::default(), + depth_bounds_test_enable: Bool32::default(), + stencil_test_enable: Bool32::default(), + front: StencilOpState::default(), + back: StencilOpState::default(), + min_depth_bounds: c_float::default(), + max_depth_bounds: c_float::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct GraphicsPipelineCreateInfo { @@ -5704,6 +6261,31 @@ pub struct GraphicsPipelineCreateInfo { pub base_pipeline_handle: Pipeline, pub base_pipeline_index: int32_t, } +impl ::std::default::Default for GraphicsPipelineCreateInfo { + fn default() -> GraphicsPipelineCreateInfo { + GraphicsPipelineCreateInfo { + s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineCreateFlags::default(), + stage_count: uint32_t::default(), + p_stages: unsafe { ::std::mem::zeroed() }, + p_vertex_input_state: unsafe { ::std::mem::zeroed() }, + p_input_assembly_state: unsafe { ::std::mem::zeroed() }, + p_tessellation_state: unsafe { ::std::mem::zeroed() }, + p_viewport_state: unsafe { ::std::mem::zeroed() }, + p_rasterization_state: unsafe { ::std::mem::zeroed() }, + p_multisample_state: unsafe { ::std::mem::zeroed() }, + p_depth_stencil_state: unsafe { ::std::mem::zeroed() }, + p_color_blend_state: unsafe { ::std::mem::zeroed() }, + p_dynamic_state: unsafe { ::std::mem::zeroed() }, + layout: PipelineLayout::default(), + render_pass: RenderPass::default(), + subpass: uint32_t::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: int32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineCacheCreateInfo { @@ -5713,8 +6295,19 @@ pub struct PipelineCacheCreateInfo { pub initial_data_size: size_t, pub p_initial_data: *const c_void, } +impl ::std::default::Default for PipelineCacheCreateInfo { + fn default() -> PipelineCacheCreateInfo { + PipelineCacheCreateInfo { + s_type: StructureType::PIPELINE_CACHE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineCacheCreateFlags::default(), + initial_data_size: size_t::default(), + p_initial_data: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PushConstantRange { pub stage_flags: ShaderStageFlags, pub offset: uint32_t, @@ -5731,6 +6324,19 @@ pub struct PipelineLayoutCreateInfo { pub push_constant_range_count: uint32_t, pub p_push_constant_ranges: *const PushConstantRange, } +impl ::std::default::Default for PipelineLayoutCreateInfo { + fn default() -> PipelineLayoutCreateInfo { + PipelineLayoutCreateInfo { + s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineLayoutCreateFlags::default(), + set_layout_count: uint32_t::default(), + p_set_layouts: unsafe { ::std::mem::zeroed() }, + push_constant_range_count: uint32_t::default(), + p_push_constant_ranges: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerCreateInfo { @@ -5753,6 +6359,30 @@ pub struct SamplerCreateInfo { pub border_color: BorderColor, pub unnormalized_coordinates: Bool32, } +impl ::std::default::Default for SamplerCreateInfo { + fn default() -> SamplerCreateInfo { + SamplerCreateInfo { + s_type: StructureType::SAMPLER_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: SamplerCreateFlags::default(), + mag_filter: Filter::default(), + min_filter: Filter::default(), + mipmap_mode: SamplerMipmapMode::default(), + address_mode_u: SamplerAddressMode::default(), + address_mode_v: SamplerAddressMode::default(), + address_mode_w: SamplerAddressMode::default(), + mip_lod_bias: c_float::default(), + anisotropy_enable: Bool32::default(), + max_anisotropy: c_float::default(), + compare_enable: Bool32::default(), + compare_op: CompareOp::default(), + min_lod: c_float::default(), + max_lod: c_float::default(), + border_color: BorderColor::default(), + unnormalized_coordinates: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandPoolCreateInfo { @@ -5761,6 +6391,16 @@ pub struct CommandPoolCreateInfo { pub flags: CommandPoolCreateFlags, pub queue_family_index: uint32_t, } +impl ::std::default::Default for CommandPoolCreateInfo { + fn default() -> CommandPoolCreateInfo { + CommandPoolCreateInfo { + s_type: StructureType::COMMAND_POOL_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: CommandPoolCreateFlags::default(), + queue_family_index: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandBufferAllocateInfo { @@ -5770,6 +6410,17 @@ pub struct CommandBufferAllocateInfo { pub level: CommandBufferLevel, pub command_buffer_count: uint32_t, } +impl ::std::default::Default for CommandBufferAllocateInfo { + fn default() -> CommandBufferAllocateInfo { + CommandBufferAllocateInfo { + s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + command_pool: CommandPool::default(), + level: CommandBufferLevel::default(), + command_buffer_count: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandBufferInheritanceInfo { @@ -5782,6 +6433,20 @@ pub struct CommandBufferInheritanceInfo { pub query_flags: QueryControlFlags, pub pipeline_statistics: QueryPipelineStatisticFlags, } +impl ::std::default::Default for CommandBufferInheritanceInfo { + fn default() -> CommandBufferInheritanceInfo { + CommandBufferInheritanceInfo { + s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + render_pass: RenderPass::default(), + subpass: uint32_t::default(), + framebuffer: Framebuffer::default(), + occlusion_query_enable: Bool32::default(), + query_flags: QueryControlFlags::default(), + pipeline_statistics: QueryPipelineStatisticFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandBufferBeginInfo { @@ -5790,6 +6455,16 @@ pub struct CommandBufferBeginInfo { pub flags: CommandBufferUsageFlags, pub p_inheritance_info: *const CommandBufferInheritanceInfo, } +impl ::std::default::Default for CommandBufferBeginInfo { + fn default() -> CommandBufferBeginInfo { + CommandBufferBeginInfo { + s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: CommandBufferUsageFlags::default(), + p_inheritance_info: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct RenderPassBeginInfo { @@ -5814,6 +6489,19 @@ impl ::std::fmt::Debug for RenderPassBeginInfo { .finish() } } +impl ::std::default::Default for RenderPassBeginInfo { + fn default() -> RenderPassBeginInfo { + RenderPassBeginInfo { + s_type: StructureType::RENDER_PASS_BEGIN_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + render_pass: RenderPass::default(), + framebuffer: Framebuffer::default(), + render_area: Rect2D::default(), + clear_value_count: uint32_t::default(), + p_clear_values: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub union ClearColorValue { @@ -5821,8 +6509,13 @@ pub union ClearColorValue { pub int32: [int32_t; 4], pub uint32: [uint32_t; 4], } +impl ::std::default::Default for ClearColorValue { + fn default() -> ClearColorValue { + unsafe { ::std::mem::zeroed() } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ClearDepthStencilValue { pub depth: c_float, pub stencil: uint32_t, @@ -5833,8 +6526,13 @@ pub union ClearValue { pub color: ClearColorValue, pub depth_stencil: ClearDepthStencilValue, } +impl ::std::default::Default for ClearValue { + fn default() -> ClearValue { + unsafe { ::std::mem::zeroed() } + } +} #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Default)] pub struct ClearAttachment { pub aspect_mask: ImageAspectFlags, pub color_attachment: uint32_t, @@ -5850,7 +6548,7 @@ impl ::std::fmt::Debug for ClearAttachment { } } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct AttachmentDescription { pub flags: AttachmentDescriptionFlags, pub format: Format, @@ -5863,7 +6561,7 @@ pub struct AttachmentDescription { pub final_layout: ImageLayout, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct AttachmentReference { pub attachment: uint32_t, pub layout: ImageLayout, @@ -5882,8 +6580,24 @@ pub struct SubpassDescription { pub preserve_attachment_count: uint32_t, pub p_preserve_attachments: *const uint32_t, } +impl ::std::default::Default for SubpassDescription { + fn default() -> SubpassDescription { + SubpassDescription { + flags: SubpassDescriptionFlags::default(), + pipeline_bind_point: PipelineBindPoint::default(), + input_attachment_count: uint32_t::default(), + p_input_attachments: unsafe { ::std::mem::zeroed() }, + color_attachment_count: uint32_t::default(), + p_color_attachments: unsafe { ::std::mem::zeroed() }, + p_resolve_attachments: unsafe { ::std::mem::zeroed() }, + p_depth_stencil_attachment: unsafe { ::std::mem::zeroed() }, + preserve_attachment_count: uint32_t::default(), + p_preserve_attachments: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SubpassDependency { pub src_subpass: uint32_t, pub dst_subpass: uint32_t, @@ -5906,6 +6620,21 @@ pub struct RenderPassCreateInfo { pub dependency_count: uint32_t, pub p_dependencies: *const SubpassDependency, } +impl ::std::default::Default for RenderPassCreateInfo { + fn default() -> RenderPassCreateInfo { + RenderPassCreateInfo { + s_type: StructureType::RENDER_PASS_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: RenderPassCreateFlags::default(), + attachment_count: uint32_t::default(), + p_attachments: unsafe { ::std::mem::zeroed() }, + subpass_count: uint32_t::default(), + p_subpasses: unsafe { ::std::mem::zeroed() }, + dependency_count: uint32_t::default(), + p_dependencies: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct EventCreateInfo { @@ -5913,6 +6642,15 @@ pub struct EventCreateInfo { pub p_next: *const c_void, pub flags: EventCreateFlags, } +impl ::std::default::Default for EventCreateInfo { + fn default() -> EventCreateInfo { + EventCreateInfo { + s_type: StructureType::EVENT_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: EventCreateFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FenceCreateInfo { @@ -5920,8 +6658,17 @@ pub struct FenceCreateInfo { pub p_next: *const c_void, pub flags: FenceCreateFlags, } +impl ::std::default::Default for FenceCreateInfo { + fn default() -> FenceCreateInfo { + FenceCreateInfo { + s_type: StructureType::FENCE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: FenceCreateFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceFeatures { pub robust_buffer_access: Bool32, pub full_draw_index_uint32: Bool32, @@ -5980,7 +6727,7 @@ pub struct PhysicalDeviceFeatures { pub inherited_queries: Bool32, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceSparseProperties { pub residency_standard2_d_block_shape: Bool32, pub residency_standard2_d_multisample_block_shape: Bool32, @@ -6393,6 +7140,118 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .finish() } } +impl ::std::default::Default for PhysicalDeviceLimits { + fn default() -> PhysicalDeviceLimits { + PhysicalDeviceLimits { + max_image_dimension1_d: uint32_t::default(), + max_image_dimension2_d: uint32_t::default(), + max_image_dimension3_d: uint32_t::default(), + max_image_dimension_cube: uint32_t::default(), + max_image_array_layers: uint32_t::default(), + max_texel_buffer_elements: uint32_t::default(), + max_uniform_buffer_range: uint32_t::default(), + max_storage_buffer_range: uint32_t::default(), + max_push_constants_size: uint32_t::default(), + max_memory_allocation_count: uint32_t::default(), + max_sampler_allocation_count: uint32_t::default(), + buffer_image_granularity: DeviceSize::default(), + sparse_address_space_size: DeviceSize::default(), + max_bound_descriptor_sets: uint32_t::default(), + max_per_stage_descriptor_samplers: uint32_t::default(), + max_per_stage_descriptor_uniform_buffers: uint32_t::default(), + max_per_stage_descriptor_storage_buffers: uint32_t::default(), + max_per_stage_descriptor_sampled_images: uint32_t::default(), + max_per_stage_descriptor_storage_images: uint32_t::default(), + max_per_stage_descriptor_input_attachments: uint32_t::default(), + max_per_stage_resources: uint32_t::default(), + max_descriptor_set_samplers: uint32_t::default(), + max_descriptor_set_uniform_buffers: uint32_t::default(), + max_descriptor_set_uniform_buffers_dynamic: uint32_t::default(), + max_descriptor_set_storage_buffers: uint32_t::default(), + max_descriptor_set_storage_buffers_dynamic: uint32_t::default(), + max_descriptor_set_sampled_images: uint32_t::default(), + max_descriptor_set_storage_images: uint32_t::default(), + max_descriptor_set_input_attachments: uint32_t::default(), + max_vertex_input_attributes: uint32_t::default(), + max_vertex_input_bindings: uint32_t::default(), + max_vertex_input_attribute_offset: uint32_t::default(), + max_vertex_input_binding_stride: uint32_t::default(), + max_vertex_output_components: uint32_t::default(), + max_tessellation_generation_level: uint32_t::default(), + max_tessellation_patch_size: uint32_t::default(), + max_tessellation_control_per_vertex_input_components: uint32_t::default(), + max_tessellation_control_per_vertex_output_components: uint32_t::default(), + max_tessellation_control_per_patch_output_components: uint32_t::default(), + max_tessellation_control_total_output_components: uint32_t::default(), + max_tessellation_evaluation_input_components: uint32_t::default(), + max_tessellation_evaluation_output_components: uint32_t::default(), + max_geometry_shader_invocations: uint32_t::default(), + max_geometry_input_components: uint32_t::default(), + max_geometry_output_components: uint32_t::default(), + max_geometry_output_vertices: uint32_t::default(), + max_geometry_total_output_components: uint32_t::default(), + max_fragment_input_components: uint32_t::default(), + max_fragment_output_attachments: uint32_t::default(), + max_fragment_dual_src_attachments: uint32_t::default(), + max_fragment_combined_output_resources: uint32_t::default(), + max_compute_shared_memory_size: uint32_t::default(), + max_compute_work_group_count: unsafe { ::std::mem::zeroed() }, + max_compute_work_group_invocations: uint32_t::default(), + max_compute_work_group_size: unsafe { ::std::mem::zeroed() }, + sub_pixel_precision_bits: uint32_t::default(), + sub_texel_precision_bits: uint32_t::default(), + mipmap_precision_bits: uint32_t::default(), + max_draw_indexed_index_value: uint32_t::default(), + max_draw_indirect_count: uint32_t::default(), + max_sampler_lod_bias: c_float::default(), + max_sampler_anisotropy: c_float::default(), + max_viewports: uint32_t::default(), + max_viewport_dimensions: unsafe { ::std::mem::zeroed() }, + viewport_bounds_range: unsafe { ::std::mem::zeroed() }, + viewport_sub_pixel_bits: uint32_t::default(), + min_memory_map_alignment: size_t::default(), + min_texel_buffer_offset_alignment: DeviceSize::default(), + min_uniform_buffer_offset_alignment: DeviceSize::default(), + min_storage_buffer_offset_alignment: DeviceSize::default(), + min_texel_offset: int32_t::default(), + max_texel_offset: uint32_t::default(), + min_texel_gather_offset: int32_t::default(), + max_texel_gather_offset: uint32_t::default(), + min_interpolation_offset: c_float::default(), + max_interpolation_offset: c_float::default(), + sub_pixel_interpolation_offset_bits: uint32_t::default(), + max_framebuffer_width: uint32_t::default(), + max_framebuffer_height: uint32_t::default(), + max_framebuffer_layers: uint32_t::default(), + framebuffer_color_sample_counts: SampleCountFlags::default(), + framebuffer_depth_sample_counts: SampleCountFlags::default(), + framebuffer_stencil_sample_counts: SampleCountFlags::default(), + framebuffer_no_attachments_sample_counts: SampleCountFlags::default(), + max_color_attachments: uint32_t::default(), + sampled_image_color_sample_counts: SampleCountFlags::default(), + sampled_image_integer_sample_counts: SampleCountFlags::default(), + sampled_image_depth_sample_counts: SampleCountFlags::default(), + sampled_image_stencil_sample_counts: SampleCountFlags::default(), + storage_image_sample_counts: SampleCountFlags::default(), + max_sample_mask_words: uint32_t::default(), + timestamp_compute_and_graphics: Bool32::default(), + timestamp_period: c_float::default(), + max_clip_distances: uint32_t::default(), + max_cull_distances: uint32_t::default(), + max_combined_clip_and_cull_distances: uint32_t::default(), + discrete_queue_priorities: uint32_t::default(), + point_size_range: unsafe { ::std::mem::zeroed() }, + line_width_range: unsafe { ::std::mem::zeroed() }, + point_size_granularity: c_float::default(), + line_width_granularity: c_float::default(), + strict_lines: Bool32::default(), + standard_sample_locations: Bool32::default(), + optimal_buffer_copy_offset_alignment: DeviceSize::default(), + optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(), + non_coherent_atom_size: DeviceSize::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SemaphoreCreateInfo { @@ -6400,6 +7259,15 @@ pub struct SemaphoreCreateInfo { pub p_next: *const c_void, pub flags: SemaphoreCreateFlags, } +impl ::std::default::Default for SemaphoreCreateInfo { + fn default() -> SemaphoreCreateInfo { + SemaphoreCreateInfo { + s_type: StructureType::SEMAPHORE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: SemaphoreCreateFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct QueryPoolCreateInfo { @@ -6410,6 +7278,18 @@ pub struct QueryPoolCreateInfo { pub query_count: uint32_t, pub pipeline_statistics: QueryPipelineStatisticFlags, } +impl ::std::default::Default for QueryPoolCreateInfo { + fn default() -> QueryPoolCreateInfo { + QueryPoolCreateInfo { + s_type: StructureType::QUERY_POOL_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: QueryPoolCreateFlags::default(), + query_type: QueryType::default(), + query_count: uint32_t::default(), + pipeline_statistics: QueryPipelineStatisticFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FramebufferCreateInfo { @@ -6423,8 +7303,23 @@ pub struct FramebufferCreateInfo { pub height: uint32_t, pub layers: uint32_t, } +impl ::std::default::Default for FramebufferCreateInfo { + fn default() -> FramebufferCreateInfo { + FramebufferCreateInfo { + s_type: StructureType::FRAMEBUFFER_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: FramebufferCreateFlags::default(), + render_pass: RenderPass::default(), + attachment_count: uint32_t::default(), + p_attachments: unsafe { ::std::mem::zeroed() }, + width: uint32_t::default(), + height: uint32_t::default(), + layers: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DrawIndirectCommand { pub vertex_count: uint32_t, pub instance_count: uint32_t, @@ -6432,7 +7327,7 @@ pub struct DrawIndirectCommand { pub first_instance: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DrawIndexedIndirectCommand { pub index_count: uint32_t, pub instance_count: uint32_t, @@ -6441,7 +7336,7 @@ pub struct DrawIndexedIndirectCommand { pub first_instance: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DispatchIndirectCommand { pub x: uint32_t, pub y: uint32_t, @@ -6460,6 +7355,21 @@ pub struct SubmitInfo { pub signal_semaphore_count: uint32_t, pub p_signal_semaphores: *const Semaphore, } +impl ::std::default::Default for SubmitInfo { + fn default() -> SubmitInfo { + SubmitInfo { + s_type: StructureType::SUBMIT_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + wait_semaphore_count: uint32_t::default(), + p_wait_semaphores: unsafe { ::std::mem::zeroed() }, + p_wait_dst_stage_mask: unsafe { ::std::mem::zeroed() }, + command_buffer_count: uint32_t::default(), + p_command_buffers: unsafe { ::std::mem::zeroed() }, + signal_semaphore_count: uint32_t::default(), + p_signal_semaphores: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPropertiesKHR { @@ -6471,20 +7381,33 @@ pub struct DisplayPropertiesKHR { pub plane_reorder_possible: Bool32, pub persistent_content: Bool32, } +impl ::std::default::Default for DisplayPropertiesKHR { + fn default() -> DisplayPropertiesKHR { + DisplayPropertiesKHR { + display: DisplayKHR::default(), + display_name: unsafe { ::std::mem::zeroed() }, + physical_dimensions: Extent2D::default(), + physical_resolution: Extent2D::default(), + supported_transforms: SurfaceTransformFlagsKHR::default(), + plane_reorder_possible: Bool32::default(), + persistent_content: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DisplayPlanePropertiesKHR { pub current_display: DisplayKHR, pub current_stack_index: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DisplayModeParametersKHR { pub visible_region: Extent2D, pub refresh_rate: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DisplayModePropertiesKHR { pub display_mode: DisplayModeKHR, pub parameters: DisplayModeParametersKHR, @@ -6497,8 +7420,18 @@ pub struct DisplayModeCreateInfoKHR { pub flags: DisplayModeCreateFlagsKHR, pub parameters: DisplayModeParametersKHR, } +impl ::std::default::Default for DisplayModeCreateInfoKHR { + fn default() -> DisplayModeCreateInfoKHR { + DisplayModeCreateInfoKHR { + s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DisplayModeCreateFlagsKHR::default(), + parameters: DisplayModeParametersKHR::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DisplayPlaneCapabilitiesKHR { pub supported_alpha: DisplayPlaneAlphaFlagsKHR, pub min_src_position: Offset2D, @@ -6524,6 +7457,22 @@ pub struct DisplaySurfaceCreateInfoKHR { pub alpha_mode: DisplayPlaneAlphaFlagsKHR, pub image_extent: Extent2D, } +impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { + fn default() -> DisplaySurfaceCreateInfoKHR { + DisplaySurfaceCreateInfoKHR { + s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DisplaySurfaceCreateFlagsKHR::default(), + display_mode: DisplayModeKHR::default(), + plane_index: uint32_t::default(), + plane_stack_index: uint32_t::default(), + transform: SurfaceTransformFlagsKHR::default(), + global_alpha: c_float::default(), + alpha_mode: DisplayPlaneAlphaFlagsKHR::default(), + image_extent: Extent2D::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPresentInfoKHR { @@ -6533,8 +7482,19 @@ pub struct DisplayPresentInfoKHR { pub dst_rect: Rect2D, pub persistent: Bool32, } +impl ::std::default::Default for DisplayPresentInfoKHR { + fn default() -> DisplayPresentInfoKHR { + DisplayPresentInfoKHR { + s_type: StructureType::DISPLAY_PRESENT_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + src_rect: Rect2D::default(), + dst_rect: Rect2D::default(), + persistent: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SurfaceCapabilitiesKHR { pub min_image_count: uint32_t, pub max_image_count: uint32_t, @@ -6555,6 +7515,16 @@ pub struct AndroidSurfaceCreateInfoKHR { pub flags: AndroidSurfaceCreateFlagsKHR, pub window: *const ANativeWindow, } +impl ::std::default::Default for AndroidSurfaceCreateInfoKHR { + fn default() -> AndroidSurfaceCreateInfoKHR { + AndroidSurfaceCreateInfoKHR { + s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: AndroidSurfaceCreateFlagsKHR::default(), + window: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MirSurfaceCreateInfoKHR { @@ -6564,6 +7534,17 @@ pub struct MirSurfaceCreateInfoKHR { pub connection: *const MirConnection, pub mir_surface: *const MirSurface, } +impl ::std::default::Default for MirSurfaceCreateInfoKHR { + fn default() -> MirSurfaceCreateInfoKHR { + MirSurfaceCreateInfoKHR { + s_type: StructureType::MIR_SURFACE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: MirSurfaceCreateFlagsKHR::default(), + connection: unsafe { ::std::mem::zeroed() }, + mir_surface: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ViSurfaceCreateInfoNN { @@ -6572,6 +7553,16 @@ pub struct ViSurfaceCreateInfoNN { pub flags: ViSurfaceCreateFlagsNN, pub window: *const c_void, } +impl ::std::default::Default for ViSurfaceCreateInfoNN { + fn default() -> ViSurfaceCreateInfoNN { + ViSurfaceCreateInfoNN { + s_type: StructureType::VI_SURFACE_CREATE_INFO_NN, + p_next: unsafe { ::std::mem::zeroed() }, + flags: ViSurfaceCreateFlagsNN::default(), + window: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct WaylandSurfaceCreateInfoKHR { @@ -6581,6 +7572,17 @@ pub struct WaylandSurfaceCreateInfoKHR { pub display: *const wl_display, pub surface: *const wl_surface, } +impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { + fn default() -> WaylandSurfaceCreateInfoKHR { + WaylandSurfaceCreateInfoKHR { + s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: WaylandSurfaceCreateFlagsKHR::default(), + display: unsafe { ::std::mem::zeroed() }, + surface: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct Win32SurfaceCreateInfoKHR { @@ -6590,6 +7592,17 @@ pub struct Win32SurfaceCreateInfoKHR { pub hinstance: HINSTANCE, pub hwnd: HWND, } +impl ::std::default::Default for Win32SurfaceCreateInfoKHR { + fn default() -> Win32SurfaceCreateInfoKHR { + Win32SurfaceCreateInfoKHR { + s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: Win32SurfaceCreateFlagsKHR::default(), + hinstance: unsafe { ::std::mem::zeroed() }, + hwnd: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct XlibSurfaceCreateInfoKHR { @@ -6599,6 +7612,17 @@ pub struct XlibSurfaceCreateInfoKHR { pub dpy: *const Display, pub window: Window, } +impl ::std::default::Default for XlibSurfaceCreateInfoKHR { + fn default() -> XlibSurfaceCreateInfoKHR { + XlibSurfaceCreateInfoKHR { + s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: XlibSurfaceCreateFlagsKHR::default(), + dpy: unsafe { ::std::mem::zeroed() }, + window: Window::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct XcbSurfaceCreateInfoKHR { @@ -6608,8 +7632,19 @@ pub struct XcbSurfaceCreateInfoKHR { pub connection: *const xcb_connection_t, pub window: xcb_window_t, } +impl ::std::default::Default for XcbSurfaceCreateInfoKHR { + fn default() -> XcbSurfaceCreateInfoKHR { + XcbSurfaceCreateInfoKHR { + s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: XcbSurfaceCreateFlagsKHR::default(), + connection: unsafe { ::std::mem::zeroed() }, + window: xcb_window_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SurfaceFormatKHR { pub format: Format, pub color_space: ColorSpaceKHR, @@ -6636,6 +7671,30 @@ pub struct SwapchainCreateInfoKHR { pub clipped: Bool32, pub old_swapchain: SwapchainKHR, } +impl ::std::default::Default for SwapchainCreateInfoKHR { + fn default() -> SwapchainCreateInfoKHR { + SwapchainCreateInfoKHR { + s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + flags: SwapchainCreateFlagsKHR::default(), + surface: SurfaceKHR::default(), + min_image_count: uint32_t::default(), + image_format: Format::default(), + image_color_space: ColorSpaceKHR::default(), + image_extent: Extent2D::default(), + image_array_layers: uint32_t::default(), + image_usage: ImageUsageFlags::default(), + image_sharing_mode: SharingMode::default(), + queue_family_index_count: uint32_t::default(), + p_queue_family_indices: unsafe { ::std::mem::zeroed() }, + pre_transform: SurfaceTransformFlagsKHR::default(), + composite_alpha: CompositeAlphaFlagsKHR::default(), + present_mode: PresentModeKHR::default(), + clipped: Bool32::default(), + old_swapchain: SwapchainKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentInfoKHR { @@ -6648,6 +7707,20 @@ pub struct PresentInfoKHR { pub p_image_indices: *const uint32_t, pub p_results: *const Result, } +impl ::std::default::Default for PresentInfoKHR { + fn default() -> PresentInfoKHR { + PresentInfoKHR { + s_type: StructureType::PRESENT_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + wait_semaphore_count: uint32_t::default(), + p_wait_semaphores: unsafe { ::std::mem::zeroed() }, + swapchain_count: uint32_t::default(), + p_swapchains: unsafe { ::std::mem::zeroed() }, + p_image_indices: unsafe { ::std::mem::zeroed() }, + p_results: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct DebugReportCallbackCreateInfoEXT { @@ -6668,6 +7741,17 @@ impl ::std::fmt::Debug for DebugReportCallbackCreateInfoEXT { .finish() } } +impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { + fn default() -> DebugReportCallbackCreateInfoEXT { + DebugReportCallbackCreateInfoEXT { + s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DebugReportFlagsEXT::default(), + pfn_callback: unsafe { ::std::mem::zeroed() }, + p_user_data: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ValidationFlagsEXT { @@ -6676,6 +7760,16 @@ pub struct ValidationFlagsEXT { pub disabled_validation_check_count: uint32_t, pub p_disabled_validation_checks: *const ValidationCheckEXT, } +impl ::std::default::Default for ValidationFlagsEXT { + fn default() -> ValidationFlagsEXT { + ValidationFlagsEXT { + s_type: StructureType::VALIDATION_FLAGS_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + disabled_validation_check_count: uint32_t::default(), + p_disabled_validation_checks: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationStateRasterizationOrderAMD { @@ -6683,6 +7777,15 @@ pub struct PipelineRasterizationStateRasterizationOrderAMD { pub p_next: *const c_void, pub rasterization_order: RasterizationOrderAMD, } +impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD { + fn default() -> PipelineRasterizationStateRasterizationOrderAMD { + PipelineRasterizationStateRasterizationOrderAMD { + s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, + p_next: unsafe { ::std::mem::zeroed() }, + rasterization_order: RasterizationOrderAMD::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugMarkerObjectNameInfoEXT { @@ -6692,6 +7795,17 @@ pub struct DebugMarkerObjectNameInfoEXT { pub object: uint64_t, pub p_object_name: *const c_char, } +impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { + fn default() -> DebugMarkerObjectNameInfoEXT { + DebugMarkerObjectNameInfoEXT { + s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + object_type: DebugReportObjectTypeEXT::default(), + object: uint64_t::default(), + p_object_name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugMarkerObjectTagInfoEXT { @@ -6703,6 +7817,19 @@ pub struct DebugMarkerObjectTagInfoEXT { pub tag_size: size_t, pub p_tag: *const c_void, } +impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { + fn default() -> DebugMarkerObjectTagInfoEXT { + DebugMarkerObjectTagInfoEXT { + s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + object_type: DebugReportObjectTypeEXT::default(), + object: uint64_t::default(), + tag_name: uint64_t::default(), + tag_size: size_t::default(), + p_tag: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct DebugMarkerMarkerInfoEXT { @@ -6723,6 +7850,16 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .finish() } } +impl ::std::default::Default for DebugMarkerMarkerInfoEXT { + fn default() -> DebugMarkerMarkerInfoEXT { + DebugMarkerMarkerInfoEXT { + s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + p_marker_name: unsafe { ::std::mem::zeroed() }, + color: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationImageCreateInfoNV { @@ -6730,6 +7867,15 @@ pub struct DedicatedAllocationImageCreateInfoNV { pub p_next: *const c_void, pub dedicated_allocation: Bool32, } +impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV { + fn default() -> DedicatedAllocationImageCreateInfoNV { + DedicatedAllocationImageCreateInfoNV { + s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + dedicated_allocation: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationBufferCreateInfoNV { @@ -6737,6 +7883,15 @@ pub struct DedicatedAllocationBufferCreateInfoNV { pub p_next: *const c_void, pub dedicated_allocation: Bool32, } +impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV { + fn default() -> DedicatedAllocationBufferCreateInfoNV { + DedicatedAllocationBufferCreateInfoNV { + s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + dedicated_allocation: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationMemoryAllocateInfoNV { @@ -6745,8 +7900,18 @@ pub struct DedicatedAllocationMemoryAllocateInfoNV { pub image: Image, pub buffer: Buffer, } +impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV { + fn default() -> DedicatedAllocationMemoryAllocateInfoNV { + DedicatedAllocationMemoryAllocateInfoNV { + s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + image: Image::default(), + buffer: Buffer::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalImageFormatPropertiesNV { pub image_format_properties: ImageFormatProperties, pub external_memory_features: ExternalMemoryFeatureFlagsNV, @@ -6760,6 +7925,15 @@ pub struct ExternalMemoryImageCreateInfoNV { pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlagsNV, } +impl ::std::default::Default for ExternalMemoryImageCreateInfoNV { + fn default() -> ExternalMemoryImageCreateInfoNV { + ExternalMemoryImageCreateInfoNV { + s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryAllocateInfoNV { @@ -6767,6 +7941,15 @@ pub struct ExportMemoryAllocateInfoNV { pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlagsNV, } +impl ::std::default::Default for ExportMemoryAllocateInfoNV { + fn default() -> ExportMemoryAllocateInfoNV { + ExportMemoryAllocateInfoNV { + s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryWin32HandleInfoNV { @@ -6775,6 +7958,16 @@ pub struct ImportMemoryWin32HandleInfoNV { pub handle_type: ExternalMemoryHandleTypeFlagsNV, pub handle: HANDLE, } +impl ::std::default::Default for ImportMemoryWin32HandleInfoNV { + fn default() -> ImportMemoryWin32HandleInfoNV { + ImportMemoryWin32HandleInfoNV { + s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + handle_type: ExternalMemoryHandleTypeFlagsNV::default(), + handle: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryWin32HandleInfoNV { @@ -6783,6 +7976,16 @@ pub struct ExportMemoryWin32HandleInfoNV { pub p_attributes: *const SECURITY_ATTRIBUTES, pub dw_access: DWORD, } +impl ::std::default::Default for ExportMemoryWin32HandleInfoNV { + fn default() -> ExportMemoryWin32HandleInfoNV { + ExportMemoryWin32HandleInfoNV { + s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + p_attributes: unsafe { ::std::mem::zeroed() }, + dw_access: DWORD::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct Win32KeyedMutexAcquireReleaseInfoNV { @@ -6796,6 +7999,21 @@ pub struct Win32KeyedMutexAcquireReleaseInfoNV { pub p_release_syncs: *const DeviceMemory, pub p_release_keys: *const uint64_t, } +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { + fn default() -> Win32KeyedMutexAcquireReleaseInfoNV { + Win32KeyedMutexAcquireReleaseInfoNV { + s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + acquire_count: uint32_t::default(), + p_acquire_syncs: unsafe { ::std::mem::zeroed() }, + p_acquire_keys: unsafe { ::std::mem::zeroed() }, + p_acquire_timeout_milliseconds: unsafe { ::std::mem::zeroed() }, + release_count: uint32_t::default(), + p_release_syncs: unsafe { ::std::mem::zeroed() }, + p_release_keys: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGeneratedCommandsFeaturesNVX { @@ -6803,6 +8021,15 @@ pub struct DeviceGeneratedCommandsFeaturesNVX { pub p_next: *const c_void, pub compute_binding_point_support: Bool32, } +impl ::std::default::Default for DeviceGeneratedCommandsFeaturesNVX { + fn default() -> DeviceGeneratedCommandsFeaturesNVX { + DeviceGeneratedCommandsFeaturesNVX { + s_type: StructureType::DEVICE_GENERATED_COMMANDS_FEATURES_NVX, + p_next: unsafe { ::std::mem::zeroed() }, + compute_binding_point_support: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGeneratedCommandsLimitsNVX { @@ -6814,15 +8041,28 @@ pub struct DeviceGeneratedCommandsLimitsNVX { pub min_sequence_index_buffer_offset_alignment: uint32_t, pub min_commands_token_buffer_offset_alignment: uint32_t, } +impl ::std::default::Default for DeviceGeneratedCommandsLimitsNVX { + fn default() -> DeviceGeneratedCommandsLimitsNVX { + DeviceGeneratedCommandsLimitsNVX { + s_type: StructureType::DEVICE_GENERATED_COMMANDS_LIMITS_NVX, + p_next: unsafe { ::std::mem::zeroed() }, + max_indirect_commands_layout_token_count: uint32_t::default(), + max_object_entry_counts: uint32_t::default(), + min_sequence_count_buffer_offset_alignment: uint32_t::default(), + min_sequence_index_buffer_offset_alignment: uint32_t::default(), + min_commands_token_buffer_offset_alignment: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct IndirectCommandsTokenNVX { pub token_type: IndirectCommandsTokenTypeNVX, pub buffer: Buffer, pub offset: DeviceSize, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct IndirectCommandsLayoutTokenNVX { pub token_type: IndirectCommandsTokenTypeNVX, pub binding_unit: uint32_t, @@ -6839,6 +8079,18 @@ pub struct IndirectCommandsLayoutCreateInfoNVX { pub token_count: uint32_t, pub p_tokens: *const IndirectCommandsLayoutTokenNVX, } +impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNVX { + fn default() -> IndirectCommandsLayoutCreateInfoNVX { + IndirectCommandsLayoutCreateInfoNVX { + s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, + p_next: unsafe { ::std::mem::zeroed() }, + pipeline_bind_point: PipelineBindPoint::default(), + flags: IndirectCommandsLayoutUsageFlagsNVX::default(), + token_count: uint32_t::default(), + p_tokens: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CmdProcessCommandsInfoNVX { @@ -6855,6 +8107,24 @@ pub struct CmdProcessCommandsInfoNVX { pub sequences_index_buffer: Buffer, pub sequences_index_offset: DeviceSize, } +impl ::std::default::Default for CmdProcessCommandsInfoNVX { + fn default() -> CmdProcessCommandsInfoNVX { + CmdProcessCommandsInfoNVX { + s_type: StructureType::CMD_PROCESS_COMMANDS_INFO_NVX, + p_next: unsafe { ::std::mem::zeroed() }, + object_table: ObjectTableNVX::default(), + indirect_commands_layout: IndirectCommandsLayoutNVX::default(), + indirect_commands_token_count: uint32_t::default(), + p_indirect_commands_tokens: unsafe { ::std::mem::zeroed() }, + max_sequences_count: uint32_t::default(), + target_command_buffer: CommandBuffer::default(), + sequences_count_buffer: Buffer::default(), + sequences_count_offset: DeviceSize::default(), + sequences_index_buffer: Buffer::default(), + sequences_index_offset: DeviceSize::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CmdReserveSpaceForCommandsInfoNVX { @@ -6864,6 +8134,17 @@ pub struct CmdReserveSpaceForCommandsInfoNVX { pub indirect_commands_layout: IndirectCommandsLayoutNVX, pub max_sequences_count: uint32_t, } +impl ::std::default::Default for CmdReserveSpaceForCommandsInfoNVX { + fn default() -> CmdReserveSpaceForCommandsInfoNVX { + CmdReserveSpaceForCommandsInfoNVX { + s_type: StructureType::CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX, + p_next: unsafe { ::std::mem::zeroed() }, + object_table: ObjectTableNVX::default(), + indirect_commands_layout: IndirectCommandsLayoutNVX::default(), + max_sequences_count: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ObjectTableCreateInfoNVX { @@ -6879,21 +8160,38 @@ pub struct ObjectTableCreateInfoNVX { pub max_sampled_images_per_descriptor: uint32_t, pub max_pipeline_layouts: uint32_t, } +impl ::std::default::Default for ObjectTableCreateInfoNVX { + fn default() -> ObjectTableCreateInfoNVX { + ObjectTableCreateInfoNVX { + s_type: StructureType::OBJECT_TABLE_CREATE_INFO_NVX, + p_next: unsafe { ::std::mem::zeroed() }, + object_count: uint32_t::default(), + p_object_entry_types: unsafe { ::std::mem::zeroed() }, + p_object_entry_counts: unsafe { ::std::mem::zeroed() }, + p_object_entry_usage_flags: unsafe { ::std::mem::zeroed() }, + max_uniform_buffers_per_descriptor: uint32_t::default(), + max_storage_buffers_per_descriptor: uint32_t::default(), + max_storage_images_per_descriptor: uint32_t::default(), + max_sampled_images_per_descriptor: uint32_t::default(), + max_pipeline_layouts: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ObjectTablePipelineEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, pub pipeline: Pipeline, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableDescriptorSetEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, @@ -6901,14 +8199,14 @@ pub struct ObjectTableDescriptorSetEntryNVX { pub descriptor_set: DescriptorSet, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableVertexBufferEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, pub buffer: Buffer, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableIndexBufferEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, @@ -6916,7 +8214,7 @@ pub struct ObjectTableIndexBufferEntryNVX { pub index_type: IndexType, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ObjectTablePushConstantEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, @@ -6930,8 +8228,17 @@ pub struct PhysicalDeviceFeatures2 { pub p_next: *const c_void, pub features: PhysicalDeviceFeatures, } +impl ::std::default::Default for PhysicalDeviceFeatures2 { + fn default() -> PhysicalDeviceFeatures2 { + PhysicalDeviceFeatures2 { + s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2, + p_next: unsafe { ::std::mem::zeroed() }, + features: PhysicalDeviceFeatures::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceFeatures2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6940,8 +8247,17 @@ pub struct PhysicalDeviceProperties2 { pub p_next: *const c_void, pub properties: PhysicalDeviceProperties, } +impl ::std::default::Default for PhysicalDeviceProperties2 { + fn default() -> PhysicalDeviceProperties2 { + PhysicalDeviceProperties2 { + s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2, + p_next: unsafe { ::std::mem::zeroed() }, + properties: PhysicalDeviceProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceProperties2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6950,8 +8266,17 @@ pub struct FormatProperties2 { pub p_next: *const c_void, pub format_properties: FormatProperties, } +impl ::std::default::Default for FormatProperties2 { + fn default() -> FormatProperties2 { + FormatProperties2 { + s_type: StructureType::FORMAT_PROPERTIES_2, + p_next: unsafe { ::std::mem::zeroed() }, + format_properties: FormatProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct FormatProperties2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6960,8 +8285,17 @@ pub struct ImageFormatProperties2 { pub p_next: *const c_void, pub image_format_properties: ImageFormatProperties, } +impl ::std::default::Default for ImageFormatProperties2 { + fn default() -> ImageFormatProperties2 { + ImageFormatProperties2 { + s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2, + p_next: unsafe { ::std::mem::zeroed() }, + image_format_properties: ImageFormatProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageFormatProperties2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6974,8 +8308,21 @@ pub struct PhysicalDeviceImageFormatInfo2 { pub usage: ImageUsageFlags, pub flags: ImageCreateFlags, } +impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { + fn default() -> PhysicalDeviceImageFormatInfo2 { + PhysicalDeviceImageFormatInfo2 { + s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + p_next: unsafe { ::std::mem::zeroed() }, + format: Format::default(), + ty: ImageType::default(), + tiling: ImageTiling::default(), + usage: ImageUsageFlags::default(), + flags: ImageCreateFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceImageFormatInfo2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6984,8 +8331,17 @@ pub struct QueueFamilyProperties2 { pub p_next: *const c_void, pub queue_family_properties: QueueFamilyProperties, } +impl ::std::default::Default for QueueFamilyProperties2 { + fn default() -> QueueFamilyProperties2 { + QueueFamilyProperties2 { + s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2, + p_next: unsafe { ::std::mem::zeroed() }, + queue_family_properties: QueueFamilyProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct QueueFamilyProperties2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6994,8 +8350,17 @@ pub struct PhysicalDeviceMemoryProperties2 { pub p_next: *const c_void, pub memory_properties: PhysicalDeviceMemoryProperties, } +impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { + fn default() -> PhysicalDeviceMemoryProperties2 { + PhysicalDeviceMemoryProperties2 { + s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + p_next: unsafe { ::std::mem::zeroed() }, + memory_properties: PhysicalDeviceMemoryProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceMemoryProperties2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7004,8 +8369,17 @@ pub struct SparseImageFormatProperties2 { pub p_next: *const c_void, pub properties: SparseImageFormatProperties, } +impl ::std::default::Default for SparseImageFormatProperties2 { + fn default() -> SparseImageFormatProperties2 { + SparseImageFormatProperties2 { + s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2, + p_next: unsafe { ::std::mem::zeroed() }, + properties: SparseImageFormatProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SparseImageFormatProperties2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7018,8 +8392,21 @@ pub struct PhysicalDeviceSparseImageFormatInfo2 { pub usage: ImageUsageFlags, pub tiling: ImageTiling, } +impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { + fn default() -> PhysicalDeviceSparseImageFormatInfo2 { + PhysicalDeviceSparseImageFormatInfo2 { + s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + p_next: unsafe { ::std::mem::zeroed() }, + format: Format::default(), + ty: ImageType::default(), + samples: SampleCountFlags::default(), + usage: ImageUsageFlags::default(), + tiling: ImageTiling::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceSparseImageFormatInfo2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7028,6 +8415,15 @@ pub struct PhysicalDevicePushDescriptorPropertiesKHR { pub p_next: *const c_void, pub max_push_descriptors: uint32_t, } +impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { + fn default() -> PhysicalDevicePushDescriptorPropertiesKHR { + PhysicalDevicePushDescriptorPropertiesKHR { + s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + max_push_descriptors: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentRegionsKHR { @@ -7036,14 +8432,32 @@ pub struct PresentRegionsKHR { pub swapchain_count: uint32_t, pub p_regions: *const PresentRegionKHR, } +impl ::std::default::Default for PresentRegionsKHR { + fn default() -> PresentRegionsKHR { + PresentRegionsKHR { + s_type: StructureType::PRESENT_REGIONS_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + swapchain_count: uint32_t::default(), + p_regions: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentRegionKHR { pub rectangle_count: uint32_t, pub p_rectangles: *const RectLayerKHR, } +impl ::std::default::Default for PresentRegionKHR { + fn default() -> PresentRegionKHR { + PresentRegionKHR { + rectangle_count: uint32_t::default(), + p_rectangles: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct RectLayerKHR { pub offset: Offset2D, pub extent: Extent2D, @@ -7057,18 +8471,28 @@ pub struct PhysicalDeviceVariablePointerFeatures { pub variable_pointers_storage_buffer: Bool32, pub variable_pointers: Bool32, } +impl ::std::default::Default for PhysicalDeviceVariablePointerFeatures { + fn default() -> PhysicalDeviceVariablePointerFeatures { + PhysicalDeviceVariablePointerFeatures { + s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + p_next: unsafe { ::std::mem::zeroed() }, + variable_pointers_storage_buffer: Bool32::default(), + variable_pointers: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceVariablePointerFeaturesKHR {} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalMemoryProperties { pub external_memory_features: ExternalMemoryFeatureFlags, pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, pub compatible_handle_types: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalMemoryPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7077,8 +8501,17 @@ pub struct PhysicalDeviceExternalImageFormatInfo { pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, } +impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo { + fn default() -> PhysicalDeviceExternalImageFormatInfo { + PhysicalDeviceExternalImageFormatInfo { + s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceExternalImageFormatInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7087,8 +8520,17 @@ pub struct ExternalImageFormatProperties { pub p_next: *const c_void, pub external_memory_properties: ExternalMemoryProperties, } +impl ::std::default::Default for ExternalImageFormatProperties { + fn default() -> ExternalImageFormatProperties { + ExternalImageFormatProperties { + s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + external_memory_properties: ExternalMemoryProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalImageFormatPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7099,8 +8541,19 @@ pub struct PhysicalDeviceExternalBufferInfo { pub usage: BufferUsageFlags, pub handle_type: ExternalMemoryHandleTypeFlags, } +impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { + fn default() -> PhysicalDeviceExternalBufferInfo { + PhysicalDeviceExternalBufferInfo { + s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: BufferCreateFlags::default(), + usage: BufferUsageFlags::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceExternalBufferInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7109,8 +8562,17 @@ pub struct ExternalBufferProperties { pub p_next: *const c_void, pub external_memory_properties: ExternalMemoryProperties, } +impl ::std::default::Default for ExternalBufferProperties { + fn default() -> ExternalBufferProperties { + ExternalBufferProperties { + s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + external_memory_properties: ExternalMemoryProperties::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalBufferPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone)] @@ -7142,8 +8604,21 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .finish() } } +impl ::std::default::Default for PhysicalDeviceIDProperties { + fn default() -> PhysicalDeviceIDProperties { + PhysicalDeviceIDProperties { + s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + device_uuid: unsafe { ::std::mem::zeroed() }, + driver_uuid: unsafe { ::std::mem::zeroed() }, + device_luid: unsafe { ::std::mem::zeroed() }, + device_node_mask: uint32_t::default(), + device_luid_valid: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceIDPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7152,8 +8627,17 @@ pub struct ExternalMemoryImageCreateInfo { pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, } +impl ::std::default::Default for ExternalMemoryImageCreateInfo { + fn default() -> ExternalMemoryImageCreateInfo { + ExternalMemoryImageCreateInfo { + s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalMemoryImageCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7162,8 +8646,17 @@ pub struct ExternalMemoryBufferCreateInfo { pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, } +impl ::std::default::Default for ExternalMemoryBufferCreateInfo { + fn default() -> ExternalMemoryBufferCreateInfo { + ExternalMemoryBufferCreateInfo { + s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalMemoryBufferCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7172,8 +8665,17 @@ pub struct ExportMemoryAllocateInfo { pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, } +impl ::std::default::Default for ExportMemoryAllocateInfo { + fn default() -> ExportMemoryAllocateInfo { + ExportMemoryAllocateInfo { + s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExportMemoryAllocateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7184,6 +8686,17 @@ pub struct ImportMemoryWin32HandleInfoKHR { pub handle: HANDLE, pub name: LPCWSTR, } +impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR { + fn default() -> ImportMemoryWin32HandleInfoKHR { + ImportMemoryWin32HandleInfoKHR { + s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + handle_type: ExternalMemoryHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryWin32HandleInfoKHR { @@ -7193,6 +8706,17 @@ pub struct ExportMemoryWin32HandleInfoKHR { pub dw_access: DWORD, pub name: LPCWSTR, } +impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { + fn default() -> ExportMemoryWin32HandleInfoKHR { + ExportMemoryWin32HandleInfoKHR { + s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + p_attributes: unsafe { ::std::mem::zeroed() }, + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryWin32HandlePropertiesKHR { @@ -7200,6 +8724,15 @@ pub struct MemoryWin32HandlePropertiesKHR { pub p_next: *const c_void, pub memory_type_bits: uint32_t, } +impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { + fn default() -> MemoryWin32HandlePropertiesKHR { + MemoryWin32HandlePropertiesKHR { + s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + memory_type_bits: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryGetWin32HandleInfoKHR { @@ -7208,6 +8741,16 @@ pub struct MemoryGetWin32HandleInfoKHR { pub memory: DeviceMemory, pub handle_type: ExternalMemoryHandleTypeFlags, } +impl ::std::default::Default for MemoryGetWin32HandleInfoKHR { + fn default() -> MemoryGetWin32HandleInfoKHR { + MemoryGetWin32HandleInfoKHR { + s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryFdInfoKHR { @@ -7216,6 +8759,16 @@ pub struct ImportMemoryFdInfoKHR { pub handle_type: ExternalMemoryHandleTypeFlags, pub fd: c_int, } +impl ::std::default::Default for ImportMemoryFdInfoKHR { + fn default() -> ImportMemoryFdInfoKHR { + ImportMemoryFdInfoKHR { + s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + handle_type: ExternalMemoryHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryFdPropertiesKHR { @@ -7223,6 +8776,15 @@ pub struct MemoryFdPropertiesKHR { pub p_next: *const c_void, pub memory_type_bits: uint32_t, } +impl ::std::default::Default for MemoryFdPropertiesKHR { + fn default() -> MemoryFdPropertiesKHR { + MemoryFdPropertiesKHR { + s_type: StructureType::MEMORY_FD_PROPERTIES_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + memory_type_bits: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryGetFdInfoKHR { @@ -7231,6 +8793,16 @@ pub struct MemoryGetFdInfoKHR { pub memory: DeviceMemory, pub handle_type: ExternalMemoryHandleTypeFlags, } +impl ::std::default::Default for MemoryGetFdInfoKHR { + fn default() -> MemoryGetFdInfoKHR { + MemoryGetFdInfoKHR { + s_type: StructureType::MEMORY_GET_FD_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct Win32KeyedMutexAcquireReleaseInfoKHR { @@ -7244,6 +8816,21 @@ pub struct Win32KeyedMutexAcquireReleaseInfoKHR { pub p_release_syncs: *const DeviceMemory, pub p_release_keys: *const uint64_t, } +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { + fn default() -> Win32KeyedMutexAcquireReleaseInfoKHR { + Win32KeyedMutexAcquireReleaseInfoKHR { + s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + acquire_count: uint32_t::default(), + p_acquire_syncs: unsafe { ::std::mem::zeroed() }, + p_acquire_keys: unsafe { ::std::mem::zeroed() }, + p_acquire_timeouts: unsafe { ::std::mem::zeroed() }, + release_count: uint32_t::default(), + p_release_syncs: unsafe { ::std::mem::zeroed() }, + p_release_keys: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalSemaphoreInfo { @@ -7251,8 +8838,17 @@ pub struct PhysicalDeviceExternalSemaphoreInfo { pub p_next: *const c_void, pub handle_type: ExternalSemaphoreHandleTypeFlags, } +impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo { + fn default() -> PhysicalDeviceExternalSemaphoreInfo { + PhysicalDeviceExternalSemaphoreInfo { + s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceExternalSemaphoreInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7263,8 +8859,19 @@ pub struct ExternalSemaphoreProperties { pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags, pub external_semaphore_features: ExternalSemaphoreFeatureFlags, } +impl ::std::default::Default for ExternalSemaphoreProperties { + fn default() -> ExternalSemaphoreProperties { + ExternalSemaphoreProperties { + s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(), + compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(), + external_semaphore_features: ExternalSemaphoreFeatureFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalSemaphorePropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7273,8 +8880,17 @@ pub struct ExportSemaphoreCreateInfo { pub p_next: *const c_void, pub handle_types: ExternalSemaphoreHandleTypeFlags, } +impl ::std::default::Default for ExportSemaphoreCreateInfo { + fn default() -> ExportSemaphoreCreateInfo { + ExportSemaphoreCreateInfo { + s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_types: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExportSemaphoreCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7287,6 +8903,19 @@ pub struct ImportSemaphoreWin32HandleInfoKHR { pub handle: HANDLE, pub name: LPCWSTR, } +impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR { + fn default() -> ImportSemaphoreWin32HandleInfoKHR { + ImportSemaphoreWin32HandleInfoKHR { + s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportSemaphoreWin32HandleInfoKHR { @@ -7296,6 +8925,17 @@ pub struct ExportSemaphoreWin32HandleInfoKHR { pub dw_access: DWORD, pub name: LPCWSTR, } +impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { + fn default() -> ExportSemaphoreWin32HandleInfoKHR { + ExportSemaphoreWin32HandleInfoKHR { + s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + p_attributes: unsafe { ::std::mem::zeroed() }, + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct D3D12FenceSubmitInfoKHR { @@ -7306,6 +8946,18 @@ pub struct D3D12FenceSubmitInfoKHR { pub signal_semaphore_values_count: uint32_t, pub p_signal_semaphore_values: *const uint64_t, } +impl ::std::default::Default for D3D12FenceSubmitInfoKHR { + fn default() -> D3D12FenceSubmitInfoKHR { + D3D12FenceSubmitInfoKHR { + s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + wait_semaphore_values_count: uint32_t::default(), + p_wait_semaphore_values: unsafe { ::std::mem::zeroed() }, + signal_semaphore_values_count: uint32_t::default(), + p_signal_semaphore_values: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SemaphoreGetWin32HandleInfoKHR { @@ -7314,6 +8966,16 @@ pub struct SemaphoreGetWin32HandleInfoKHR { pub semaphore: Semaphore, pub handle_type: ExternalSemaphoreHandleTypeFlags, } +impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR { + fn default() -> SemaphoreGetWin32HandleInfoKHR { + SemaphoreGetWin32HandleInfoKHR { + s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportSemaphoreFdInfoKHR { @@ -7324,6 +8986,18 @@ pub struct ImportSemaphoreFdInfoKHR { pub handle_type: ExternalSemaphoreHandleTypeFlags, pub fd: c_int, } +impl ::std::default::Default for ImportSemaphoreFdInfoKHR { + fn default() -> ImportSemaphoreFdInfoKHR { + ImportSemaphoreFdInfoKHR { + s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SemaphoreGetFdInfoKHR { @@ -7332,6 +9006,16 @@ pub struct SemaphoreGetFdInfoKHR { pub semaphore: Semaphore, pub handle_type: ExternalSemaphoreHandleTypeFlags, } +impl ::std::default::Default for SemaphoreGetFdInfoKHR { + fn default() -> SemaphoreGetFdInfoKHR { + SemaphoreGetFdInfoKHR { + s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalFenceInfo { @@ -7339,8 +9023,17 @@ pub struct PhysicalDeviceExternalFenceInfo { pub p_next: *const c_void, pub handle_type: ExternalFenceHandleTypeFlags, } +impl ::std::default::Default for PhysicalDeviceExternalFenceInfo { + fn default() -> PhysicalDeviceExternalFenceInfo { + PhysicalDeviceExternalFenceInfo { + s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceExternalFenceInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7351,8 +9044,19 @@ pub struct ExternalFenceProperties { pub compatible_handle_types: ExternalFenceHandleTypeFlags, pub external_fence_features: ExternalFenceFeatureFlags, } +impl ::std::default::Default for ExternalFenceProperties { + fn default() -> ExternalFenceProperties { + ExternalFenceProperties { + s_type: StructureType::EXTERNAL_FENCE_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(), + compatible_handle_types: ExternalFenceHandleTypeFlags::default(), + external_fence_features: ExternalFenceFeatureFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExternalFencePropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7361,8 +9065,17 @@ pub struct ExportFenceCreateInfo { pub p_next: *const c_void, pub handle_types: ExternalFenceHandleTypeFlags, } +impl ::std::default::Default for ExportFenceCreateInfo { + fn default() -> ExportFenceCreateInfo { + ExportFenceCreateInfo { + s_type: StructureType::EXPORT_FENCE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + handle_types: ExternalFenceHandleTypeFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ExportFenceCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7375,6 +9088,19 @@ pub struct ImportFenceWin32HandleInfoKHR { pub handle: HANDLE, pub name: LPCWSTR, } +impl ::std::default::Default for ImportFenceWin32HandleInfoKHR { + fn default() -> ImportFenceWin32HandleInfoKHR { + ImportFenceWin32HandleInfoKHR { + s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + fence: Fence::default(), + flags: FenceImportFlags::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportFenceWin32HandleInfoKHR { @@ -7384,6 +9110,17 @@ pub struct ExportFenceWin32HandleInfoKHR { pub dw_access: DWORD, pub name: LPCWSTR, } +impl ::std::default::Default for ExportFenceWin32HandleInfoKHR { + fn default() -> ExportFenceWin32HandleInfoKHR { + ExportFenceWin32HandleInfoKHR { + s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + p_attributes: unsafe { ::std::mem::zeroed() }, + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FenceGetWin32HandleInfoKHR { @@ -7392,6 +9129,16 @@ pub struct FenceGetWin32HandleInfoKHR { pub fence: Fence, pub handle_type: ExternalFenceHandleTypeFlags, } +impl ::std::default::Default for FenceGetWin32HandleInfoKHR { + fn default() -> FenceGetWin32HandleInfoKHR { + FenceGetWin32HandleInfoKHR { + s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + fence: Fence::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportFenceFdInfoKHR { @@ -7402,6 +9149,18 @@ pub struct ImportFenceFdInfoKHR { pub handle_type: ExternalFenceHandleTypeFlags, pub fd: c_int, } +impl ::std::default::Default for ImportFenceFdInfoKHR { + fn default() -> ImportFenceFdInfoKHR { + ImportFenceFdInfoKHR { + s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + fence: Fence::default(), + flags: FenceImportFlags::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FenceGetFdInfoKHR { @@ -7410,6 +9169,16 @@ pub struct FenceGetFdInfoKHR { pub fence: Fence, pub handle_type: ExternalFenceHandleTypeFlags, } +impl ::std::default::Default for FenceGetFdInfoKHR { + fn default() -> FenceGetFdInfoKHR { + FenceGetFdInfoKHR { + s_type: StructureType::FENCE_GET_FD_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + fence: Fence::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewFeatures { @@ -7419,8 +9188,19 @@ pub struct PhysicalDeviceMultiviewFeatures { pub multiview_geometry_shader: Bool32, pub multiview_tessellation_shader: Bool32, } +impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { + fn default() -> PhysicalDeviceMultiviewFeatures { + PhysicalDeviceMultiviewFeatures { + s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + p_next: unsafe { ::std::mem::zeroed() }, + multiview: Bool32::default(), + multiview_geometry_shader: Bool32::default(), + multiview_tessellation_shader: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceMultiviewFeaturesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7430,8 +9210,18 @@ pub struct PhysicalDeviceMultiviewProperties { pub max_multiview_view_count: uint32_t, pub max_multiview_instance_index: uint32_t, } +impl ::std::default::Default for PhysicalDeviceMultiviewProperties { + fn default() -> PhysicalDeviceMultiviewProperties { + PhysicalDeviceMultiviewProperties { + s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + max_multiview_view_count: uint32_t::default(), + max_multiview_instance_index: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceMultiviewPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7445,8 +9235,22 @@ pub struct RenderPassMultiviewCreateInfo { pub correlation_mask_count: uint32_t, pub p_correlation_masks: *const uint32_t, } +impl ::std::default::Default for RenderPassMultiviewCreateInfo { + fn default() -> RenderPassMultiviewCreateInfo { + RenderPassMultiviewCreateInfo { + s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + subpass_count: uint32_t::default(), + p_view_masks: unsafe { ::std::mem::zeroed() }, + dependency_count: uint32_t::default(), + p_view_offsets: unsafe { ::std::mem::zeroed() }, + correlation_mask_count: uint32_t::default(), + p_correlation_masks: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct RenderPassMultiviewCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7465,6 +9269,25 @@ pub struct SurfaceCapabilities2EXT { pub supported_usage_flags: ImageUsageFlags, pub supported_surface_counters: SurfaceCounterFlagsEXT, } +impl ::std::default::Default for SurfaceCapabilities2EXT { + fn default() -> SurfaceCapabilities2EXT { + SurfaceCapabilities2EXT { + s_type: StructureType::SURFACE_CAPABILITIES_2_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + min_image_count: uint32_t::default(), + max_image_count: uint32_t::default(), + current_extent: Extent2D::default(), + min_image_extent: Extent2D::default(), + max_image_extent: Extent2D::default(), + max_image_array_layers: uint32_t::default(), + supported_transforms: SurfaceTransformFlagsKHR::default(), + current_transform: SurfaceTransformFlagsKHR::default(), + supported_composite_alpha: CompositeAlphaFlagsKHR::default(), + supported_usage_flags: ImageUsageFlags::default(), + supported_surface_counters: SurfaceCounterFlagsEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPowerInfoEXT { @@ -7472,6 +9295,15 @@ pub struct DisplayPowerInfoEXT { pub p_next: *const c_void, pub power_state: DisplayPowerStateEXT, } +impl ::std::default::Default for DisplayPowerInfoEXT { + fn default() -> DisplayPowerInfoEXT { + DisplayPowerInfoEXT { + s_type: StructureType::DISPLAY_POWER_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + power_state: DisplayPowerStateEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceEventInfoEXT { @@ -7479,6 +9311,15 @@ pub struct DeviceEventInfoEXT { pub p_next: *const c_void, pub device_event: DeviceEventTypeEXT, } +impl ::std::default::Default for DeviceEventInfoEXT { + fn default() -> DeviceEventInfoEXT { + DeviceEventInfoEXT { + s_type: StructureType::DEVICE_EVENT_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + device_event: DeviceEventTypeEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayEventInfoEXT { @@ -7486,6 +9327,15 @@ pub struct DisplayEventInfoEXT { pub p_next: *const c_void, pub display_event: DisplayEventTypeEXT, } +impl ::std::default::Default for DisplayEventInfoEXT { + fn default() -> DisplayEventInfoEXT { + DisplayEventInfoEXT { + s_type: StructureType::DISPLAY_EVENT_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + display_event: DisplayEventTypeEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SwapchainCounterCreateInfoEXT { @@ -7493,6 +9343,15 @@ pub struct SwapchainCounterCreateInfoEXT { pub p_next: *const c_void, pub surface_counters: SurfaceCounterFlagsEXT, } +impl ::std::default::Default for SwapchainCounterCreateInfoEXT { + fn default() -> SwapchainCounterCreateInfoEXT { + SwapchainCounterCreateInfoEXT { + s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + surface_counters: SurfaceCounterFlagsEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct PhysicalDeviceGroupProperties { @@ -7515,8 +9374,19 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .finish() } } +impl ::std::default::Default for PhysicalDeviceGroupProperties { + fn default() -> PhysicalDeviceGroupProperties { + PhysicalDeviceGroupProperties { + s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + physical_device_count: uint32_t::default(), + physical_devices: unsafe { ::std::mem::zeroed() }, + subset_allocation: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceGroupPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7526,8 +9396,18 @@ pub struct MemoryAllocateFlagsInfo { pub flags: MemoryAllocateFlags, pub device_mask: uint32_t, } +impl ::std::default::Default for MemoryAllocateFlagsInfo { + fn default() -> MemoryAllocateFlagsInfo { + MemoryAllocateFlagsInfo { + s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: MemoryAllocateFlags::default(), + device_mask: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct MemoryAllocateFlagsInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7538,8 +9418,19 @@ pub struct BindBufferMemoryInfo { pub memory: DeviceMemory, pub memory_offset: DeviceSize, } +impl ::std::default::Default for BindBufferMemoryInfo { + fn default() -> BindBufferMemoryInfo { + BindBufferMemoryInfo { + s_type: StructureType::BIND_BUFFER_MEMORY_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + buffer: Buffer::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BindBufferMemoryInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7549,8 +9440,18 @@ pub struct BindBufferMemoryDeviceGroupInfo { pub device_index_count: uint32_t, pub p_device_indices: *const uint32_t, } +impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { + fn default() -> BindBufferMemoryDeviceGroupInfo { + BindBufferMemoryDeviceGroupInfo { + s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + device_index_count: uint32_t::default(), + p_device_indices: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BindBufferMemoryDeviceGroupInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7561,8 +9462,19 @@ pub struct BindImageMemoryInfo { pub memory: DeviceMemory, pub memory_offset: DeviceSize, } +impl ::std::default::Default for BindImageMemoryInfo { + fn default() -> BindImageMemoryInfo { + BindImageMemoryInfo { + s_type: StructureType::BIND_IMAGE_MEMORY_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + image: Image::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BindImageMemoryInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7574,8 +9486,20 @@ pub struct BindImageMemoryDeviceGroupInfo { pub split_instance_bind_region_count: uint32_t, pub p_split_instance_bind_regions: *const Rect2D, } +impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { + fn default() -> BindImageMemoryDeviceGroupInfo { + BindImageMemoryDeviceGroupInfo { + s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + device_index_count: uint32_t::default(), + p_device_indices: unsafe { ::std::mem::zeroed() }, + split_instance_bind_region_count: uint32_t::default(), + p_split_instance_bind_regions: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BindImageMemoryDeviceGroupInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7586,8 +9510,19 @@ pub struct DeviceGroupRenderPassBeginInfo { pub device_render_area_count: uint32_t, pub p_device_render_areas: *const Rect2D, } +impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { + fn default() -> DeviceGroupRenderPassBeginInfo { + DeviceGroupRenderPassBeginInfo { + s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + device_mask: uint32_t::default(), + device_render_area_count: uint32_t::default(), + p_device_render_areas: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DeviceGroupRenderPassBeginInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7596,8 +9531,17 @@ pub struct DeviceGroupCommandBufferBeginInfo { pub p_next: *const c_void, pub device_mask: uint32_t, } +impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { + fn default() -> DeviceGroupCommandBufferBeginInfo { + DeviceGroupCommandBufferBeginInfo { + s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + device_mask: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DeviceGroupCommandBufferBeginInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7611,8 +9555,22 @@ pub struct DeviceGroupSubmitInfo { pub signal_semaphore_count: uint32_t, pub p_signal_semaphore_device_indices: *const uint32_t, } +impl ::std::default::Default for DeviceGroupSubmitInfo { + fn default() -> DeviceGroupSubmitInfo { + DeviceGroupSubmitInfo { + s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + wait_semaphore_count: uint32_t::default(), + p_wait_semaphore_device_indices: unsafe { ::std::mem::zeroed() }, + command_buffer_count: uint32_t::default(), + p_command_buffer_device_masks: unsafe { ::std::mem::zeroed() }, + signal_semaphore_count: uint32_t::default(), + p_signal_semaphore_device_indices: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DeviceGroupSubmitInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7622,8 +9580,18 @@ pub struct DeviceGroupBindSparseInfo { pub resource_device_index: uint32_t, pub memory_device_index: uint32_t, } +impl ::std::default::Default for DeviceGroupBindSparseInfo { + fn default() -> DeviceGroupBindSparseInfo { + DeviceGroupBindSparseInfo { + s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + resource_device_index: uint32_t::default(), + memory_device_index: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DeviceGroupBindSparseInfoKHR {} #[repr(C)] #[derive(Copy, Clone)] @@ -7645,6 +9613,16 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .finish() } } +impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { + fn default() -> DeviceGroupPresentCapabilitiesKHR { + DeviceGroupPresentCapabilitiesKHR { + s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + present_mask: unsafe { ::std::mem::zeroed() }, + modes: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageSwapchainCreateInfoKHR { @@ -7652,6 +9630,15 @@ pub struct ImageSwapchainCreateInfoKHR { pub p_next: *const c_void, pub swapchain: SwapchainKHR, } +impl ::std::default::Default for ImageSwapchainCreateInfoKHR { + fn default() -> ImageSwapchainCreateInfoKHR { + ImageSwapchainCreateInfoKHR { + s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + swapchain: SwapchainKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImageMemorySwapchainInfoKHR { @@ -7660,6 +9647,16 @@ pub struct BindImageMemorySwapchainInfoKHR { pub swapchain: SwapchainKHR, pub image_index: uint32_t, } +impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { + fn default() -> BindImageMemorySwapchainInfoKHR { + BindImageMemorySwapchainInfoKHR { + s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + swapchain: SwapchainKHR::default(), + image_index: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AcquireNextImageInfoKHR { @@ -7671,6 +9668,19 @@ pub struct AcquireNextImageInfoKHR { pub fence: Fence, pub device_mask: uint32_t, } +impl ::std::default::Default for AcquireNextImageInfoKHR { + fn default() -> AcquireNextImageInfoKHR { + AcquireNextImageInfoKHR { + s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + swapchain: SwapchainKHR::default(), + timeout: uint64_t::default(), + semaphore: Semaphore::default(), + fence: Fence::default(), + device_mask: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupPresentInfoKHR { @@ -7680,6 +9690,17 @@ pub struct DeviceGroupPresentInfoKHR { pub p_device_masks: *const uint32_t, pub mode: DeviceGroupPresentModeFlagsKHR, } +impl ::std::default::Default for DeviceGroupPresentInfoKHR { + fn default() -> DeviceGroupPresentInfoKHR { + DeviceGroupPresentInfoKHR { + s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + swapchain_count: uint32_t::default(), + p_device_masks: unsafe { ::std::mem::zeroed() }, + mode: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupDeviceCreateInfo { @@ -7688,8 +9709,18 @@ pub struct DeviceGroupDeviceCreateInfo { pub physical_device_count: uint32_t, pub p_physical_devices: *const PhysicalDevice, } +impl ::std::default::Default for DeviceGroupDeviceCreateInfo { + fn default() -> DeviceGroupDeviceCreateInfo { + DeviceGroupDeviceCreateInfo { + s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + physical_device_count: uint32_t::default(), + p_physical_devices: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DeviceGroupDeviceCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7698,8 +9729,17 @@ pub struct DeviceGroupSwapchainCreateInfoKHR { pub p_next: *const c_void, pub modes: DeviceGroupPresentModeFlagsKHR, } +impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR { + fn default() -> DeviceGroupSwapchainCreateInfoKHR { + DeviceGroupSwapchainCreateInfoKHR { + s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + modes: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DescriptorUpdateTemplateEntry { pub dst_binding: uint32_t, pub dst_array_element: uint32_t, @@ -7709,7 +9749,7 @@ pub struct DescriptorUpdateTemplateEntry { pub stride: size_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DescriptorUpdateTemplateEntryKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7725,11 +9765,27 @@ pub struct DescriptorUpdateTemplateCreateInfo { pub pipeline_layout: PipelineLayout, pub set: uint32_t, } +impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { + fn default() -> DescriptorUpdateTemplateCreateInfo { + DescriptorUpdateTemplateCreateInfo { + s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DescriptorUpdateTemplateCreateFlags::default(), + descriptor_update_entry_count: uint32_t::default(), + p_descriptor_update_entries: unsafe { ::std::mem::zeroed() }, + template_type: DescriptorUpdateTemplateType::default(), + descriptor_set_layout: DescriptorSetLayout::default(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline_layout: PipelineLayout::default(), + set: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DescriptorUpdateTemplateCreateInfoKHR {} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct XYColorEXT { pub x: c_float, pub y: c_float, @@ -7748,13 +9804,29 @@ pub struct HdrMetadataEXT { pub max_content_light_level: c_float, pub max_frame_average_light_level: c_float, } +impl ::std::default::Default for HdrMetadataEXT { + fn default() -> HdrMetadataEXT { + HdrMetadataEXT { + s_type: StructureType::HDR_METADATA_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + display_primary_red: XYColorEXT::default(), + display_primary_green: XYColorEXT::default(), + display_primary_blue: XYColorEXT::default(), + white_point: XYColorEXT::default(), + max_luminance: c_float::default(), + min_luminance: c_float::default(), + max_content_light_level: c_float::default(), + max_frame_average_light_level: c_float::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct RefreshCycleDurationGOOGLE { pub refresh_duration: uint64_t, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PastPresentationTimingGOOGLE { pub present_id: uint32_t, pub desired_present_time: uint64_t, @@ -7770,8 +9842,18 @@ pub struct PresentTimesInfoGOOGLE { pub swapchain_count: uint32_t, pub p_times: *const PresentTimeGOOGLE, } +impl ::std::default::Default for PresentTimesInfoGOOGLE { + fn default() -> PresentTimesInfoGOOGLE { + PresentTimesInfoGOOGLE { + s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE, + p_next: unsafe { ::std::mem::zeroed() }, + swapchain_count: uint32_t::default(), + p_times: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PresentTimeGOOGLE { pub present_id: uint32_t, pub desired_present_time: uint64_t, @@ -7784,6 +9866,16 @@ pub struct IOSSurfaceCreateInfoMVK { pub flags: IOSSurfaceCreateFlagsMVK, pub p_view: *const c_void, } +impl ::std::default::Default for IOSSurfaceCreateInfoMVK { + fn default() -> IOSSurfaceCreateInfoMVK { + IOSSurfaceCreateInfoMVK { + s_type: StructureType::IOS_SURFACE_CREATE_INFO_M, + p_next: unsafe { ::std::mem::zeroed() }, + flags: IOSSurfaceCreateFlagsMVK::default(), + p_view: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MacOSSurfaceCreateInfoMVK { @@ -7792,8 +9884,18 @@ pub struct MacOSSurfaceCreateInfoMVK { pub flags: MacOSSurfaceCreateFlagsMVK, pub p_view: *const c_void, } +impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { + fn default() -> MacOSSurfaceCreateInfoMVK { + MacOSSurfaceCreateInfoMVK { + s_type: StructureType::MACOS_SURFACE_CREATE_INFO_M, + p_next: unsafe { ::std::mem::zeroed() }, + flags: MacOSSurfaceCreateFlagsMVK::default(), + p_view: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ViewportWScalingNV { pub xcoeff: c_float, pub ycoeff: c_float, @@ -7807,8 +9909,19 @@ pub struct PipelineViewportWScalingStateCreateInfoNV { pub viewport_count: uint32_t, pub p_viewport_w_scalings: *const ViewportWScalingNV, } +impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { + fn default() -> PipelineViewportWScalingStateCreateInfoNV { + PipelineViewportWScalingStateCreateInfoNV { + s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + viewport_w_scaling_enable: Bool32::default(), + viewport_count: uint32_t::default(), + p_viewport_w_scalings: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ViewportSwizzleNV { pub x: ViewportCoordinateSwizzleNV, pub y: ViewportCoordinateSwizzleNV, @@ -7824,6 +9937,17 @@ pub struct PipelineViewportSwizzleStateCreateInfoNV { pub viewport_count: uint32_t, pub p_viewport_swizzles: *const ViewportSwizzleNV, } +impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { + fn default() -> PipelineViewportSwizzleStateCreateInfoNV { + PipelineViewportSwizzleStateCreateInfoNV { + s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineViewportSwizzleStateCreateFlagsNV::default(), + viewport_count: uint32_t::default(), + p_viewport_swizzles: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { @@ -7831,6 +9955,15 @@ pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { pub p_next: *const c_void, pub max_discard_rectangles: uint32_t, } +impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { + fn default() -> PhysicalDeviceDiscardRectanglePropertiesEXT { + PhysicalDeviceDiscardRectanglePropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + max_discard_rectangles: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineDiscardRectangleStateCreateInfoEXT { @@ -7841,6 +9974,18 @@ pub struct PipelineDiscardRectangleStateCreateInfoEXT { pub discard_rectangle_count: uint32_t, pub p_discard_rectangles: *const Rect2D, } +impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { + fn default() -> PipelineDiscardRectangleStateCreateInfoEXT { + PipelineDiscardRectangleStateCreateInfoEXT { + s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(), + discard_rectangle_mode: DiscardRectangleModeEXT::default(), + discard_rectangle_count: uint32_t::default(), + p_discard_rectangles: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { @@ -7848,15 +9993,24 @@ pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { pub p_next: *const c_void, pub per_view_position_all_components: Bool32, } +impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + fn default() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, + p_next: unsafe { ::std::mem::zeroed() }, + per_view_position_all_components: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct InputAttachmentAspectReference { pub subpass: uint32_t, pub input_attachment_index: uint32_t, pub aspect_mask: ImageAspectFlags, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct InputAttachmentAspectReferenceKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7866,8 +10020,18 @@ pub struct RenderPassInputAttachmentAspectCreateInfo { pub aspect_reference_count: uint32_t, pub p_aspect_references: *const InputAttachmentAspectReference, } +impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { + fn default() -> RenderPassInputAttachmentAspectCreateInfo { + RenderPassInputAttachmentAspectCreateInfo { + s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + aspect_reference_count: uint32_t::default(), + p_aspect_references: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct RenderPassInputAttachmentAspectCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7876,6 +10040,15 @@ pub struct PhysicalDeviceSurfaceInfo2KHR { pub p_next: *const c_void, pub surface: SurfaceKHR, } +impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR { + fn default() -> PhysicalDeviceSurfaceInfo2KHR { + PhysicalDeviceSurfaceInfo2KHR { + s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + surface: SurfaceKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2KHR { @@ -7883,6 +10056,15 @@ pub struct SurfaceCapabilities2KHR { pub p_next: *const c_void, pub surface_capabilities: SurfaceCapabilitiesKHR, } +impl ::std::default::Default for SurfaceCapabilities2KHR { + fn default() -> SurfaceCapabilities2KHR { + SurfaceCapabilities2KHR { + s_type: StructureType::SURFACE_CAPABILITIES_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + surface_capabilities: SurfaceCapabilitiesKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SurfaceFormat2KHR { @@ -7890,6 +10072,15 @@ pub struct SurfaceFormat2KHR { pub p_next: *const c_void, pub surface_format: SurfaceFormatKHR, } +impl ::std::default::Default for SurfaceFormat2KHR { + fn default() -> SurfaceFormat2KHR { + SurfaceFormat2KHR { + s_type: StructureType::SURFACE_FORMAT_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + surface_format: SurfaceFormatKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayProperties2KHR { @@ -7897,6 +10088,15 @@ pub struct DisplayProperties2KHR { pub p_next: *const c_void, pub display_properties: DisplayPropertiesKHR, } +impl ::std::default::Default for DisplayProperties2KHR { + fn default() -> DisplayProperties2KHR { + DisplayProperties2KHR { + s_type: StructureType::DISPLAY_PROPERTIES_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + display_properties: DisplayPropertiesKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneProperties2KHR { @@ -7904,6 +10104,15 @@ pub struct DisplayPlaneProperties2KHR { pub p_next: *const c_void, pub display_plane_properties: DisplayPlanePropertiesKHR, } +impl ::std::default::Default for DisplayPlaneProperties2KHR { + fn default() -> DisplayPlaneProperties2KHR { + DisplayPlaneProperties2KHR { + s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + display_plane_properties: DisplayPlanePropertiesKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayModeProperties2KHR { @@ -7911,6 +10120,15 @@ pub struct DisplayModeProperties2KHR { pub p_next: *const c_void, pub display_mode_properties: DisplayModePropertiesKHR, } +impl ::std::default::Default for DisplayModeProperties2KHR { + fn default() -> DisplayModeProperties2KHR { + DisplayModeProperties2KHR { + s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + display_mode_properties: DisplayModePropertiesKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneInfo2KHR { @@ -7919,6 +10137,16 @@ pub struct DisplayPlaneInfo2KHR { pub mode: DisplayModeKHR, pub plane_index: uint32_t, } +impl ::std::default::Default for DisplayPlaneInfo2KHR { + fn default() -> DisplayPlaneInfo2KHR { + DisplayPlaneInfo2KHR { + s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + mode: DisplayModeKHR::default(), + plane_index: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneCapabilities2KHR { @@ -7926,6 +10154,15 @@ pub struct DisplayPlaneCapabilities2KHR { pub p_next: *const c_void, pub capabilities: DisplayPlaneCapabilitiesKHR, } +impl ::std::default::Default for DisplayPlaneCapabilities2KHR { + fn default() -> DisplayPlaneCapabilities2KHR { + DisplayPlaneCapabilities2KHR { + s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + capabilities: DisplayPlaneCapabilitiesKHR::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SharedPresentSurfaceCapabilitiesKHR { @@ -7933,6 +10170,15 @@ pub struct SharedPresentSurfaceCapabilitiesKHR { pub p_next: *const c_void, pub shared_present_supported_usage_flags: ImageUsageFlags, } +impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { + fn default() -> SharedPresentSurfaceCapabilitiesKHR { + SharedPresentSurfaceCapabilitiesKHR { + s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + shared_present_supported_usage_flags: ImageUsageFlags::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDevice16BitStorageFeatures { @@ -7943,8 +10189,20 @@ pub struct PhysicalDevice16BitStorageFeatures { pub storage_push_constant16: Bool32, pub storage_input_output16: Bool32, } +impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { + fn default() -> PhysicalDevice16BitStorageFeatures { + PhysicalDevice16BitStorageFeatures { + s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + p_next: unsafe { ::std::mem::zeroed() }, + storage_buffer16_bit_access: Bool32::default(), + uniform_and_storage_buffer16_bit_access: Bool32::default(), + storage_push_constant16: Bool32::default(), + storage_input_output16: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDevice16BitStorageFeaturesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7956,6 +10214,18 @@ pub struct PhysicalDeviceSubgroupProperties { pub supported_operations: SubgroupFeatureFlags, pub quad_operations_in_all_stages: Bool32, } +impl ::std::default::Default for PhysicalDeviceSubgroupProperties { + fn default() -> PhysicalDeviceSubgroupProperties { + PhysicalDeviceSubgroupProperties { + s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + subgroup_size: uint32_t::default(), + supported_stages: ShaderStageFlags::default(), + supported_operations: SubgroupFeatureFlags::default(), + quad_operations_in_all_stages: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferMemoryRequirementsInfo2 { @@ -7963,8 +10233,17 @@ pub struct BufferMemoryRequirementsInfo2 { pub p_next: *const c_void, pub buffer: Buffer, } +impl ::std::default::Default for BufferMemoryRequirementsInfo2 { + fn default() -> BufferMemoryRequirementsInfo2 { + BufferMemoryRequirementsInfo2 { + s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2, + p_next: unsafe { ::std::mem::zeroed() }, + buffer: Buffer::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BufferMemoryRequirementsInfo2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7973,8 +10252,17 @@ pub struct ImageMemoryRequirementsInfo2 { pub p_next: *const c_void, pub image: Image, } +impl ::std::default::Default for ImageMemoryRequirementsInfo2 { + fn default() -> ImageMemoryRequirementsInfo2 { + ImageMemoryRequirementsInfo2 { + s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2, + p_next: unsafe { ::std::mem::zeroed() }, + image: Image::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageMemoryRequirementsInfo2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7983,8 +10271,17 @@ pub struct ImageSparseMemoryRequirementsInfo2 { pub p_next: *const c_void, pub image: Image, } +impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 { + fn default() -> ImageSparseMemoryRequirementsInfo2 { + ImageSparseMemoryRequirementsInfo2 { + s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + p_next: unsafe { ::std::mem::zeroed() }, + image: Image::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageSparseMemoryRequirementsInfo2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -7993,8 +10290,17 @@ pub struct MemoryRequirements2 { pub p_next: *const c_void, pub memory_requirements: MemoryRequirements, } +impl ::std::default::Default for MemoryRequirements2 { + fn default() -> MemoryRequirements2 { + MemoryRequirements2 { + s_type: StructureType::MEMORY_REQUIREMENTS_2, + p_next: unsafe { ::std::mem::zeroed() }, + memory_requirements: MemoryRequirements::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct MemoryRequirements2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8003,8 +10309,17 @@ pub struct SparseImageMemoryRequirements2 { pub p_next: *const c_void, pub memory_requirements: SparseImageMemoryRequirements, } +impl ::std::default::Default for SparseImageMemoryRequirements2 { + fn default() -> SparseImageMemoryRequirements2 { + SparseImageMemoryRequirements2 { + s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + p_next: unsafe { ::std::mem::zeroed() }, + memory_requirements: SparseImageMemoryRequirements::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SparseImageMemoryRequirements2KHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8013,8 +10328,17 @@ pub struct PhysicalDevicePointClippingProperties { pub p_next: *const c_void, pub point_clipping_behavior: PointClippingBehavior, } +impl ::std::default::Default for PhysicalDevicePointClippingProperties { + fn default() -> PhysicalDevicePointClippingProperties { + PhysicalDevicePointClippingProperties { + s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + point_clipping_behavior: PointClippingBehavior::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDevicePointClippingPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8024,8 +10348,18 @@ pub struct MemoryDedicatedRequirements { pub prefers_dedicated_allocation: Bool32, pub requires_dedicated_allocation: Bool32, } +impl ::std::default::Default for MemoryDedicatedRequirements { + fn default() -> MemoryDedicatedRequirements { + MemoryDedicatedRequirements { + s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS, + p_next: unsafe { ::std::mem::zeroed() }, + prefers_dedicated_allocation: Bool32::default(), + requires_dedicated_allocation: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct MemoryDedicatedRequirementsKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8035,8 +10369,18 @@ pub struct MemoryDedicatedAllocateInfo { pub image: Image, pub buffer: Buffer, } +impl ::std::default::Default for MemoryDedicatedAllocateInfo { + fn default() -> MemoryDedicatedAllocateInfo { + MemoryDedicatedAllocateInfo { + s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + image: Image::default(), + buffer: Buffer::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct MemoryDedicatedAllocateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8045,8 +10389,17 @@ pub struct ImageViewUsageCreateInfo { pub p_next: *const c_void, pub usage: ImageUsageFlags, } +impl ::std::default::Default for ImageViewUsageCreateInfo { + fn default() -> ImageViewUsageCreateInfo { + ImageViewUsageCreateInfo { + s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + usage: ImageUsageFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImageViewUsageCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8055,8 +10408,17 @@ pub struct PipelineTessellationDomainOriginStateCreateInfo { pub p_next: *const c_void, pub domain_origin: TessellationDomainOrigin, } +impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo { + fn default() -> PipelineTessellationDomainOriginStateCreateInfo { + PipelineTessellationDomainOriginStateCreateInfo { + s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + domain_origin: TessellationDomainOrigin::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PipelineTessellationDomainOriginStateCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8065,8 +10427,17 @@ pub struct SamplerYcbcrConversionInfo { pub p_next: *const c_void, pub conversion: SamplerYcbcrConversion, } +impl ::std::default::Default for SamplerYcbcrConversionInfo { + fn default() -> SamplerYcbcrConversionInfo { + SamplerYcbcrConversionInfo { + s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + conversion: SamplerYcbcrConversion::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SamplerYcbcrConversionInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8082,8 +10453,24 @@ pub struct SamplerYcbcrConversionCreateInfo { pub chroma_filter: Filter, pub force_explicit_reconstruction: Bool32, } +impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { + fn default() -> SamplerYcbcrConversionCreateInfo { + SamplerYcbcrConversionCreateInfo { + s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + format: Format::default(), + ycbcr_model: SamplerYcbcrModelConversion::default(), + ycbcr_range: SamplerYcbcrRange::default(), + components: ComponentMapping::default(), + x_chroma_offset: ChromaLocation::default(), + y_chroma_offset: ChromaLocation::default(), + chroma_filter: Filter::default(), + force_explicit_reconstruction: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SamplerYcbcrConversionCreateInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8092,8 +10479,17 @@ pub struct BindImagePlaneMemoryInfo { pub p_next: *const c_void, pub plane_aspect: ImageAspectFlags, } +impl ::std::default::Default for BindImagePlaneMemoryInfo { + fn default() -> BindImagePlaneMemoryInfo { + BindImagePlaneMemoryInfo { + s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + plane_aspect: ImageAspectFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct BindImagePlaneMemoryInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8102,8 +10498,17 @@ pub struct ImagePlaneMemoryRequirementsInfo { pub p_next: *const c_void, pub plane_aspect: ImageAspectFlags, } +impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo { + fn default() -> ImagePlaneMemoryRequirementsInfo { + ImagePlaneMemoryRequirementsInfo { + s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + plane_aspect: ImageAspectFlags::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ImagePlaneMemoryRequirementsInfoKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8112,8 +10517,17 @@ pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { pub p_next: *const c_void, pub sampler_ycbcr_conversion: Bool32, } +impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { + fn default() -> PhysicalDeviceSamplerYcbcrConversionFeatures { + PhysicalDeviceSamplerYcbcrConversionFeatures { + s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + p_next: unsafe { ::std::mem::zeroed() }, + sampler_ycbcr_conversion: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8122,8 +10536,17 @@ pub struct SamplerYcbcrConversionImageFormatProperties { pub p_next: *const c_void, pub combined_image_sampler_descriptor_count: uint32_t, } +impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { + fn default() -> SamplerYcbcrConversionImageFormatProperties { + SamplerYcbcrConversionImageFormatProperties { + s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + combined_image_sampler_descriptor_count: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SamplerYcbcrConversionImageFormatPropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8132,6 +10555,15 @@ pub struct TextureLODGatherFormatPropertiesAMD { pub p_next: *const c_void, pub supports_texture_gather_lod_bias_amd: Bool32, } +impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD { + fn default() -> TextureLODGatherFormatPropertiesAMD { + TextureLODGatherFormatPropertiesAMD { + s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, + p_next: unsafe { ::std::mem::zeroed() }, + supports_texture_gather_lod_bias_amd: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ProtectedSubmitInfo { @@ -8139,6 +10571,15 @@ pub struct ProtectedSubmitInfo { pub p_next: *const c_void, pub protected_submit: Bool32, } +impl ::std::default::Default for ProtectedSubmitInfo { + fn default() -> ProtectedSubmitInfo { + ProtectedSubmitInfo { + s_type: StructureType::PROTECTED_SUBMIT_INFO, + p_next: unsafe { ::std::mem::zeroed() }, + protected_submit: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryFeatures { @@ -8146,6 +10587,15 @@ pub struct PhysicalDeviceProtectedMemoryFeatures { pub p_next: *const c_void, pub protected_memory: Bool32, } +impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { + fn default() -> PhysicalDeviceProtectedMemoryFeatures { + PhysicalDeviceProtectedMemoryFeatures { + s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, + p_next: unsafe { ::std::mem::zeroed() }, + protected_memory: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryProperties { @@ -8153,6 +10603,15 @@ pub struct PhysicalDeviceProtectedMemoryProperties { pub p_next: *const c_void, pub protected_no_fault: Bool32, } +impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties { + fn default() -> PhysicalDeviceProtectedMemoryProperties { + PhysicalDeviceProtectedMemoryProperties { + s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + protected_no_fault: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceQueueInfo2 { @@ -8162,6 +10621,17 @@ pub struct DeviceQueueInfo2 { pub queue_family_index: uint32_t, pub queue_index: uint32_t, } +impl ::std::default::Default for DeviceQueueInfo2 { + fn default() -> DeviceQueueInfo2 { + DeviceQueueInfo2 { + s_type: StructureType::DEVICE_QUEUE_INFO_2, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DeviceQueueCreateFlags::default(), + queue_family_index: uint32_t::default(), + queue_index: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineCoverageToColorStateCreateInfoNV { @@ -8171,6 +10641,17 @@ pub struct PipelineCoverageToColorStateCreateInfoNV { pub coverage_to_color_enable: Bool32, pub coverage_to_color_location: uint32_t, } +impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { + fn default() -> PipelineCoverageToColorStateCreateInfoNV { + PipelineCoverageToColorStateCreateInfoNV { + s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineCoverageToColorStateCreateFlagsNV::default(), + coverage_to_color_enable: Bool32::default(), + coverage_to_color_location: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { @@ -8179,8 +10660,18 @@ pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { pub filter_minmax_single_component_formats: Bool32, pub filter_minmax_image_component_mapping: Bool32, } +impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + fn default() -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + filter_minmax_single_component_formats: Bool32::default(), + filter_minmax_image_component_mapping: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SampleLocationEXT { pub x: c_float, pub y: c_float, @@ -8195,14 +10686,26 @@ pub struct SampleLocationsInfoEXT { pub sample_locations_count: uint32_t, pub p_sample_locations: *const SampleLocationEXT, } +impl ::std::default::Default for SampleLocationsInfoEXT { + fn default() -> SampleLocationsInfoEXT { + SampleLocationsInfoEXT { + s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + sample_locations_per_pixel: SampleCountFlags::default(), + sample_location_grid_size: Extent2D::default(), + sample_locations_count: uint32_t::default(), + p_sample_locations: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct AttachmentSampleLocationsEXT { pub attachment_index: uint32_t, pub sample_locations_info: SampleLocationsInfoEXT, } #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct SubpassSampleLocationsEXT { pub subpass_index: uint32_t, pub sample_locations_info: SampleLocationsInfoEXT, @@ -8217,6 +10720,18 @@ pub struct RenderPassSampleLocationsBeginInfoEXT { pub post_subpass_sample_locations_count: uint32_t, pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT, } +impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { + fn default() -> RenderPassSampleLocationsBeginInfoEXT { + RenderPassSampleLocationsBeginInfoEXT { + s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + attachment_initial_sample_locations_count: uint32_t::default(), + p_attachment_initial_sample_locations: unsafe { ::std::mem::zeroed() }, + post_subpass_sample_locations_count: uint32_t::default(), + p_post_subpass_sample_locations: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineSampleLocationsStateCreateInfoEXT { @@ -8225,6 +10740,16 @@ pub struct PipelineSampleLocationsStateCreateInfoEXT { pub sample_locations_enable: Bool32, pub sample_locations_info: SampleLocationsInfoEXT, } +impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { + fn default() -> PipelineSampleLocationsStateCreateInfoEXT { + PipelineSampleLocationsStateCreateInfoEXT { + s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + sample_locations_enable: Bool32::default(), + sample_locations_info: SampleLocationsInfoEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct PhysicalDeviceSampleLocationsPropertiesEXT { @@ -8262,6 +10787,19 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .finish() } } +impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { + fn default() -> PhysicalDeviceSampleLocationsPropertiesEXT { + PhysicalDeviceSampleLocationsPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + sample_location_sample_counts: SampleCountFlags::default(), + max_sample_location_grid_size: Extent2D::default(), + sample_location_coordinate_range: unsafe { ::std::mem::zeroed() }, + sample_location_sub_pixel_bits: uint32_t::default(), + variable_sample_locations: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MultisamplePropertiesEXT { @@ -8269,6 +10807,15 @@ pub struct MultisamplePropertiesEXT { pub p_next: *const c_void, pub max_sample_location_grid_size: Extent2D, } +impl ::std::default::Default for MultisamplePropertiesEXT { + fn default() -> MultisamplePropertiesEXT { + MultisamplePropertiesEXT { + s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + max_sample_location_grid_size: Extent2D::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerReductionModeCreateInfoEXT { @@ -8276,6 +10823,15 @@ pub struct SamplerReductionModeCreateInfoEXT { pub p_next: *const c_void, pub reduction_mode: SamplerReductionModeEXT, } +impl ::std::default::Default for SamplerReductionModeCreateInfoEXT { + fn default() -> SamplerReductionModeCreateInfoEXT { + SamplerReductionModeCreateInfoEXT { + s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + reduction_mode: SamplerReductionModeEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { @@ -8283,6 +10839,15 @@ pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { pub p_next: *const c_void, pub advanced_blend_coherent_operations: Bool32, } +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + fn default() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + advanced_blend_coherent_operations: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { @@ -8295,6 +10860,20 @@ pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { pub advanced_blend_correlated_overlap: Bool32, pub advanced_blend_all_operations: Bool32, } +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + fn default() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + advanced_blend_max_color_attachments: uint32_t::default(), + advanced_blend_independent_blend: Bool32::default(), + advanced_blend_non_premultiplied_src_color: Bool32::default(), + advanced_blend_non_premultiplied_dst_color: Bool32::default(), + advanced_blend_correlated_overlap: Bool32::default(), + advanced_blend_all_operations: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { @@ -8304,6 +10883,17 @@ pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { pub dst_premultiplied: Bool32, pub blend_overlap: BlendOverlapEXT, } +impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT { + fn default() -> PipelineColorBlendAdvancedStateCreateInfoEXT { + PipelineColorBlendAdvancedStateCreateInfoEXT { + s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + src_premultiplied: Bool32::default(), + dst_premultiplied: Bool32::default(), + blend_overlap: BlendOverlapEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineCoverageModulationStateCreateInfoNV { @@ -8315,6 +10905,19 @@ pub struct PipelineCoverageModulationStateCreateInfoNV { pub coverage_modulation_table_count: uint32_t, pub p_coverage_modulation_table: *const c_float, } +impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { + fn default() -> PipelineCoverageModulationStateCreateInfoNV { + PipelineCoverageModulationStateCreateInfoNV { + s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineCoverageModulationStateCreateFlagsNV::default(), + coverage_modulation_mode: CoverageModulationModeNV::default(), + coverage_modulation_table_enable: Bool32::default(), + coverage_modulation_table_count: uint32_t::default(), + p_coverage_modulation_table: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageFormatListCreateInfoKHR { @@ -8323,6 +10926,16 @@ pub struct ImageFormatListCreateInfoKHR { pub view_format_count: uint32_t, pub p_view_formats: *const Format, } +impl ::std::default::Default for ImageFormatListCreateInfoKHR { + fn default() -> ImageFormatListCreateInfoKHR { + ImageFormatListCreateInfoKHR { + s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO_KHR, + p_next: unsafe { ::std::mem::zeroed() }, + view_format_count: uint32_t::default(), + p_view_formats: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ValidationCacheCreateInfoEXT { @@ -8332,6 +10945,17 @@ pub struct ValidationCacheCreateInfoEXT { pub initial_data_size: size_t, pub p_initial_data: *const c_void, } +impl ::std::default::Default for ValidationCacheCreateInfoEXT { + fn default() -> ValidationCacheCreateInfoEXT { + ValidationCacheCreateInfoEXT { + s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + flags: ValidationCacheCreateFlagsEXT::default(), + initial_data_size: size_t::default(), + p_initial_data: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ShaderModuleValidationCacheCreateInfoEXT { @@ -8339,6 +10963,15 @@ pub struct ShaderModuleValidationCacheCreateInfoEXT { pub p_next: *const c_void, pub validation_cache: ValidationCacheEXT, } +impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { + fn default() -> ShaderModuleValidationCacheCreateInfoEXT { + ShaderModuleValidationCacheCreateInfoEXT { + s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + validation_cache: ValidationCacheEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMaintenance3Properties { @@ -8347,8 +10980,18 @@ pub struct PhysicalDeviceMaintenance3Properties { pub max_per_set_descriptors: uint32_t, pub max_memory_allocation_size: DeviceSize, } +impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { + fn default() -> PhysicalDeviceMaintenance3Properties { + PhysicalDeviceMaintenance3Properties { + s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + p_next: unsafe { ::std::mem::zeroed() }, + max_per_set_descriptors: uint32_t::default(), + max_memory_allocation_size: DeviceSize::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceMaintenance3PropertiesKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8357,8 +11000,17 @@ pub struct DescriptorSetLayoutSupport { pub p_next: *const c_void, pub supported: Bool32, } +impl ::std::default::Default for DescriptorSetLayoutSupport { + fn default() -> DescriptorSetLayoutSupport { + DescriptorSetLayoutSupport { + s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT, + p_next: unsafe { ::std::mem::zeroed() }, + supported: Bool32::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct DescriptorSetLayoutSupportKHR {} #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8367,6 +11019,15 @@ pub struct PhysicalDeviceShaderDrawParameterFeatures { pub p_next: *const c_void, pub shader_draw_parameters: Bool32, } +impl ::std::default::Default for PhysicalDeviceShaderDrawParameterFeatures { + fn default() -> PhysicalDeviceShaderDrawParameterFeatures { + PhysicalDeviceShaderDrawParameterFeatures { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, + p_next: unsafe { ::std::mem::zeroed() }, + shader_draw_parameters: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct NativeBufferANDROID { @@ -8377,8 +11038,20 @@ pub struct NativeBufferANDROID { pub format: c_int, pub usage: c_int, } +impl ::std::default::Default for NativeBufferANDROID { + fn default() -> NativeBufferANDROID { + NativeBufferANDROID { + s_type: StructureType::NATIVE_BUFFER_ANDROID, + p_next: unsafe { ::std::mem::zeroed() }, + handle: unsafe { ::std::mem::zeroed() }, + stride: c_int::default(), + format: c_int::default(), + usage: c_int::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct ShaderResourceUsageAMD { pub num_used_vgprs: uint32_t, pub num_used_sgprs: uint32_t, @@ -8412,6 +11085,19 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .finish() } } +impl ::std::default::Default for ShaderStatisticsInfoAMD { + fn default() -> ShaderStatisticsInfoAMD { + ShaderStatisticsInfoAMD { + shader_stage_mask: ShaderStageFlags::default(), + resource_usage: ShaderResourceUsageAMD::default(), + num_physical_vgprs: uint32_t::default(), + num_physical_sgprs: uint32_t::default(), + num_available_vgprs: uint32_t::default(), + num_available_sgprs: uint32_t::default(), + compute_work_group_size: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceQueueGlobalPriorityCreateInfoEXT { @@ -8419,6 +11105,15 @@ pub struct DeviceQueueGlobalPriorityCreateInfoEXT { pub p_next: *const c_void, pub global_priority: QueueGlobalPriorityEXT, } +impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoEXT { + fn default() -> DeviceQueueGlobalPriorityCreateInfoEXT { + DeviceQueueGlobalPriorityCreateInfoEXT { + s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + global_priority: QueueGlobalPriorityEXT::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugUtilsObjectNameInfoEXT { @@ -8428,6 +11123,17 @@ pub struct DebugUtilsObjectNameInfoEXT { pub object_handle: uint64_t, pub p_object_name: *const c_char, } +impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { + fn default() -> DebugUtilsObjectNameInfoEXT { + DebugUtilsObjectNameInfoEXT { + s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + object_type: ObjectType::default(), + object_handle: uint64_t::default(), + p_object_name: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugUtilsObjectTagInfoEXT { @@ -8439,6 +11145,19 @@ pub struct DebugUtilsObjectTagInfoEXT { pub tag_size: size_t, pub p_tag: *const c_void, } +impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { + fn default() -> DebugUtilsObjectTagInfoEXT { + DebugUtilsObjectTagInfoEXT { + s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + object_type: ObjectType::default(), + object_handle: uint64_t::default(), + tag_name: uint64_t::default(), + tag_size: size_t::default(), + p_tag: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct DebugUtilsLabelEXT { @@ -8459,6 +11178,16 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .finish() } } +impl ::std::default::Default for DebugUtilsLabelEXT { + fn default() -> DebugUtilsLabelEXT { + DebugUtilsLabelEXT { + s_type: StructureType::DEBUG_UTILS_LABEL_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + p_label_name: unsafe { ::std::mem::zeroed() }, + color: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct DebugUtilsMessengerCreateInfoEXT { @@ -8483,6 +11212,19 @@ impl ::std::fmt::Debug for DebugUtilsMessengerCreateInfoEXT { .finish() } } +impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { + fn default() -> DebugUtilsMessengerCreateInfoEXT { + DebugUtilsMessengerCreateInfoEXT { + s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DebugUtilsMessengerCreateFlagsEXT::default(), + message_severity: DebugUtilsMessageSeverityFlagsEXT::default(), + message_type: DebugUtilsMessageTypeFlagsEXT::default(), + pfn_user_callback: unsafe { ::std::mem::zeroed() }, + p_user_data: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugUtilsMessengerCallbackDataEXT { @@ -8499,6 +11241,24 @@ pub struct DebugUtilsMessengerCallbackDataEXT { pub object_count: uint32_t, pub p_objects: *const DebugUtilsObjectNameInfoEXT, } +impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { + fn default() -> DebugUtilsMessengerCallbackDataEXT { + DebugUtilsMessengerCallbackDataEXT { + s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(), + p_message_id_name: unsafe { ::std::mem::zeroed() }, + message_id_number: int32_t::default(), + p_message: unsafe { ::std::mem::zeroed() }, + queue_label_count: uint32_t::default(), + p_queue_labels: unsafe { ::std::mem::zeroed() }, + cmd_buf_label_count: uint32_t::default(), + p_cmd_buf_labels: unsafe { ::std::mem::zeroed() }, + object_count: uint32_t::default(), + p_objects: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryHostPointerInfoEXT { @@ -8507,6 +11267,16 @@ pub struct ImportMemoryHostPointerInfoEXT { pub handle_type: ExternalMemoryHandleTypeFlags, pub p_host_pointer: *const c_void, } +impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { + fn default() -> ImportMemoryHostPointerInfoEXT { + ImportMemoryHostPointerInfoEXT { + s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + handle_type: ExternalMemoryHandleTypeFlags::default(), + p_host_pointer: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryHostPointerPropertiesEXT { @@ -8514,6 +11284,15 @@ pub struct MemoryHostPointerPropertiesEXT { pub p_next: *const c_void, pub memory_type_bits: uint32_t, } +impl ::std::default::Default for MemoryHostPointerPropertiesEXT { + fn default() -> MemoryHostPointerPropertiesEXT { + MemoryHostPointerPropertiesEXT { + s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + memory_type_bits: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { @@ -8521,6 +11300,15 @@ pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { pub p_next: *const c_void, pub min_imported_host_pointer_alignment: DeviceSize, } +impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { + fn default() -> PhysicalDeviceExternalMemoryHostPropertiesEXT { + PhysicalDeviceExternalMemoryHostPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + min_imported_host_pointer_alignment: DeviceSize::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { @@ -8536,6 +11324,23 @@ pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { pub fully_covered_fragment_shader_input_variable: Bool32, pub conservative_rasterization_post_depth_coverage: Bool32, } +impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT { + fn default() -> PhysicalDeviceConservativeRasterizationPropertiesEXT { + PhysicalDeviceConservativeRasterizationPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + primitive_overestimation_size: c_float::default(), + max_extra_primitive_overestimation_size: c_float::default(), + extra_primitive_overestimation_size_granularity: c_float::default(), + primitive_underestimation: Bool32::default(), + conservative_point_and_line_rasterization: Bool32::default(), + degenerate_triangles_rasterized: Bool32::default(), + degenerate_lines_rasterized: Bool32::default(), + fully_covered_fragment_shader_input_variable: Bool32::default(), + conservative_rasterization_post_depth_coverage: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderCorePropertiesAMD { @@ -8556,6 +11361,28 @@ pub struct PhysicalDeviceShaderCorePropertiesAMD { pub max_vgpr_allocation: uint32_t, pub vgpr_allocation_granularity: uint32_t, } +impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { + fn default() -> PhysicalDeviceShaderCorePropertiesAMD { + PhysicalDeviceShaderCorePropertiesAMD { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, + p_next: unsafe { ::std::mem::zeroed() }, + shader_engine_count: uint32_t::default(), + shader_arrays_per_engine_count: uint32_t::default(), + compute_units_per_shader_array: uint32_t::default(), + simd_per_compute_unit: uint32_t::default(), + wavefronts_per_simd: uint32_t::default(), + wavefront_size: uint32_t::default(), + sgprs_per_simd: uint32_t::default(), + min_sgpr_allocation: uint32_t::default(), + max_sgpr_allocation: uint32_t::default(), + sgpr_allocation_granularity: uint32_t::default(), + vgprs_per_simd: uint32_t::default(), + min_vgpr_allocation: uint32_t::default(), + max_vgpr_allocation: uint32_t::default(), + vgpr_allocation_granularity: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationConservativeStateCreateInfoEXT { @@ -8565,6 +11392,17 @@ pub struct PipelineRasterizationConservativeStateCreateInfoEXT { pub conservative_rasterization_mode: ConservativeRasterizationModeEXT, pub extra_primitive_overestimation_size: c_float, } +impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT { + fn default() -> PipelineRasterizationConservativeStateCreateInfoEXT { + PipelineRasterizationConservativeStateCreateInfoEXT { + s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(), + conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(), + extra_primitive_overestimation_size: c_float::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingFeaturesEXT { @@ -8591,6 +11429,34 @@ pub struct PhysicalDeviceDescriptorIndexingFeaturesEXT { pub descriptor_binding_variable_descriptor_count: Bool32, pub runtime_descriptor_array: Bool32, } +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeaturesEXT { + fn default() -> PhysicalDeviceDescriptorIndexingFeaturesEXT { + PhysicalDeviceDescriptorIndexingFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + shader_input_attachment_array_dynamic_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_image_array_non_uniform_indexing: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(), + descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(), + descriptor_binding_sampled_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_buffer_update_after_bind: Bool32::default(), + descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_update_unused_while_pending: Bool32::default(), + descriptor_binding_partially_bound: Bool32::default(), + descriptor_binding_variable_descriptor_count: Bool32::default(), + runtime_descriptor_array: Bool32::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { @@ -8620,6 +11486,37 @@ pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { pub max_descriptor_set_update_after_bind_storage_images: uint32_t, pub max_descriptor_set_update_after_bind_input_attachments: uint32_t, } +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingPropertiesEXT { + fn default() -> PhysicalDeviceDescriptorIndexingPropertiesEXT { + PhysicalDeviceDescriptorIndexingPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + max_update_after_bind_descriptors_in_all_pools: uint32_t::default(), + shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_image_array_non_uniform_indexing_native: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(), + robust_buffer_access_update_after_bind: Bool32::default(), + quad_divergent_implicit_lod: Bool32::default(), + max_per_stage_descriptor_update_after_bind_samplers: uint32_t::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: uint32_t::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: uint32_t::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: uint32_t::default(), + max_per_stage_descriptor_update_after_bind_storage_images: uint32_t::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: uint32_t::default(), + max_per_stage_update_after_bind_resources: uint32_t::default(), + max_descriptor_set_update_after_bind_samplers: uint32_t::default(), + max_descriptor_set_update_after_bind_uniform_buffers: uint32_t::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: uint32_t::default(), + max_descriptor_set_update_after_bind_storage_buffers: uint32_t::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: uint32_t::default(), + max_descriptor_set_update_after_bind_sampled_images: uint32_t::default(), + max_descriptor_set_update_after_bind_storage_images: uint32_t::default(), + max_descriptor_set_update_after_bind_input_attachments: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { @@ -8628,6 +11525,16 @@ pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { pub binding_count: uint32_t, pub p_binding_flags: *const DescriptorBindingFlagsEXT, } +impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfoEXT { + fn default() -> DescriptorSetLayoutBindingFlagsCreateInfoEXT { + DescriptorSetLayoutBindingFlagsCreateInfoEXT { + s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + binding_count: uint32_t::default(), + p_binding_flags: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { @@ -8636,6 +11543,16 @@ pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { pub descriptor_set_count: uint32_t, pub p_descriptor_counts: *const uint32_t, } +impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfoEXT { + fn default() -> DescriptorSetVariableDescriptorCountAllocateInfoEXT { + DescriptorSetVariableDescriptorCountAllocateInfoEXT { + s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + descriptor_set_count: uint32_t::default(), + p_descriptor_counts: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { @@ -8643,8 +11560,17 @@ pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { pub p_next: *const c_void, pub max_variable_descriptor_count: uint32_t, } +impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupportEXT { + fn default() -> DescriptorSetVariableDescriptorCountLayoutSupportEXT { + DescriptorSetVariableDescriptorCountLayoutSupportEXT { + s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + max_variable_descriptor_count: uint32_t::default(), + } + } +} #[repr(C)] -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Default, Debug)] pub struct VertexInputBindingDivisorDescriptionEXT { pub binding: uint32_t, pub divisor: uint32_t, @@ -8657,6 +11583,16 @@ pub struct PipelineVertexInputDivisorStateCreateInfoEXT { pub vertex_binding_divisor_count: uint32_t, pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT, } +impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { + fn default() -> PipelineVertexInputDivisorStateCreateInfoEXT { + PipelineVertexInputDivisorStateCreateInfoEXT { + s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + vertex_binding_divisor_count: uint32_t::default(), + p_vertex_binding_divisors: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { @@ -8664,6 +11600,15 @@ pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { pub p_next: *const c_void, pub max_vertex_attrib_divisor: uint32_t, } +impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + fn default() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, + p_next: unsafe { ::std::mem::zeroed() }, + max_vertex_attrib_divisor: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportAndroidHardwareBufferInfoANDROID { @@ -8671,6 +11616,15 @@ pub struct ImportAndroidHardwareBufferInfoANDROID { pub p_next: *const c_void, pub buffer: *const AHardwareBuffer, } +impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { + fn default() -> ImportAndroidHardwareBufferInfoANDROID { + ImportAndroidHardwareBufferInfoANDROID { + s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + p_next: unsafe { ::std::mem::zeroed() }, + buffer: unsafe { ::std::mem::zeroed() }, + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferUsageANDROID { @@ -8678,6 +11632,15 @@ pub struct AndroidHardwareBufferUsageANDROID { pub p_next: *const c_void, pub android_hardware_buffer_usage: uint64_t, } +impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { + fn default() -> AndroidHardwareBufferUsageANDROID { + AndroidHardwareBufferUsageANDROID { + s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, + p_next: unsafe { ::std::mem::zeroed() }, + android_hardware_buffer_usage: uint64_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferPropertiesANDROID { @@ -8686,6 +11649,16 @@ pub struct AndroidHardwareBufferPropertiesANDROID { pub allocation_size: DeviceSize, pub memory_type_bits: uint32_t, } +impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { + fn default() -> AndroidHardwareBufferPropertiesANDROID { + AndroidHardwareBufferPropertiesANDROID { + s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, + p_next: unsafe { ::std::mem::zeroed() }, + allocation_size: DeviceSize::default(), + memory_type_bits: uint32_t::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryGetAndroidHardwareBufferInfoANDROID { @@ -8693,6 +11666,15 @@ pub struct MemoryGetAndroidHardwareBufferInfoANDROID { pub p_next: *const c_void, pub memory: DeviceMemory, } +impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID { + fn default() -> MemoryGetAndroidHardwareBufferInfoANDROID { + MemoryGetAndroidHardwareBufferInfoANDROID { + s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + p_next: unsafe { ::std::mem::zeroed() }, + memory: DeviceMemory::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferFormatPropertiesANDROID { @@ -8707,6 +11689,22 @@ pub struct AndroidHardwareBufferFormatPropertiesANDROID { pub suggested_x_chroma_offset: ChromaLocation, pub suggested_y_chroma_offset: ChromaLocation, } +impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { + fn default() -> AndroidHardwareBufferFormatPropertiesANDROID { + AndroidHardwareBufferFormatPropertiesANDROID { + s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, + p_next: unsafe { ::std::mem::zeroed() }, + format: Format::default(), + external_format: uint64_t::default(), + format_features: FormatFeatureFlags::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + } + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalFormatANDROID { @@ -8714,7 +11712,16 @@ pub struct ExternalFormatANDROID { pub p_next: *const c_void, pub external_format: uint64_t, } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +impl ::std::default::Default for ExternalFormatANDROID { + fn default() -> ExternalFormatANDROID { + ExternalFormatANDROID { + s_type: StructureType::EXTERNAL_FORMAT_ANDROID, + p_next: unsafe { ::std::mem::zeroed() }, + external_format: uint64_t::default(), + } + } +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ImageLayout(pub(crate) i32); impl ImageLayout { @@ -8737,7 +11744,7 @@ impl ImageLayout { #[doc = "Initial layout used when the data is populated by the CPU"] pub const PREINITIALIZED: Self = ImageLayout(8); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct AttachmentLoadOp(pub(crate) i32); impl AttachmentLoadOp { @@ -8745,14 +11752,14 @@ impl AttachmentLoadOp { pub const CLEAR: Self = AttachmentLoadOp(1); pub const DONT_CARE: Self = AttachmentLoadOp(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct AttachmentStoreOp(pub(crate) i32); impl AttachmentStoreOp { pub const STORE: Self = AttachmentStoreOp(0); pub const DONT_CARE: Self = AttachmentStoreOp(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ImageType(pub(crate) i32); impl ImageType { @@ -8760,14 +11767,14 @@ impl ImageType { pub const TYPE_2D: Self = ImageType(1); pub const TYPE_3D: Self = ImageType(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ImageTiling(pub(crate) i32); impl ImageTiling { pub const OPTIMAL: Self = ImageTiling(0); pub const LINEAR: Self = ImageTiling(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ImageViewType(pub(crate) i32); impl ImageViewType { @@ -8779,14 +11786,14 @@ impl ImageViewType { pub const TYPE_2D_ARRAY: Self = ImageViewType(5); pub const CUBE_ARRAY: Self = ImageViewType(6); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct CommandBufferLevel(pub(crate) i32); impl CommandBufferLevel { pub const PRIMARY: Self = CommandBufferLevel(0); pub const SECONDARY: Self = CommandBufferLevel(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ComponentSwizzle(pub(crate) i32); impl ComponentSwizzle { @@ -8798,7 +11805,7 @@ impl ComponentSwizzle { pub const B: Self = ComponentSwizzle(5); pub const A: Self = ComponentSwizzle(6); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DescriptorType(pub(crate) i32); impl DescriptorType { @@ -8814,7 +11821,7 @@ impl DescriptorType { pub const STORAGE_BUFFER_DYNAMIC: Self = DescriptorType(9); pub const INPUT_ATTACHMENT: Self = DescriptorType(10); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct QueryType(pub(crate) i32); impl QueryType { @@ -8823,7 +11830,7 @@ impl QueryType { pub const PIPELINE_STATISTICS: Self = QueryType(1); pub const TIMESTAMP: Self = QueryType(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct BorderColor(pub(crate) i32); impl BorderColor { @@ -8834,20 +11841,20 @@ impl BorderColor { pub const FLOAT_OPAQUE_WHITE: Self = BorderColor(4); pub const INT_OPAQUE_WHITE: Self = BorderColor(5); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct PipelineBindPoint(pub(crate) i32); impl PipelineBindPoint { pub const GRAPHICS: Self = PipelineBindPoint(0); pub const COMPUTE: Self = PipelineBindPoint(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct PipelineCacheHeaderVersion(pub(crate) i32); impl PipelineCacheHeaderVersion { pub const ONE: Self = PipelineCacheHeaderVersion(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct PrimitiveTopology(pub(crate) i32); impl PrimitiveTopology { @@ -8863,28 +11870,28 @@ impl PrimitiveTopology { pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = PrimitiveTopology(9); pub const PATCH_LIST: Self = PrimitiveTopology(10); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SharingMode(pub(crate) i32); impl SharingMode { pub const EXCLUSIVE: Self = SharingMode(0); pub const CONCURRENT: Self = SharingMode(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct IndexType(pub(crate) i32); impl IndexType { pub const UINT16: Self = IndexType(0); pub const UINT32: Self = IndexType(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct Filter(pub(crate) i32); impl Filter { pub const NEAREST: Self = Filter(0); pub const LINEAR: Self = Filter(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SamplerMipmapMode(pub(crate) i32); impl SamplerMipmapMode { @@ -8893,7 +11900,7 @@ impl SamplerMipmapMode { #[doc = "Linear filter between mip levels"] pub const LINEAR: Self = SamplerMipmapMode(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SamplerAddressMode(pub(crate) i32); impl SamplerAddressMode { @@ -8902,7 +11909,7 @@ impl SamplerAddressMode { pub const CLAMP_TO_EDGE: Self = SamplerAddressMode(2); pub const CLAMP_TO_BORDER: Self = SamplerAddressMode(3); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct CompareOp(pub(crate) i32); impl CompareOp { @@ -8915,7 +11922,7 @@ impl CompareOp { pub const GREATER_OR_EQUAL: Self = CompareOp(6); pub const ALWAYS: Self = CompareOp(7); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct PolygonMode(pub(crate) i32); impl PolygonMode { @@ -8923,14 +11930,14 @@ impl PolygonMode { pub const LINE: Self = PolygonMode(1); pub const POINT: Self = PolygonMode(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct FrontFace(pub(crate) i32); impl FrontFace { pub const COUNTER_CLOCKWISE: Self = FrontFace(0); pub const CLOCKWISE: Self = FrontFace(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct BlendFactor(pub(crate) i32); impl BlendFactor { @@ -8954,7 +11961,7 @@ impl BlendFactor { pub const SRC1_ALPHA: Self = BlendFactor(17); pub const ONE_MINUS_SRC1_ALPHA: Self = BlendFactor(18); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct BlendOp(pub(crate) i32); impl BlendOp { @@ -8964,7 +11971,7 @@ impl BlendOp { pub const MIN: Self = BlendOp(3); pub const MAX: Self = BlendOp(4); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct StencilOp(pub(crate) i32); impl StencilOp { @@ -8977,7 +11984,7 @@ impl StencilOp { pub const INCREMENT_AND_WRAP: Self = StencilOp(6); pub const DECREMENT_AND_WRAP: Self = StencilOp(7); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct LogicOp(pub(crate) i32); impl LogicOp { @@ -8998,13 +12005,13 @@ impl LogicOp { pub const NAND: Self = LogicOp(14); pub const SET: Self = LogicOp(15); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct InternalAllocationType(pub(crate) i32); impl InternalAllocationType { pub const EXECUTABLE: Self = InternalAllocationType(0); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SystemAllocationScope(pub(crate) i32); impl SystemAllocationScope { @@ -9014,7 +12021,7 @@ impl SystemAllocationScope { pub const DEVICE: Self = SystemAllocationScope(3); pub const INSTANCE: Self = SystemAllocationScope(4); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct PhysicalDeviceType(pub(crate) i32); impl PhysicalDeviceType { @@ -9024,14 +12031,14 @@ impl PhysicalDeviceType { pub const VIRTUAL_GPU: Self = PhysicalDeviceType(3); pub const CPU: Self = PhysicalDeviceType(4); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct VertexInputRate(pub(crate) i32); impl VertexInputRate { pub const VERTEX: Self = VertexInputRate(0); pub const INSTANCE: Self = VertexInputRate(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct Format(pub(crate) i32); impl Format { @@ -9221,7 +12228,7 @@ impl Format { pub const ASTC_12X12_UNORM_BLOCK: Self = Format(183); pub const ASTC_12X12_SRGB_BLOCK: Self = Format(184); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct StructureType(pub(crate) i32); impl StructureType { @@ -9277,14 +12284,14 @@ impl StructureType { #[doc = "Reserved for internal use by the loader, layers, and ICDs"] pub const LOADER_DEVICE_CREATE_INFO: Self = StructureType(48); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SubpassContents(pub(crate) i32); impl SubpassContents { pub const INLINE: Self = SubpassContents(0); pub const SECONDARY_COMMAND_BUFFERS: Self = SubpassContents(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct Result(pub(crate) i32); impl Result { @@ -9378,7 +12385,7 @@ impl ::std::fmt::Display for Result { } } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DynamicState(pub(crate) i32); impl DynamicState { @@ -9392,14 +12399,14 @@ impl DynamicState { pub const STENCIL_WRITE_MASK: Self = DynamicState(7); pub const STENCIL_REFERENCE: Self = DynamicState(8); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DescriptorUpdateTemplateType(pub(crate) i32); impl DescriptorUpdateTemplateType { #[doc = "Create descriptor update template for descriptor set updates"] pub const DESCRIPTOR_SET: Self = DescriptorUpdateTemplateType(0); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ObjectType(pub(crate) i32); impl ObjectType { @@ -9455,7 +12462,7 @@ impl ObjectType { #[doc = "VkCommandPool"] pub const COMMAND_POOL: Self = ObjectType(25); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct PresentModeKHR(pub(crate) i32); impl PresentModeKHR { @@ -9464,13 +12471,13 @@ impl PresentModeKHR { pub const PRESENT_MODE_FIFO_KHR: Self = PresentModeKHR(2); pub const PRESENT_MODE_FIFO_RELAXED_KHR: Self = PresentModeKHR(3); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ColorSpaceKHR(pub(crate) i32); impl ColorSpaceKHR { pub const COLOR_SPACE_SRGB_NONLINEAR_KHR: Self = ColorSpaceKHR(0); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DebugReportObjectTypeEXT(pub(crate) i32); impl DebugReportObjectTypeEXT { @@ -9513,21 +12520,21 @@ impl DebugReportObjectTypeEXT { pub const DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: Self = DebugReportObjectTypeEXT(33); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct RasterizationOrderAMD(pub(crate) i32); impl RasterizationOrderAMD { pub const RASTERIZATION_ORDER_STRICT_AMD: Self = RasterizationOrderAMD(0); pub const RASTERIZATION_ORDER_RELAXED_AMD: Self = RasterizationOrderAMD(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ValidationCheckEXT(pub(crate) i32); impl ValidationCheckEXT { pub const VALIDATION_CHECK_ALL_EXT: Self = ValidationCheckEXT(0); pub const VALIDATION_CHECK_SHADERS_EXT: Self = ValidationCheckEXT(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct IndirectCommandsTokenTypeNVX(pub(crate) i32); impl IndirectCommandsTokenTypeNVX { @@ -9543,7 +12550,7 @@ impl IndirectCommandsTokenTypeNVX { pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX: Self = IndirectCommandsTokenTypeNVX(6); pub const INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX: Self = IndirectCommandsTokenTypeNVX(7); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ObjectEntryTypeNVX(pub(crate) i32); impl ObjectEntryTypeNVX { @@ -9553,7 +12560,7 @@ impl ObjectEntryTypeNVX { pub const OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(3); pub const OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX: Self = ObjectEntryTypeNVX(4); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DisplayPowerStateEXT(pub(crate) i32); impl DisplayPowerStateEXT { @@ -9561,19 +12568,19 @@ impl DisplayPowerStateEXT { pub const DISPLAY_POWER_STATE_SUSPEND_EXT: Self = DisplayPowerStateEXT(1); pub const DISPLAY_POWER_STATE_ON_EXT: Self = DisplayPowerStateEXT(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DeviceEventTypeEXT(pub(crate) i32); impl DeviceEventTypeEXT { pub const DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: Self = DeviceEventTypeEXT(0); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DisplayEventTypeEXT(pub(crate) i32); impl DisplayEventTypeEXT { pub const DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: Self = DisplayEventTypeEXT(0); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); impl ViewportCoordinateSwizzleNV { @@ -9586,21 +12593,21 @@ impl ViewportCoordinateSwizzleNV { pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: Self = ViewportCoordinateSwizzleNV(6); pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: Self = ViewportCoordinateSwizzleNV(7); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DiscardRectangleModeEXT(pub(crate) i32); impl DiscardRectangleModeEXT { pub const DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: Self = DiscardRectangleModeEXT(0); pub const DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: Self = DiscardRectangleModeEXT(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct PointClippingBehavior(pub(crate) i32); impl PointClippingBehavior { pub const ALL_CLIP_PLANES: Self = PointClippingBehavior(0); pub const USER_CLIP_PLANES_ONLY: Self = PointClippingBehavior(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SamplerReductionModeEXT(pub(crate) i32); impl SamplerReductionModeEXT { @@ -9608,14 +12615,14 @@ impl SamplerReductionModeEXT { pub const SAMPLER_REDUCTION_MODE_MIN_EXT: Self = SamplerReductionModeEXT(1); pub const SAMPLER_REDUCTION_MODE_MAX_EXT: Self = SamplerReductionModeEXT(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct TessellationDomainOrigin(pub(crate) i32); impl TessellationDomainOrigin { pub const UPPER_LEFT: Self = TessellationDomainOrigin(0); pub const LOWER_LEFT: Self = TessellationDomainOrigin(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SamplerYcbcrModelConversion(pub(crate) i32); impl SamplerYcbcrModelConversion { @@ -9629,7 +12636,7 @@ impl SamplerYcbcrModelConversion { #[doc = "aka UHD YUV"] pub const YCBCR_2020: Self = SamplerYcbcrModelConversion(4); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct SamplerYcbcrRange(pub(crate) i32); impl SamplerYcbcrRange { @@ -9638,14 +12645,14 @@ impl SamplerYcbcrRange { #[doc = "Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240"] pub const ITU_NARROW: Self = SamplerYcbcrRange(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ChromaLocation(pub(crate) i32); impl ChromaLocation { pub const COSITED_EVEN: Self = ChromaLocation(0); pub const MIDPOINT: Self = ChromaLocation(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct BlendOverlapEXT(pub(crate) i32); impl BlendOverlapEXT { @@ -9653,7 +12660,7 @@ impl BlendOverlapEXT { pub const BLEND_OVERLAP_DISJOINT_EXT: Self = BlendOverlapEXT(1); pub const BLEND_OVERLAP_CONJOINT_EXT: Self = BlendOverlapEXT(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct CoverageModulationModeNV(pub(crate) i32); impl CoverageModulationModeNV { @@ -9662,13 +12669,13 @@ impl CoverageModulationModeNV { pub const COVERAGE_MODULATION_MODE_ALPHA_NV: Self = CoverageModulationModeNV(2); pub const COVERAGE_MODULATION_MODE_RGBA_NV: Self = CoverageModulationModeNV(3); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); impl ValidationCacheHeaderVersionEXT { pub const VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: Self = ValidationCacheHeaderVersionEXT(1); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ShaderInfoTypeAMD(pub(crate) i32); impl ShaderInfoTypeAMD { @@ -9676,7 +12683,7 @@ impl ShaderInfoTypeAMD { pub const SHADER_INFO_TYPE_BINARY_AMD: Self = ShaderInfoTypeAMD(1); pub const SHADER_INFO_TYPE_DISASSEMBLY_AMD: Self = ShaderInfoTypeAMD(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct QueueGlobalPriorityEXT(pub(crate) i32); impl QueueGlobalPriorityEXT { @@ -9685,7 +12692,7 @@ impl QueueGlobalPriorityEXT { pub const QUEUE_GLOBAL_PRIORITY_HIGH_EXT: Self = QueueGlobalPriorityEXT(512); pub const QUEUE_GLOBAL_PRIORITY_REALTIME_EXT: Self = QueueGlobalPriorityEXT(1024); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ConservativeRasterizationModeEXT(pub(crate) i32); impl ConservativeRasterizationModeEXT { @@ -9696,7 +12703,7 @@ impl ConservativeRasterizationModeEXT { pub const CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: Self = ConservativeRasterizationModeEXT(2); } -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct VendorId(pub(crate) i32); impl VendorId { @@ -11695,6 +14702,120 @@ pub mod extensions { impl StructureType { pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000009000); } + pub struct AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: extern "system" fn( + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *const c_int, + ) -> Result, + acquire_image_android: extern "system" fn( + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, + ) -> Result, + queue_signal_release_image_android: extern "system" fn( + queue: Queue, + wait_semaphore_count: uint32_t, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *const c_int, + ) -> Result, + } + unsafe impl Send for AndroidNativeBufferFn {} + unsafe impl Sync for AndroidNativeBufferFn {} + impl ::std::clone::Clone for AndroidNativeBufferFn { + fn clone(&self) -> Self { + AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: self.get_swapchain_gralloc_usage_android, + acquire_image_android: self.acquire_image_android, + queue_signal_release_image_android: self.queue_signal_release_image_android, + } + } + } + impl AndroidNativeBufferFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: unsafe { + let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_image_android: unsafe { + let raw_name = stringify!(vkAcquireImageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_signal_release_image_android: unsafe { + let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_swapchain_gralloc_usage_android( + &self, + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *const c_int, + ) -> Result { + (self.get_swapchain_gralloc_usage_android)(device, format, image_usage, gralloc_usage) + } + pub unsafe fn acquire_image_android( + &self, + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, + ) -> Result { + (self.acquire_image_android)(device, image, native_fence_fd, semaphore, fence) + } + pub unsafe fn queue_signal_release_image_android( + &self, + queue: Queue, + wait_semaphore_count: uint32_t, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *const c_int, + ) -> Result { + (self.queue_signal_release_image_android)( + queue, + wait_semaphore_count, + p_wait_semaphores, + image, + p_native_fence_fd, + ) + } + } + #[doc = "Generated from \'VK_ANDROID_native_buffer\'"] + impl StructureType { + pub const NATIVE_BUFFER_ANDROID: Self = StructureType(1000010000); + } pub struct ExtDebugReportFn { create_debug_report_callback_ext: extern "system" fn( @@ -11939,6 +15060,50 @@ pub mod extensions { impl FormatFeatureFlags { pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = FormatFeatureFlags(0b10000000000000); } + pub struct AmdExtension17Fn {} + unsafe impl Send for AmdExtension17Fn {} + unsafe impl Sync for AmdExtension17Fn {} + impl ::std::clone::Clone for AmdExtension17Fn { + fn clone(&self) -> Self { + AmdExtension17Fn {} + } + } + impl AmdExtension17Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension17Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension18Fn {} + unsafe impl Send for AmdExtension18Fn {} + unsafe impl Sync for AmdExtension18Fn {} + impl ::std::clone::Clone for AmdExtension18Fn { + fn clone(&self) -> Self { + AmdExtension18Fn {} + } + } + impl AmdExtension18Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension18Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdRasterizationOrderFn {} unsafe impl Send for AmdRasterizationOrderFn {} unsafe impl Sync for AmdRasterizationOrderFn {} @@ -11966,6 +15131,28 @@ pub mod extensions { pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = StructureType(1000018000); } + pub struct AmdExtension20Fn {} + unsafe impl Send for AmdExtension20Fn {} + unsafe impl Sync for AmdExtension20Fn {} + impl ::std::clone::Clone for AmdExtension20Fn { + fn clone(&self) -> Self { + AmdExtension20Fn {} + } + } + impl AmdExtension20Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension20Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdShaderTrinaryMinmaxFn {} unsafe impl Send for AmdShaderTrinaryMinmaxFn {} unsafe impl Sync for AmdShaderTrinaryMinmaxFn {} @@ -12145,6 +15332,50 @@ pub mod extensions { impl StructureType { pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = StructureType(1000022002); } + pub struct AmdExtension24Fn {} + unsafe impl Send for AmdExtension24Fn {} + unsafe impl Sync for AmdExtension24Fn {} + impl ::std::clone::Clone for AmdExtension24Fn { + fn clone(&self) -> Self { + AmdExtension24Fn {} + } + } + impl AmdExtension24Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension24Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension25Fn {} + unsafe impl Send for AmdExtension25Fn {} + unsafe impl Sync for AmdExtension25Fn {} + impl ::std::clone::Clone for AmdExtension25Fn { + fn clone(&self) -> Self { + AmdExtension25Fn {} + } + } + impl AmdExtension25Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension25Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdGcnShaderFn {} unsafe impl Send for AmdGcnShaderFn {} unsafe impl Sync for AmdGcnShaderFn {} @@ -12201,6 +15432,138 @@ pub mod extensions { impl StructureType { pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = StructureType(1000026002); } + pub struct ExtExtension28Fn {} + unsafe impl Send for ExtExtension28Fn {} + unsafe impl Sync for ExtExtension28Fn {} + impl ::std::clone::Clone for ExtExtension28Fn { + fn clone(&self) -> Self { + ExtExtension28Fn {} + } + } + impl ExtExtension28Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension28Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvxExtension29Fn {} + unsafe impl Send for NvxExtension29Fn {} + unsafe impl Sync for NvxExtension29Fn {} + impl ::std::clone::Clone for NvxExtension29Fn { + fn clone(&self) -> Self { + NvxExtension29Fn {} + } + } + impl NvxExtension29Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension29Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvxExtension30Fn {} + unsafe impl Send for NvxExtension30Fn {} + unsafe impl Sync for NvxExtension30Fn {} + impl ::std::clone::Clone for NvxExtension30Fn { + fn clone(&self) -> Self { + NvxExtension30Fn {} + } + } + impl NvxExtension30Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension30Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvxExtension31Fn {} + unsafe impl Send for NvxExtension31Fn {} + unsafe impl Sync for NvxExtension31Fn {} + impl ::std::clone::Clone for NvxExtension31Fn { + fn clone(&self) -> Self { + NvxExtension31Fn {} + } + } + impl NvxExtension31Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension31Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension32Fn {} + unsafe impl Send for AmdExtension32Fn {} + unsafe impl Sync for AmdExtension32Fn {} + impl ::std::clone::Clone for AmdExtension32Fn { + fn clone(&self) -> Self { + AmdExtension32Fn {} + } + } + impl AmdExtension32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension32Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension33Fn {} + unsafe impl Send for AmdExtension33Fn {} + unsafe impl Sync for AmdExtension33Fn {} + impl ::std::clone::Clone for AmdExtension33Fn { + fn clone(&self) -> Self { + AmdExtension33Fn {} + } + } + impl AmdExtension33Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension33Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdDrawIndirectCountFn { cmd_draw_indirect_count_amd: extern "system" fn( command_buffer: CommandBuffer, @@ -12304,6 +15667,28 @@ pub mod extensions { ) } } + pub struct AmdExtension35Fn {} + unsafe impl Send for AmdExtension35Fn {} + unsafe impl Sync for AmdExtension35Fn {} + impl ::std::clone::Clone for AmdExtension35Fn { + fn clone(&self) -> Self { + AmdExtension35Fn {} + } + } + impl AmdExtension35Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension35Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdNegativeViewportHeightFn {} unsafe impl Send for AmdNegativeViewportHeightFn {} unsafe impl Sync for AmdNegativeViewportHeightFn {} @@ -12370,6 +15755,72 @@ pub mod extensions { } } } + pub struct AmdExtension39Fn {} + unsafe impl Send for AmdExtension39Fn {} + unsafe impl Sync for AmdExtension39Fn {} + impl ::std::clone::Clone for AmdExtension39Fn { + fn clone(&self) -> Self { + AmdExtension39Fn {} + } + } + impl AmdExtension39Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension39Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension40Fn {} + unsafe impl Send for AmdExtension40Fn {} + unsafe impl Sync for AmdExtension40Fn {} + impl ::std::clone::Clone for AmdExtension40Fn { + fn clone(&self) -> Self { + AmdExtension40Fn {} + } + } + impl AmdExtension40Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension40Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension41Fn {} + unsafe impl Send for AmdExtension41Fn {} + unsafe impl Sync for AmdExtension41Fn {} + impl ::std::clone::Clone for AmdExtension41Fn { + fn clone(&self) -> Self { + AmdExtension41Fn {} + } + } + impl AmdExtension41Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension41Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdTextureGatherBiasLodFn {} unsafe impl Send for AmdTextureGatherBiasLodFn {} unsafe impl Sync for AmdTextureGatherBiasLodFn {} @@ -12457,6 +15908,72 @@ pub mod extensions { ) } } + pub struct AmdExtension44Fn {} + unsafe impl Send for AmdExtension44Fn {} + unsafe impl Sync for AmdExtension44Fn {} + impl ::std::clone::Clone for AmdExtension44Fn { + fn clone(&self) -> Self { + AmdExtension44Fn {} + } + } + impl AmdExtension44Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension44Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension45Fn {} + unsafe impl Send for AmdExtension45Fn {} + unsafe impl Sync for AmdExtension45Fn {} + impl ::std::clone::Clone for AmdExtension45Fn { + fn clone(&self) -> Self { + AmdExtension45Fn {} + } + } + impl AmdExtension45Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension45Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension46Fn {} + unsafe impl Send for AmdExtension46Fn {} + unsafe impl Sync for AmdExtension46Fn {} + impl ::std::clone::Clone for AmdExtension46Fn { + fn clone(&self) -> Self { + AmdExtension46Fn {} + } + } + impl AmdExtension46Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension46Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdShaderImageLoadStoreLodFn {} unsafe impl Send for AmdShaderImageLoadStoreLodFn {} unsafe impl Sync for AmdShaderImageLoadStoreLodFn {} @@ -12479,6 +15996,138 @@ pub mod extensions { } } } + pub struct NvxExtension48Fn {} + unsafe impl Send for NvxExtension48Fn {} + unsafe impl Sync for NvxExtension48Fn {} + impl ::std::clone::Clone for NvxExtension48Fn { + fn clone(&self) -> Self { + NvxExtension48Fn {} + } + } + impl NvxExtension48Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension48Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct GoogleExtension49Fn {} + unsafe impl Send for GoogleExtension49Fn {} + unsafe impl Sync for GoogleExtension49Fn {} + impl ::std::clone::Clone for GoogleExtension49Fn { + fn clone(&self) -> Self { + GoogleExtension49Fn {} + } + } + impl GoogleExtension49Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension49Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct GoogleExtension50Fn {} + unsafe impl Send for GoogleExtension50Fn {} + unsafe impl Sync for GoogleExtension50Fn {} + impl ::std::clone::Clone for GoogleExtension50Fn { + fn clone(&self) -> Self { + GoogleExtension50Fn {} + } + } + impl GoogleExtension50Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension50Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvxExtension51Fn {} + unsafe impl Send for NvxExtension51Fn {} + unsafe impl Sync for NvxExtension51Fn {} + impl ::std::clone::Clone for NvxExtension51Fn { + fn clone(&self) -> Self { + NvxExtension51Fn {} + } + } + impl NvxExtension51Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension51Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvxExtension52Fn {} + unsafe impl Send for NvxExtension52Fn {} + unsafe impl Sync for NvxExtension52Fn {} + impl ::std::clone::Clone for NvxExtension52Fn { + fn clone(&self) -> Self { + NvxExtension52Fn {} + } + } + impl NvxExtension52Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension52Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension53Fn {} + unsafe impl Send for NvExtension53Fn {} + unsafe impl Sync for NvExtension53Fn {} + impl ::std::clone::Clone for NvExtension53Fn { + fn clone(&self) -> Self { + NvExtension53Fn {} + } + } + impl NvExtension53Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension53Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct KhrMultiviewFn {} unsafe impl Send for KhrMultiviewFn {} unsafe impl Sync for KhrMultiviewFn {} @@ -13002,6 +16651,72 @@ pub mod extensions { } } } + pub struct ArmExtension01Fn {} + unsafe impl Send for ArmExtension01Fn {} + unsafe impl Sync for ArmExtension01Fn {} + impl ::std::clone::Clone for ArmExtension01Fn { + fn clone(&self) -> Self { + ArmExtension01Fn {} + } + } + impl ArmExtension01Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ArmExtension01Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ArmExtension02Fn {} + unsafe impl Send for ArmExtension02Fn {} + unsafe impl Sync for ArmExtension02Fn {} + impl ::std::clone::Clone for ArmExtension02Fn { + fn clone(&self) -> Self { + ArmExtension02Fn {} + } + } + impl ArmExtension02Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ArmExtension02Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ImgExtension69Fn {} + unsafe impl Send for ImgExtension69Fn {} + unsafe impl Sync for ImgExtension69Fn {} + impl ::std::clone::Clone for ImgExtension69Fn { + fn clone(&self) -> Self { + ImgExtension69Fn {} + } + } + impl ImgExtension69Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension69Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct KhrMaintenance1Fn {} unsafe impl Send for KhrMaintenance1Fn {} unsafe impl Sync for KhrMaintenance1Fn {} @@ -13586,6 +17301,50 @@ pub mod extensions { impl DescriptorSetLayoutCreateFlags { pub const PUSH_DESCRIPTOR_KHR: Self = DescriptorSetLayoutCreateFlags(0b1); } + pub struct ExtExtension82Fn {} + unsafe impl Send for ExtExtension82Fn {} + unsafe impl Sync for ExtExtension82Fn {} + impl ::std::clone::Clone for ExtExtension82Fn { + fn clone(&self) -> Self { + ExtExtension82Fn {} + } + } + impl ExtExtension82Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension82Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExtension83Fn {} + unsafe impl Send for KhrExtension83Fn {} + unsafe impl Sync for KhrExtension83Fn {} + impl ::std::clone::Clone for KhrExtension83Fn { + fn clone(&self) -> Self { + KhrExtension83Fn {} + } + } + impl KhrExtension83Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension83Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct Khr16bitStorageFn {} unsafe impl Send for Khr16bitStorageFn {} unsafe impl Sync for Khr16bitStorageFn {} @@ -14680,6 +18439,28 @@ pub mod extensions { impl DynamicState { pub const DISCARD_RECTANGLE_EXT: Self = DynamicState(1000099000); } + pub struct NvExtension101Fn {} + unsafe impl Send for NvExtension101Fn {} + unsafe impl Sync for NvExtension101Fn {} + impl ::std::clone::Clone for NvExtension101Fn { + fn clone(&self) -> Self { + NvExtension101Fn {} + } + } + impl NvExtension101Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension101Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtConservativeRasterizationFn {} unsafe impl Send for ExtConservativeRasterizationFn {} unsafe impl Sync for ExtConservativeRasterizationFn {} @@ -14712,6 +18493,50 @@ pub mod extensions { pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = StructureType(1000101001); } + pub struct NvExtension103Fn {} + unsafe impl Send for NvExtension103Fn {} + unsafe impl Sync for NvExtension103Fn {} + impl ::std::clone::Clone for NvExtension103Fn { + fn clone(&self) -> Self { + NvExtension103Fn {} + } + } + impl NvExtension103Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension103Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension104Fn {} + unsafe impl Send for NvExtension104Fn {} + unsafe impl Sync for NvExtension104Fn {} + impl ::std::clone::Clone for NvExtension104Fn { + fn clone(&self) -> Self { + NvExtension104Fn {} + } + } + impl NvExtension104Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension104Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtSwapchainColorspaceFn {} unsafe impl Send for ExtSwapchainColorspaceFn {} unsafe impl Sync for ExtSwapchainColorspaceFn {} @@ -14844,6 +18669,116 @@ pub mod extensions { impl StructureType { pub const HDR_METADATA_EXT: Self = StructureType(1000105000); } + pub struct ImgExtension107Fn {} + unsafe impl Send for ImgExtension107Fn {} + unsafe impl Sync for ImgExtension107Fn {} + impl ::std::clone::Clone for ImgExtension107Fn { + fn clone(&self) -> Self { + ImgExtension107Fn {} + } + } + impl ImgExtension107Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension107Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ImgExtension108Fn {} + unsafe impl Send for ImgExtension108Fn {} + unsafe impl Sync for ImgExtension108Fn {} + impl ::std::clone::Clone for ImgExtension108Fn { + fn clone(&self) -> Self { + ImgExtension108Fn {} + } + } + impl ImgExtension108Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension108Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ImgExtension109Fn {} + unsafe impl Send for ImgExtension109Fn {} + unsafe impl Sync for ImgExtension109Fn {} + impl ::std::clone::Clone for ImgExtension109Fn { + fn clone(&self) -> Self { + ImgExtension109Fn {} + } + } + impl ImgExtension109Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension109Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ImgExtension110Fn {} + unsafe impl Send for ImgExtension110Fn {} + unsafe impl Sync for ImgExtension110Fn {} + impl ::std::clone::Clone for ImgExtension110Fn { + fn clone(&self) -> Self { + ImgExtension110Fn {} + } + } + impl ImgExtension110Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension110Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ImgExtension111Fn {} + unsafe impl Send for ImgExtension111Fn {} + unsafe impl Sync for ImgExtension111Fn {} + impl ::std::clone::Clone for ImgExtension111Fn { + fn clone(&self) -> Self { + ImgExtension111Fn {} + } + } + impl ImgExtension111Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension111Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct KhrSharedPresentableImageFn { get_swapchain_status_khr: extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, @@ -15095,6 +19030,28 @@ pub mod extensions { impl StructureType { pub const FENCE_GET_FD_INFO_KHR: Self = StructureType(1000115001); } + pub struct KhrExtension117Fn {} + unsafe impl Send for KhrExtension117Fn {} + unsafe impl Sync for KhrExtension117Fn {} + impl ::std::clone::Clone for KhrExtension117Fn { + fn clone(&self) -> Self { + KhrExtension117Fn {} + } + } + impl KhrExtension117Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension117Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct KhrMaintenance2Fn {} unsafe impl Send for KhrMaintenance2Fn {} unsafe impl Sync for KhrMaintenance2Fn {} @@ -15117,6 +19074,28 @@ pub mod extensions { } } } + pub struct KhrExtension119Fn {} + unsafe impl Send for KhrExtension119Fn {} + unsafe impl Sync for KhrExtension119Fn {} + impl ::std::clone::Clone for KhrExtension119Fn { + fn clone(&self) -> Self { + KhrExtension119Fn {} + } + } + impl KhrExtension119Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension119Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct KhrGetSurfaceCapabilities2Fn { get_physical_device_surface_capabilities2_khr: extern "system" fn( @@ -15508,6 +19487,28 @@ pub mod extensions { impl StructureType { pub const MACOS_SURFACE_CREATE_INFO_M: Self = StructureType(1000123000); } + pub struct MvkMoltenvkFn {} + unsafe impl Send for MvkMoltenvkFn {} + unsafe impl Sync for MvkMoltenvkFn {} + impl ::std::clone::Clone for MvkMoltenvkFn { + fn clone(&self) -> Self { + MvkMoltenvkFn {} + } + } + impl MvkMoltenvkFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkMoltenvkFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtExternalMemoryDmaBufFn {} unsafe impl Send for ExtExternalMemoryDmaBufFn {} unsafe impl Sync for ExtExternalMemoryDmaBufFn {} @@ -16050,6 +20051,72 @@ pub mod extensions { } } } + pub struct AmdExtension134Fn {} + unsafe impl Send for AmdExtension134Fn {} + unsafe impl Sync for AmdExtension134Fn {} + impl ::std::clone::Clone for AmdExtension134Fn { + fn clone(&self) -> Self { + AmdExtension134Fn {} + } + } + impl AmdExtension134Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension134Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension135Fn {} + unsafe impl Send for AmdExtension135Fn {} + unsafe impl Sync for AmdExtension135Fn {} + impl ::std::clone::Clone for AmdExtension135Fn { + fn clone(&self) -> Self { + AmdExtension135Fn {} + } + } + impl AmdExtension135Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension135Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension136Fn {} + unsafe impl Send for AmdExtension136Fn {} + unsafe impl Sync for AmdExtension136Fn {} + impl ::std::clone::Clone for AmdExtension136Fn { + fn clone(&self) -> Self { + AmdExtension136Fn {} + } + } + impl AmdExtension136Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension136Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdMixedAttachmentSamplesFn {} unsafe impl Send for AmdMixedAttachmentSamplesFn {} unsafe impl Sync for AmdMixedAttachmentSamplesFn {} @@ -16094,6 +20161,50 @@ pub mod extensions { } } } + pub struct AmdExtension139Fn {} + unsafe impl Send for AmdExtension139Fn {} + unsafe impl Sync for AmdExtension139Fn {} + impl ::std::clone::Clone for AmdExtension139Fn { + fn clone(&self) -> Self { + AmdExtension139Fn {} + } + } + impl AmdExtension139Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension139Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension140Fn {} + unsafe impl Send for AmdExtension140Fn {} + unsafe impl Sync for AmdExtension140Fn {} + impl ::std::clone::Clone for AmdExtension140Fn { + fn clone(&self) -> Self { + AmdExtension140Fn {} + } + } + impl AmdExtension140Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension140Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtShaderStencilExportFn {} unsafe impl Send for ExtShaderStencilExportFn {} unsafe impl Sync for ExtShaderStencilExportFn {} @@ -16116,6 +20227,50 @@ pub mod extensions { } } } + pub struct AmdExtension142Fn {} + unsafe impl Send for AmdExtension142Fn {} + unsafe impl Sync for AmdExtension142Fn {} + impl ::std::clone::Clone for AmdExtension142Fn { + fn clone(&self) -> Self { + AmdExtension142Fn {} + } + } + impl AmdExtension142Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension142Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension143Fn {} + unsafe impl Send for AmdExtension143Fn {} + unsafe impl Sync for AmdExtension143Fn {} + impl ::std::clone::Clone for AmdExtension143Fn { + fn clone(&self) -> Self { + AmdExtension143Fn {} + } + } + impl AmdExtension143Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension143Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtSampleLocationsFn { cmd_set_sample_locations_ext: extern "system" fn( @@ -16541,6 +20696,50 @@ pub mod extensions { impl StructureType { pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = StructureType(1000149000); } + pub struct NvExtension151Fn {} + unsafe impl Send for NvExtension151Fn {} + unsafe impl Sync for NvExtension151Fn {} + impl ::std::clone::Clone for NvExtension151Fn { + fn clone(&self) -> Self { + NvExtension151Fn {} + } + } + impl NvExtension151Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension151Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension152Fn {} + unsafe impl Send for NvExtension152Fn {} + unsafe impl Sync for NvExtension152Fn {} + impl ::std::clone::Clone for NvExtension152Fn { + fn clone(&self) -> Self { + NvExtension152Fn {} + } + } + impl NvExtension152Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension152Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct NvFramebufferMixedSamplesFn {} unsafe impl Send for NvFramebufferMixedSamplesFn {} unsafe impl Sync for NvFramebufferMixedSamplesFn {} @@ -16594,6 +20793,28 @@ pub mod extensions { impl PolygonMode { pub const FILL_RECTANGLE_NV: Self = PolygonMode(1000153000); } + pub struct NvExtension155Fn {} + unsafe impl Send for NvExtension155Fn {} + unsafe impl Sync for NvExtension155Fn {} + impl ::std::clone::Clone for NvExtension155Fn { + fn clone(&self) -> Self { + NvExtension155Fn {} + } + } + impl NvExtension155Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension155Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtPostDepthCoverageFn {} unsafe impl Send for ExtPostDepthCoverageFn {} unsafe impl Sync for ExtPostDepthCoverageFn {} @@ -16660,6 +20881,50 @@ pub mod extensions { } } } + pub struct ExtExtension159Fn {} + unsafe impl Send for ExtExtension159Fn {} + unsafe impl Sync for ExtExtension159Fn {} + impl ::std::clone::Clone for ExtExtension159Fn { + fn clone(&self) -> Self { + ExtExtension159Fn {} + } + } + impl ExtExtension159Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension159Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtExtension160Fn {} + unsafe impl Send for ExtExtension160Fn {} + unsafe impl Sync for ExtExtension160Fn {} + impl ::std::clone::Clone for ExtExtension160Fn { + fn clone(&self) -> Self { + ExtExtension160Fn {} + } + } + impl ExtExtension160Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension160Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtValidationCacheFn { create_validation_cache_ext: extern "system" fn( @@ -16882,6 +21147,116 @@ pub mod extensions { } } } + pub struct NvExtension164Fn {} + unsafe impl Send for NvExtension164Fn {} + unsafe impl Sync for NvExtension164Fn {} + impl ::std::clone::Clone for NvExtension164Fn { + fn clone(&self) -> Self { + NvExtension164Fn {} + } + } + impl NvExtension164Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension164Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension165Fn {} + unsafe impl Send for NvExtension165Fn {} + unsafe impl Sync for NvExtension165Fn {} + impl ::std::clone::Clone for NvExtension165Fn { + fn clone(&self) -> Self { + NvExtension165Fn {} + } + } + impl NvExtension165Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension165Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension166Fn {} + unsafe impl Send for NvExtension166Fn {} + unsafe impl Sync for NvExtension166Fn {} + impl ::std::clone::Clone for NvExtension166Fn { + fn clone(&self) -> Self { + NvExtension166Fn {} + } + } + impl NvExtension166Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension166Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension167Fn {} + unsafe impl Send for NvExtension167Fn {} + unsafe impl Sync for NvExtension167Fn {} + impl ::std::clone::Clone for NvExtension167Fn { + fn clone(&self) -> Self { + NvExtension167Fn {} + } + } + impl NvExtension167Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension167Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension168Fn {} + unsafe impl Send for NvExtension168Fn {} + unsafe impl Sync for NvExtension168Fn {} + impl ::std::clone::Clone for NvExtension168Fn { + fn clone(&self) -> Self { + NvExtension168Fn {} + } + } + impl NvExtension168Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension168Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct KhrMaintenance3Fn {} unsafe impl Send for KhrMaintenance3Fn {} unsafe impl Sync for KhrMaintenance3Fn {} @@ -17007,6 +21382,94 @@ pub mod extensions { ) } } + pub struct QcomExtension171Fn {} + unsafe impl Send for QcomExtension171Fn {} + unsafe impl Sync for QcomExtension171Fn {} + impl ::std::clone::Clone for QcomExtension171Fn { + fn clone(&self) -> Self { + QcomExtension171Fn {} + } + } + impl QcomExtension171Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension171Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct QcomExtension172Fn {} + unsafe impl Send for QcomExtension172Fn {} + unsafe impl Sync for QcomExtension172Fn {} + impl ::std::clone::Clone for QcomExtension172Fn { + fn clone(&self) -> Self { + QcomExtension172Fn {} + } + } + impl QcomExtension172Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension172Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct QcomExtension173Fn {} + unsafe impl Send for QcomExtension173Fn {} + unsafe impl Sync for QcomExtension173Fn {} + impl ::std::clone::Clone for QcomExtension173Fn { + fn clone(&self) -> Self { + QcomExtension173Fn {} + } + } + impl QcomExtension173Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension173Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct QcomExtension174Fn {} + unsafe impl Send for QcomExtension174Fn {} + unsafe impl Sync for QcomExtension174Fn {} + impl ::std::clone::Clone for QcomExtension174Fn { + fn clone(&self) -> Self { + QcomExtension174Fn {} + } + } + impl QcomExtension174Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension174Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtGlobalPriorityFn {} unsafe impl Send for ExtGlobalPriorityFn {} unsafe impl Sync for ExtGlobalPriorityFn {} @@ -17037,6 +21500,72 @@ pub mod extensions { impl Result { pub const ERROR_NOT_PERMITTED_EXT: Self = Result(1000174001); } + pub struct ExtExtension176Fn {} + unsafe impl Send for ExtExtension176Fn {} + unsafe impl Sync for ExtExtension176Fn {} + impl ::std::clone::Clone for ExtExtension176Fn { + fn clone(&self) -> Self { + ExtExtension176Fn {} + } + } + impl ExtExtension176Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension176Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtExtension177Fn {} + unsafe impl Send for ExtExtension177Fn {} + unsafe impl Sync for ExtExtension177Fn {} + impl ::std::clone::Clone for ExtExtension177Fn { + fn clone(&self) -> Self { + ExtExtension177Fn {} + } + } + impl ExtExtension177Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension177Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtExtension178Fn {} + unsafe impl Send for ExtExtension178Fn {} + unsafe impl Sync for ExtExtension178Fn {} + impl ::std::clone::Clone for ExtExtension178Fn { + fn clone(&self) -> Self { + ExtExtension178Fn {} + } + } + impl ExtExtension178Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension178Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , p_host_pointer : *const c_void , p_memory_host_pointer_properties : *const MemoryHostPointerPropertiesEXT , ) -> Result , } unsafe impl Send for ExtExternalMemoryHostFn {} unsafe impl Sync for ExtExternalMemoryHostFn {} @@ -17164,6 +21693,116 @@ pub mod extensions { ) } } + pub struct AmdExtension181Fn {} + unsafe impl Send for AmdExtension181Fn {} + unsafe impl Sync for AmdExtension181Fn {} + impl ::std::clone::Clone for AmdExtension181Fn { + fn clone(&self) -> Self { + AmdExtension181Fn {} + } + } + impl AmdExtension181Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension181Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension182Fn {} + unsafe impl Send for AmdExtension182Fn {} + unsafe impl Sync for AmdExtension182Fn {} + impl ::std::clone::Clone for AmdExtension182Fn { + fn clone(&self) -> Self { + AmdExtension182Fn {} + } + } + impl AmdExtension182Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension182Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension183Fn {} + unsafe impl Send for AmdExtension183Fn {} + unsafe impl Sync for AmdExtension183Fn {} + impl ::std::clone::Clone for AmdExtension183Fn { + fn clone(&self) -> Self { + AmdExtension183Fn {} + } + } + impl AmdExtension183Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension183Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension184Fn {} + unsafe impl Send for AmdExtension184Fn {} + unsafe impl Sync for AmdExtension184Fn {} + impl ::std::clone::Clone for AmdExtension184Fn { + fn clone(&self) -> Self { + AmdExtension184Fn {} + } + } + impl AmdExtension184Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension184Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension185Fn {} + unsafe impl Send for AmdExtension185Fn {} + unsafe impl Sync for AmdExtension185Fn {} + impl ::std::clone::Clone for AmdExtension185Fn { + fn clone(&self) -> Self { + AmdExtension185Fn {} + } + } + impl AmdExtension185Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension185Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct AmdShaderCorePropertiesFn {} unsafe impl Send for AmdShaderCorePropertiesFn {} unsafe impl Sync for AmdShaderCorePropertiesFn {} @@ -17190,6 +21829,94 @@ pub mod extensions { impl StructureType { pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = StructureType(1000185000); } + pub struct AmdExtension187Fn {} + unsafe impl Send for AmdExtension187Fn {} + unsafe impl Sync for AmdExtension187Fn {} + impl ::std::clone::Clone for AmdExtension187Fn { + fn clone(&self) -> Self { + AmdExtension187Fn {} + } + } + impl AmdExtension187Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension187Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension188Fn {} + unsafe impl Send for AmdExtension188Fn {} + unsafe impl Sync for AmdExtension188Fn {} + impl ::std::clone::Clone for AmdExtension188Fn { + fn clone(&self) -> Self { + AmdExtension188Fn {} + } + } + impl AmdExtension188Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension188Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension189Fn {} + unsafe impl Send for AmdExtension189Fn {} + unsafe impl Sync for AmdExtension189Fn {} + impl ::std::clone::Clone for AmdExtension189Fn { + fn clone(&self) -> Self { + AmdExtension189Fn {} + } + } + impl AmdExtension189Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension189Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct AmdExtension190Fn {} + unsafe impl Send for AmdExtension190Fn {} + unsafe impl Sync for AmdExtension190Fn {} + impl ::std::clone::Clone for AmdExtension190Fn { + fn clone(&self) -> Self { + AmdExtension190Fn {} + } + } + impl AmdExtension190Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension190Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct ExtVertexAttributeDivisorFn {} unsafe impl Send for ExtVertexAttributeDivisorFn {} unsafe impl Sync for ExtVertexAttributeDivisorFn {} @@ -17222,6 +21949,160 @@ pub mod extensions { pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = StructureType(1000190001); } + pub struct GoogleExtension192Fn {} + unsafe impl Send for GoogleExtension192Fn {} + unsafe impl Sync for GoogleExtension192Fn {} + impl ::std::clone::Clone for GoogleExtension192Fn { + fn clone(&self) -> Self { + GoogleExtension192Fn {} + } + } + impl GoogleExtension192Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension192Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct GoogleExtension193Fn {} + unsafe impl Send for GoogleExtension193Fn {} + unsafe impl Sync for GoogleExtension193Fn {} + impl ::std::clone::Clone for GoogleExtension193Fn { + fn clone(&self) -> Self { + GoogleExtension193Fn {} + } + } + impl GoogleExtension193Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension193Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct GoogleExtension194Fn {} + unsafe impl Send for GoogleExtension194Fn {} + unsafe impl Sync for GoogleExtension194Fn {} + impl ::std::clone::Clone for GoogleExtension194Fn { + fn clone(&self) -> Self { + GoogleExtension194Fn {} + } + } + impl GoogleExtension194Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension194Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct GoogleExtension195Fn {} + unsafe impl Send for GoogleExtension195Fn {} + unsafe impl Sync for GoogleExtension195Fn {} + impl ::std::clone::Clone for GoogleExtension195Fn { + fn clone(&self) -> Self { + GoogleExtension195Fn {} + } + } + impl GoogleExtension195Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension195Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct GoogleExtension196Fn {} + unsafe impl Send for GoogleExtension196Fn {} + unsafe impl Sync for GoogleExtension196Fn {} + impl ::std::clone::Clone for GoogleExtension196Fn { + fn clone(&self) -> Self { + GoogleExtension196Fn {} + } + } + impl GoogleExtension196Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension196Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ExtExtension197Fn {} + unsafe impl Send for ExtExtension197Fn {} + unsafe impl Sync for ExtExtension197Fn {} + impl ::std::clone::Clone for ExtExtension197Fn { + fn clone(&self) -> Self { + ExtExtension197Fn {} + } + } + impl ExtExtension197Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension197Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct ArmExtension198Fn {} + unsafe impl Send for ArmExtension198Fn {} + unsafe impl Sync for ArmExtension198Fn {} + impl ::std::clone::Clone for ArmExtension198Fn { + fn clone(&self) -> Self { + ArmExtension198Fn {} + } + } + impl ArmExtension198Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ArmExtension198Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } pub struct NvShaderSubgroupPartitionedFn {} unsafe impl Send for NvShaderSubgroupPartitionedFn {} unsafe impl Sync for NvShaderSubgroupPartitionedFn {} @@ -17248,4 +22129,833 @@ pub mod extensions { impl SubgroupFeatureFlags { pub const PARTITIONED_NV: Self = SubgroupFeatureFlags(0b100000000); } + pub struct KhrExtension200Fn {} + unsafe impl Send for KhrExtension200Fn {} + unsafe impl Sync for KhrExtension200Fn {} + impl ::std::clone::Clone for KhrExtension200Fn { + fn clone(&self) -> Self { + KhrExtension200Fn {} + } + } + impl KhrExtension200Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension200Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExtension201Fn {} + unsafe impl Send for KhrExtension201Fn {} + unsafe impl Sync for KhrExtension201Fn {} + impl ::std::clone::Clone for KhrExtension201Fn { + fn clone(&self) -> Self { + KhrExtension201Fn {} + } + } + impl KhrExtension201Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension201Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension202Fn {} + unsafe impl Send for NvExtension202Fn {} + unsafe impl Sync for NvExtension202Fn {} + impl ::std::clone::Clone for NvExtension202Fn { + fn clone(&self) -> Self { + NvExtension202Fn {} + } + } + impl NvExtension202Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension202Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension203Fn {} + unsafe impl Send for NvExtension203Fn {} + unsafe impl Sync for NvExtension203Fn {} + impl ::std::clone::Clone for NvExtension203Fn { + fn clone(&self) -> Self { + NvExtension203Fn {} + } + } + impl NvExtension203Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension203Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension204Fn {} + unsafe impl Send for NvExtension204Fn {} + unsafe impl Sync for NvExtension204Fn {} + impl ::std::clone::Clone for NvExtension204Fn { + fn clone(&self) -> Self { + NvExtension204Fn {} + } + } + impl NvExtension204Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension204Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension205Fn {} + unsafe impl Send for NvExtension205Fn {} + unsafe impl Sync for NvExtension205Fn {} + impl ::std::clone::Clone for NvExtension205Fn { + fn clone(&self) -> Self { + NvExtension205Fn {} + } + } + impl NvExtension205Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension205Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension206Fn {} + unsafe impl Send for NvExtension206Fn {} + unsafe impl Sync for NvExtension206Fn {} + impl ::std::clone::Clone for NvExtension206Fn { + fn clone(&self) -> Self { + NvExtension206Fn {} + } + } + impl NvExtension206Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension206Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct NvExtension207Fn {} + unsafe impl Send for NvExtension207Fn {} + unsafe impl Sync for NvExtension207Fn {} + impl ::std::clone::Clone for NvExtension207Fn { + fn clone(&self) -> Self { + NvExtension207Fn {} + } + } + impl NvExtension207Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension207Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExtension208Fn {} + unsafe impl Send for KhrExtension208Fn {} + unsafe impl Sync for KhrExtension208Fn {} + impl ::std::clone::Clone for KhrExtension208Fn { + fn clone(&self) -> Self { + KhrExtension208Fn {} + } + } + impl KhrExtension208Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension208Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExtension209Fn {} + unsafe impl Send for KhrExtension209Fn {} + unsafe impl Sync for KhrExtension209Fn {} + impl ::std::clone::Clone for KhrExtension209Fn { + fn clone(&self) -> Self { + KhrExtension209Fn {} + } + } + impl KhrExtension209Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension209Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct IntelExtension210Fn {} + unsafe impl Send for IntelExtension210Fn {} + unsafe impl Sync for IntelExtension210Fn {} + impl ::std::clone::Clone for IntelExtension210Fn { + fn clone(&self) -> Self { + IntelExtension210Fn {} + } + } + impl IntelExtension210Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = IntelExtension210Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct IntelExtension211Fn {} + unsafe impl Send for IntelExtension211Fn {} + unsafe impl Sync for IntelExtension211Fn {} + impl ::std::clone::Clone for IntelExtension211Fn { + fn clone(&self) -> Self { + IntelExtension211Fn {} + } + } + impl IntelExtension211Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = IntelExtension211Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + pub struct KhrExtension212Fn {} + unsafe impl Send for KhrExtension212Fn {} + unsafe impl Sync for KhrExtension212Fn {} + impl ::std::clone::Clone for KhrExtension212Fn { + fn clone(&self) -> Self { + KhrExtension212Fn {} + } + } + impl KhrExtension212Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension212Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = StructureType(1000094000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const BIND_BUFFER_MEMORY_INFO: Self = StructureType(1000157000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const BIND_IMAGE_MEMORY_INFO: Self = StructureType(1000157001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageCreateFlags { + pub const ALIAS: Self = ImageCreateFlags(0b10000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = StructureType(1000083000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const MEMORY_DEDICATED_REQUIREMENTS: Self = StructureType(1000127000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = StructureType(1000127001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = StructureType(1000060000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = StructureType(1000060003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = StructureType(1000060004); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DEVICE_GROUP_SUBMIT_INFO: Self = StructureType(1000060005); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = StructureType(1000060006); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl PipelineCreateFlags { + pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = PipelineCreateFlags(0b1000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl PipelineCreateFlags { + pub const DISPATCH_BASE: Self = PipelineCreateFlags(0b10000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl DependencyFlags { + pub const DEVICE_GROUP: Self = DependencyFlags(0b100); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1000060013); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1000060014); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageCreateFlags { + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = ImageCreateFlags(0b1000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = StructureType(1000070000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = StructureType(1000070001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl MemoryHeapFlags { + pub const MULTI_INSTANCE: Self = MemoryHeapFlags(0b10); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const MEMORY_REQUIREMENTS_2: Self = StructureType(1000146003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = StructureType(1000146004); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_FEATURES_2: Self = StructureType(1000059000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = StructureType(1000059001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const FORMAT_PROPERTIES_2: Self = StructureType(1000059002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1000059003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = StructureType(1000059004); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const QUEUE_FAMILY_PROPERTIES_2: Self = StructureType(1000059005); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = StructureType(1000059006); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1000059007); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = StructureType(1000059008); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Result { + pub const ERROR_OUT_OF_POOL_MEMORY: Self = Result(1000069000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const TRANSFER_SRC: Self = FormatFeatureFlags(0b100000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const TRANSFER_DST: Self = FormatFeatureFlags(0b1000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageCreateFlags { + pub const TYPE_2D_ARRAY_COMPATIBLE: Self = ImageCreateFlags(0b100000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageCreateFlags { + pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = ImageCreateFlags(0b10000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageCreateFlags { + pub const EXTENDED_USAGE: Self = ImageCreateFlags(0b100000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = StructureType(1000117000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = StructureType(1000117001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = StructureType(1000117002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = + StructureType(1000117003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageLayout { + pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(1000117000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageLayout { + pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(1000117001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = StructureType(1000053000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = StructureType(1000053001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = StructureType(1000053002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl DependencyFlags { + pub const VIEW_LOCAL: Self = DependencyFlags(0b10); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = StructureType(1000120000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PROTECTED_SUBMIT_INFO: Self = StructureType(1000145000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = StructureType(1000145001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = StructureType(1000145002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DEVICE_QUEUE_INFO_2: Self = StructureType(1000145003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl QueueFlags { + pub const PROTECTED: Self = QueueFlags(0b10000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl DeviceQueueCreateFlags { + pub const PROTECTED: Self = DeviceQueueCreateFlags(0b1); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl MemoryPropertyFlags { + pub const PROTECTED: Self = MemoryPropertyFlags(0b100000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl BufferCreateFlags { + pub const PROTECTED: Self = BufferCreateFlags(0b1000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageCreateFlags { + pub const PROTECTED: Self = ImageCreateFlags(0b100000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl CommandPoolCreateFlags { + pub const PROTECTED: Self = CommandPoolCreateFlags(0b100); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = StructureType(1000156000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = StructureType(1000156001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = StructureType(1000156002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = StructureType(1000156003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = + StructureType(1000156004); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = + StructureType(1000156005); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ObjectType { + pub const SAMPLER_YCBCR_CONVERSION: Self = ObjectType(1000156000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G8B8G8R8_422_UNORM: Self = Format(1000156000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const B8G8R8G8_422_UNORM: Self = Format(1000156001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G8_B8_R8_3PLANE_420_UNORM: Self = Format(1000156002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G8_B8R8_2PLANE_420_UNORM: Self = Format(1000156003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G8_B8_R8_3PLANE_422_UNORM: Self = Format(1000156004); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G8_B8R8_2PLANE_422_UNORM: Self = Format(1000156005); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G8_B8_R8_3PLANE_444_UNORM: Self = Format(1000156006); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const R10X6_UNORM_PACK16: Self = Format(1000156007); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const R10X6G10X6_UNORM_2PACK16: Self = Format(1000156008); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Format(1000156009); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Format(1000156010); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Format(1000156011); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Format(1000156012); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Format(1000156013); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Format(1000156014); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Format(1000156015); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Format(1000156016); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const R12X4_UNORM_PACK16: Self = Format(1000156017); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const R12X4G12X4_UNORM_2PACK16: Self = Format(1000156018); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Format(1000156019); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Format(1000156020); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Format(1000156021); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Format(1000156022); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Format(1000156023); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Format(1000156024); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Format(1000156025); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Format(1000156026); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G16B16G16R16_422_UNORM: Self = Format(1000156027); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const B16G16R16G16_422_UNORM: Self = Format(1000156028); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G16_B16_R16_3PLANE_420_UNORM: Self = Format(1000156029); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G16_B16R16_2PLANE_420_UNORM: Self = Format(1000156030); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G16_B16_R16_3PLANE_422_UNORM: Self = Format(1000156031); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G16_B16R16_2PLANE_422_UNORM: Self = Format(1000156032); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Format { + pub const G16_B16_R16_3PLANE_444_UNORM: Self = Format(1000156033); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageAspectFlags { + pub const PLANE_0: Self = ImageAspectFlags(0b10000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageAspectFlags { + pub const PLANE_1: Self = ImageAspectFlags(0b100000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageAspectFlags { + pub const PLANE_2: Self = ImageAspectFlags(0b1000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ImageCreateFlags { + pub const DISJOINT: Self = ImageCreateFlags(0b1000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const MIDPOINT_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b100000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = + FormatFeatureFlags(0b1000000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = + FormatFeatureFlags(0b10000000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = + FormatFeatureFlags(0b100000000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = + FormatFeatureFlags(0b1000000000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const DISJOINT: Self = FormatFeatureFlags(0b10000000000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl FormatFeatureFlags { + pub const COSITED_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b100000000000000000000000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = StructureType(1000085000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl ObjectType { + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = ObjectType(1000085000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = StructureType(1000071000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1000071001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = StructureType(1000071002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXTERNAL_BUFFER_PROPERTIES: Self = StructureType(1000071003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = StructureType(1000071004); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = StructureType(1000072000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = StructureType(1000072001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = StructureType(1000072002); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl Result { + pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Result(1000072003); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = StructureType(1000112000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXTERNAL_FENCE_PROPERTIES: Self = StructureType(1000112001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXPORT_FENCE_CREATE_INFO: Self = StructureType(1000113000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = StructureType(1000077000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = StructureType(1000076000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = StructureType(1000076001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = StructureType(1000168000); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = StructureType(1000168001); + } + #[doc = "Generated from \'VK_VERSION_1_1\'"] + impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = StructureType(1000063000); + } } From 1eea8ab1efe475b31e43798839efc9d404f98470 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 31 Jul 2018 06:37:09 +0200 Subject: [PATCH 035/122] Remove --force --- generator/--force | 1 - 1 file changed, 1 deletion(-) delete mode 160000 generator/--force diff --git a/generator/--force b/generator/--force deleted file mode 160000 index 82e7301..0000000 --- a/generator/--force +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 82e73015b0632833939349d767af39cb88836f29 From e9db6b516a8232f9c79c88b224f19e9b0b275b83 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 31 Jul 2018 06:48:20 +0200 Subject: [PATCH 036/122] Remove submodule file --- .gitmodules | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 .gitmodules diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index 8673d0a..0000000 --- a/.gitmodules +++ /dev/null @@ -1,3 +0,0 @@ -[submodule "generator/Vulkan-Headers"] - path = generator/Vulkan-Headers - url = https://github.com/KhronosGroup/Vulkan-Headers From 60915eacb269bc00c5ea2ef0d9fe85a9c6e7f6ea Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 31 Jul 2018 08:04:07 +0200 Subject: [PATCH 037/122] Add initial support for 1.1 --- ash/src/device.rs | 30 ++++++++++++- ash/src/instance.rs | 32 ++++++++++++-- ash/src/version.rs | 102 ++++++++++++++++++++++++++++++++++---------- 3 files changed, 136 insertions(+), 28 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index 7e77314..7b5498e 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -1,10 +1,22 @@ #![allow(dead_code)] use prelude::*; use std::mem; -use version::{FunctionPointers, V1_0}; +use version::{FunctionPointers, V1_0, V1_1}; use vk; use RawPtr; +#[allow(non_camel_case_types)] +pub trait DeviceV1_1: DeviceV1_0 { + fn fp_v1_1(&self) -> &vk::DeviceFnV1_1; + unsafe fn bind_buffer_memory2(&self, bind_infos: &[vk::BindBufferMemoryInfo]) -> vk::Result { + self.fp_v1_1().bind_buffer_memory2( + self.handle(), + bind_infos.len() as _, + bind_infos.as_ptr(), + ) + } +} + #[allow(non_camel_case_types)] pub trait DeviceV1_0 { fn handle(&self) -> vk::Device; @@ -1495,6 +1507,22 @@ impl DeviceV1_0 for Device { } } +impl DeviceV1_0 for Device { + fn handle(&self) -> vk::Device { + self.handle + } + + fn fp_v1_0(&self) -> &vk::DeviceFnV1_0 { + &self.device_fn.device_fn_1_0 + } +} + +impl DeviceV1_1 for Device { + fn fp_v1_1(&self) -> &vk::DeviceFnV1_1 { + &self.device_fn.device_fn_1_1 + } +} + impl Device { pub fn handle(&self) -> vk::Device { self.handle diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 834835b..004c41f 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -6,7 +6,7 @@ use std::fmt; use std::mem; use std::ptr; use version::DeviceLoader; -use version::{FunctionPointers, V1_0}; +use version::{FunctionPointers, V1_0, V1_1}; use vk; use RawPtr; @@ -51,6 +51,24 @@ impl InstanceV1_0 for Instance { &self.instance_fp.instance_fn } } + +impl InstanceV1_0 for Instance { + type Fp = V1_1; + fn handle(&self) -> vk::Instance { + self.handle + } + + fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 { + &self.instance_fp.instance_fn_1_0 + } +} + +impl InstanceV1_1 for Instance { + fn fp_v1_1(&self) -> &vk::InstanceFnV1_1 { + &self.instance_fp.instance_fn_1_1 + } +} + impl Instance { pub fn handle(&self) -> vk::Instance { self.handle @@ -64,6 +82,15 @@ impl Instance { } } +#[allow(non_camel_case_types)] +pub trait InstanceV1_1: InstanceV1_0 { + fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; + unsafe fn enumerate_instance_version(&self, api_version: &vk::uint32_t) -> vk::Result { + self.fp_v1_1() + .enumerate_instance_version(api_version as *const _) + } +} + #[allow(non_camel_case_types)] pub trait InstanceV1_0 { type Fp: FunctionPointers; @@ -253,6 +280,3 @@ pub trait InstanceV1_0 { } } } - -// pub trait InstanceMajor1Minor1: InstanceMajor1Minor0 {} -// pub trait InstanceMajor1Minor2: InstanceMajor1Minor1 {} diff --git a/ash/src/version.rs b/ash/src/version.rs index 51f00f9..bc1ed91 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -11,17 +11,20 @@ pub trait FunctionPointers { #[allow(non_camel_case_types)] #[derive(Clone)] -pub struct V1_0; -impl FunctionPointers for V1_0 { - type InstanceFp = InstanceFpV1_0; - type DeviceFp = DeviceFpV1_0; +pub struct V1_1; +impl FunctionPointers for V1_1 { + type InstanceFp = InstanceFpV1_1; + type DeviceFp = DeviceFpV1_1; type EntryFp = EntryFpV1_0; } #[allow(non_camel_case_types)] #[derive(Clone)] -pub struct InstanceFpV1_0 { - pub instance_fn: vk::InstanceFnV1_0, +pub struct V1_0; +impl FunctionPointers for V1_0 { + type InstanceFp = InstanceFpV1_0; + type DeviceFp = DeviceFpV1_0; + type EntryFp = EntryFpV1_0; } #[allow(non_camel_case_types)] @@ -48,13 +51,58 @@ pub trait EntryLoader: Sized { } pub trait InstanceLoader: Sized { - fn fp_v1_0(&self) -> &vk::InstanceFnV1_0; unsafe fn load( static_fn: &vk::StaticFn, instance: vk::Instance, ) -> Result>; } +#[allow(non_camel_case_types)] +#[derive(Clone)] +pub struct InstanceFpV1_0 { + pub instance_fn: vk::InstanceFnV1_0, +} + +impl InstanceLoader for InstanceFpV1_0 { + unsafe fn load( + static_fn: &vk::StaticFn, + instance: vk::Instance, + ) -> Result> { + let instance_fn = vk::InstanceFnV1_0::load(|name| { + mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) + })?; + Ok(InstanceFpV1_0 { + instance_fn: instance_fn, + }) + } +} + +#[allow(non_camel_case_types)] +#[derive(Clone)] +pub struct InstanceFpV1_1 { + pub instance_fn_1_0: vk::InstanceFnV1_0, + pub instance_fn_1_1: vk::InstanceFnV1_1, +} + +impl InstanceLoader for InstanceFpV1_1 { + unsafe fn load( + static_fn: &vk::StaticFn, + instance: vk::Instance, + ) -> Result> { + let instance_fn_1_0 = vk::InstanceFnV1_0::load(|name| { + mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) + })?; + let instance_fn_1_1 = vk::InstanceFnV1_1::load(|name| { + mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) + })?; + + Ok(InstanceFpV1_1 { + instance_fn_1_0, + instance_fn_1_1, + }) + } +} + pub trait DeviceLoader: Sized { unsafe fn load( instance_fn: &vk::InstanceFnV1_0, @@ -62,6 +110,12 @@ pub trait DeviceLoader: Sized { ) -> Result>; } +#[allow(non_camel_case_types)] +#[derive(Clone)] +pub struct DeviceFpV1_0 { + pub device_fn: vk::DeviceFnV1_0, +} + impl DeviceLoader for DeviceFpV1_0 { unsafe fn load( instance_fn: &vk::InstanceFnV1_0, @@ -76,25 +130,27 @@ impl DeviceLoader for DeviceFpV1_0 { } } -impl InstanceLoader for InstanceFpV1_0 { - fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 { - &self.instance_fn - } +#[allow(non_camel_case_types)] +#[derive(Clone)] +pub struct DeviceFpV1_1 { + pub device_fn_1_0: vk::DeviceFnV1_0, + pub device_fn_1_1: vk::DeviceFnV1_1, +} + +impl DeviceLoader for DeviceFpV1_1 { unsafe fn load( - static_fn: &vk::StaticFn, - instance: vk::Instance, + instance_fn: &vk::InstanceFnV1_0, + device: vk::Device, ) -> Result> { - let instance_fn = vk::InstanceFnV1_0::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) + let device_fn_1_0 = vk::DeviceFnV1_0::load(|name| { + mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) })?; - Ok(InstanceFpV1_0 { - instance_fn: instance_fn, + let device_fn_1_1 = vk::DeviceFnV1_1::load(|name| { + mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) + })?; + Ok(DeviceFpV1_1 { + device_fn_1_0, + device_fn_1_1, }) } } - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct DeviceFpV1_0 { - pub device_fn: vk::DeviceFnV1_0, -} From f04df1e1dfee4c26ccf7b2b8f9b07bf5840bfaee Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 31 Jul 2018 10:51:44 +0200 Subject: [PATCH 038/122] Vulkan-Headers --- .gitmodules | 3 +++ generator/Vulkan-Headers | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 generator/Vulkan-Headers diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..8673d0a --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "generator/Vulkan-Headers"] + path = generator/Vulkan-Headers + url = https://github.com/KhronosGroup/Vulkan-Headers diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers new file mode 160000 index 0000000..c4e056d --- /dev/null +++ b/generator/Vulkan-Headers @@ -0,0 +1 @@ +Subproject commit c4e056d365472174471a243dfefbfe66a03564af From 7c8ab2a876a680616e8e1966c099664d843b05b6 Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 12:45:29 +0200 Subject: [PATCH 039/122] Adjust `lib.rs` for examples --- examples/src/lib.rs | 116 ++++++++++++++++++++++---------------------- 1 file changed, 58 insertions(+), 58 deletions(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 8d1ad5a..0d0b0de 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -43,14 +43,14 @@ pub fn record_submit_commandbuffer( let x11_display = window.get_xlib_display().unwrap(); let x11_window = window.get_xlib_window().unwrap(); let x11_create_info = vk::XlibSurfaceCreateInfoKHR { - s_type: vk::StructureType::XlibSurfaceCreateInfoKhr, + s_type: vk::StructureType::XLIB_SURFACE_CREATE_INFO_KHR, p_next: ptr::null(), flags: Default::default(), window: x11_window as vk::Window, @@ -280,7 +280,7 @@ impl ExampleBase { let extension_names_raw = extension_names(); let appinfo = vk::ApplicationInfo { p_application_name: raw_name, - s_type: vk::StructureType::ApplicationInfo, + s_type: vk::StructureType::APPLICATION_INFO, p_next: ptr::null(), application_version: 0, p_engine_name: raw_name, @@ -288,7 +288,7 @@ impl ExampleBase { api_version: vk_make_version!(1, 0, 36), }; let create_info = vk::InstanceCreateInfo { - s_type: vk::StructureType::InstanceCreateInfo, + s_type: vk::StructureType::INSTANCE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), p_application_info: &appinfo, @@ -301,10 +301,10 @@ impl ExampleBase { .create_instance(&create_info, None) .expect("Instance creation error"); let debug_info = vk::DebugReportCallbackCreateInfoEXT { - s_type: vk::StructureType::DebugReportCallbackCreateInfoExt, + s_type: vk::StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, p_next: ptr::null(), - flags: vk::DEBUG_REPORT_ERROR_BIT_EXT | vk::DEBUG_REPORT_WARNING_BIT_EXT - | vk::DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, + flags: vk::DebugReportFlagsEXT::ERROR | vk::DebugReportFlagsEXT::WARNING + | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING, pfn_callback: vulkan_debug_callback, p_user_data: ptr::null_mut(), }; @@ -328,7 +328,7 @@ impl ExampleBase { .enumerate() .filter_map(|(index, ref info)| { let supports_graphic_and_surface = info.queue_flags - .subset(vk::QUEUE_GRAPHICS_BIT) + .subset(vk::QueueFlags::GRAPHICS) && surface_loader.get_physical_device_surface_support_khr( *pdevice, index as u32, @@ -352,7 +352,7 @@ impl ExampleBase { }; let priorities = [1.0]; let queue_info = vk::DeviceQueueCreateInfo { - s_type: vk::StructureType::DeviceQueueCreateInfo, + s_type: vk::StructureType::DEVICE_QUEUE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), queue_family_index: queue_family_index as u32, @@ -360,7 +360,7 @@ impl ExampleBase { queue_count: priorities.len() as u32, }; let device_create_info = vk::DeviceCreateInfo { - s_type: vk::StructureType::DeviceCreateInfo, + s_type: vk::StructureType::DEVICE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), queue_create_info_count: 1, @@ -382,8 +382,8 @@ impl ExampleBase { let surface_format = surface_formats .iter() .map(|sfmt| match sfmt.format { - vk::Format:: => vk::SurfaceFormatKHR { - format: vk::Format::B8g8r8Unorm, + vk::Format::UNDEFINED => vk::SurfaceFormatKHR { + format: vk::Format::B8G8R8_UNORM, color_space: sfmt.color_space, }, _ => sfmt.clone(), @@ -408,9 +408,9 @@ impl ExampleBase { }; let pre_transform = if surface_capabilities .supported_transforms - .subset(vk::SURFACE_TRANSFORM_IDENTITY_BIT_KHR) + .subset(vk::SurfaceTransformFlagsKHR::IDENTITY) { - vk::SURFACE_TRANSFORM_IDENTITY_BIT_KHR + vk::SurfaceTransformFlagsKHR::IDENTITY } else { surface_capabilities.current_transform }; @@ -420,12 +420,12 @@ impl ExampleBase { let present_mode = present_modes .iter() .cloned() - .find(|&mode| mode == vk::PresentModeKHR::Mailbox) - .unwrap_or(vk::PresentModeKHR::Fifo); + .find(|&mode| mode == vk::PresentModeKHR::MAILBOX) + .unwrap_or(vk::PresentModeKHR::FIFO); let swapchain_loader = Swapchain::new(&instance, &device).expect("Unable to load swapchain"); let swapchain_create_info = vk::SwapchainCreateInfoKHR { - s_type: vk::StructureType::SwapchainCreateInfoKhr, + s_type: vk::StructureType::SWAPCHAIN_CREATE_INFO_KHR, p_next: ptr::null(), flags: Default::default(), surface: surface, @@ -433,10 +433,10 @@ impl ExampleBase { image_color_space: surface_format.color_space, image_format: surface_format.format, image_extent: surface_resolution.clone(), - image_usage: vk::IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - image_sharing_mode: vk::SharingMode::Exclusive, + image_usage: vk::ImageUsageFlags::COLOR_ATTACHMENT, + image_sharing_mode: vk::SharingMode::EXCLUSIVE, pre_transform: pre_transform, - composite_alpha: vk::COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + composite_alpha: vk::CompositeAlphaFlagsKHR::OPAQUE, present_mode: present_mode, clipped: 1, old_swapchain: vk::SwapchainKHR::null(), @@ -448,18 +448,18 @@ impl ExampleBase { .create_swapchain_khr(&swapchain_create_info, None) .unwrap(); let pool_create_info = vk::CommandPoolCreateInfo { - s_type: vk::StructureType::CommandPoolCreateInfo, + s_type: vk::StructureType::COMMAND_POOL_CREATE_INFO, p_next: ptr::null(), - flags: vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER_BIT, + flags: vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER, queue_family_index: queue_family_index, }; let pool = device.create_command_pool(&pool_create_info, None).unwrap(); let command_buffer_allocate_info = vk::CommandBufferAllocateInfo { - s_type: vk::StructureType::CommandBufferAllocateInfo, + s_type: vk::StructureType::COMMAND_BUFFER_ALLOCATE_INFO, p_next: ptr::null(), command_buffer_count: 2, command_pool: pool, - level: vk::CommandBufferLevel::Primary, + level: vk::CommandBufferLevel::PRIMARY, }; let command_buffers = device .allocate_command_buffers(&command_buffer_allocate_info) @@ -474,10 +474,10 @@ impl ExampleBase { .iter() .map(|&image| { let create_view_info = vk::ImageViewCreateInfo { - s_type: vk::StructureType::ImageViewCreateInfo, + s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - view_type: vk::ImageViewType::Type2d, + view_type: vk::ImageViewType::TYPE_2D, format: surface_format.format, components: vk::ComponentMapping { r: vk::ComponentSwizzle::R, @@ -486,7 +486,7 @@ impl ExampleBase { a: vk::ComponentSwizzle::A, }, subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + aspect_mask: vk::ImageAspectFlags::COLOR, base_mip_level: 0, level_count: 1, base_array_layer: 0, @@ -499,11 +499,11 @@ impl ExampleBase { .collect(); let device_memory_properties = instance.get_physical_device_memory_properties(pdevice); let depth_image_create_info = vk::ImageCreateInfo { - s_type: vk::StructureType::ImageCreateInfo, + s_type: vk::StructureType::IMAGE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - image_type: vk::ImageType::Type2d, - format: vk::Format::D16Unorm, + image_type: vk::ImageType::TYPE_2D, + format: vk::Format::D16_UNORM, extent: vk::Extent3D { width: surface_resolution.width, height: surface_resolution.height, @@ -511,13 +511,13 @@ impl ExampleBase { }, mip_levels: 1, array_layers: 1, - samples: vk::SAMPLE_COUNT_1_BIT, - tiling: vk::ImageTiling::Optimal, - usage: vk::IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, - sharing_mode: vk::SharingMode::Exclusive, + samples: vk::SampleCountFlags::TYPE_1, + tiling: vk::ImageTiling::OPTIMAL, + usage: vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), - initial_layout: vk::ImageLayout::Undefined, + initial_layout: vk::ImageLayout::UNDEFINED, }; let depth_image = device.create_image(&depth_image_create_info, None).unwrap(); let depth_image_memory_req = device.get_image_memory_requirements(depth_image); @@ -525,11 +525,11 @@ impl ExampleBase { find_memorytype_index( &depth_image_memory_req, &device_memory_properties, - vk::MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + vk::MemoryPropertyFlags::DEVICE_LOCAL, ).expect("Unable to find suitable memory index for depth image."); let depth_image_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: depth_image_memory_req.size, memory_type_index: depth_image_memory_index, @@ -544,23 +544,23 @@ impl ExampleBase { &device, setup_command_buffer, present_queue, - &[vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT], + &[vk::PipelineStageFlags::BOTTOM_OF_PIPE], &[], &[], |device, setup_command_buffer| { let layout_transition_barrier = vk::ImageMemoryBarrier { - s_type: vk::StructureType::ImageMemoryBarrier, + s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, p_next: ptr::null(), src_access_mask: Default::default(), - dst_access_mask: vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT - | vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, - old_layout: vk::ImageLayout::Undefined, - new_layout: vk::ImageLayout::DepthStencilAttachmentOptimal, + dst_access_mask: vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ + | vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE, + old_layout: vk::ImageLayout::UNDEFINED, + new_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, image: depth_image, subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_DEPTH_BIT, + aspect_mask: vk::ImageAspectFlags::DEPTH, base_mip_level: 0, level_count: 1, base_array_layer: 0, @@ -569,8 +569,8 @@ impl ExampleBase { }; device.cmd_pipeline_barrier( setup_command_buffer, - vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - vk::PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, + vk::PipelineStageFlags::BOTTOM_OF_PIPE, + vk::PipelineStageFlags::LATE_FRAGMENT_TESTS, vk::DependencyFlags::empty(), &[], &[], @@ -579,19 +579,19 @@ impl ExampleBase { }, ); let depth_image_view_info = vk::ImageViewCreateInfo { - s_type: vk::StructureType::ImageViewCreateInfo, + s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - view_type: vk::ImageViewType::Type2d, + view_type: vk::ImageViewType::TYPE_2D, format: depth_image_create_info.format, components: vk::ComponentMapping { - r: vk::ComponentSwizzle::Identity, - g: vk::ComponentSwizzle::Identity, - b: vk::ComponentSwizzle::Identity, - a: vk::ComponentSwizzle::Identity, + r: vk::ComponentSwizzle::IDENTITY, + g: vk::ComponentSwizzle::IDENTITY, + b: vk::ComponentSwizzle::IDENTITY, + a: vk::ComponentSwizzle::IDENTITY, }, subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_DEPTH_BIT, + aspect_mask: vk::ImageAspectFlags::DEPTH, base_mip_level: 0, level_count: 1, base_array_layer: 0, @@ -603,7 +603,7 @@ impl ExampleBase { .create_image_view(&depth_image_view_info, None) .unwrap(); let semaphore_create_info = vk::SemaphoreCreateInfo { - s_type: vk::StructureType::SemaphoreCreateInfo, + s_type: vk::StructureType::SEMAPHORE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), }; From c6be07f5f59be8d8942570d5c3c61c6c731452af Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 13:15:39 +0200 Subject: [PATCH 040/122] Port texture example --- examples/src/bin/texture.rs | 296 ++++++++++++++++++------------------ 1 file changed, 148 insertions(+), 148 deletions(-) diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index 4eec9c1..765c3cb 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -36,50 +36,50 @@ fn main() { vk::AttachmentDescription { format: base.surface_format.format, flags: vk::AttachmentDescriptionFlags::empty(), - samples: vk::SAMPLE_COUNT_1_BIT, - load_op: vk::AttachmentLoadOp::Clear, - store_op: vk::AttachmentStoreOp::Store, - stencil_load_op: vk::AttachmentLoadOp::DontCare, - stencil_store_op: vk::AttachmentStoreOp::DontCare, - initial_layout: vk::ImageLayout::Undefined, - final_layout: vk::ImageLayout::PresentSrcKhr, + samples: vk::SampleCountFlags::TYPE_1, + load_op: vk::AttachmentLoadOp::CLEAR, + store_op: vk::AttachmentStoreOp::STORE, + stencil_load_op: vk::AttachmentLoadOp::DONT_CARE, + stencil_store_op: vk::AttachmentStoreOp::DONT_CARE, + initial_layout: vk::ImageLayout::UNDEFINED, + final_layout: vk::ImageLayout::PRESENT_SRC_KHR, }, vk::AttachmentDescription { - format: vk::Format::D16Unorm, + format: vk::Format::D16_UNORM, flags: vk::AttachmentDescriptionFlags::empty(), - samples: vk::SAMPLE_COUNT_1_BIT, - load_op: vk::AttachmentLoadOp::Clear, - store_op: vk::AttachmentStoreOp::DontCare, - stencil_load_op: vk::AttachmentLoadOp::DontCare, - stencil_store_op: vk::AttachmentStoreOp::DontCare, - initial_layout: vk::ImageLayout::DepthStencilAttachmentOptimal, - final_layout: vk::ImageLayout::DepthStencilAttachmentOptimal, + samples: vk::SampleCountFlags::TYPE_1, + load_op: vk::AttachmentLoadOp::CLEAR, + store_op: vk::AttachmentStoreOp::DONT_CARE, + stencil_load_op: vk::AttachmentLoadOp::DONT_CARE, + stencil_store_op: vk::AttachmentStoreOp::DONT_CARE, + initial_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + final_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }, ]; let color_attachment_ref = vk::AttachmentReference { attachment: 0, - layout: vk::ImageLayout::ColorAttachmentOptimal, + layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL, }; let depth_attachment_ref = vk::AttachmentReference { attachment: 1, - layout: vk::ImageLayout::DepthStencilAttachmentOptimal, + layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }; let dependency = vk::SubpassDependency { dependency_flags: Default::default(), - src_subpass: vk::VK_SUBPASS_EXTERNAL, + src_subpass: vk::SUBPASS_EXTERNAL, dst_subpass: Default::default(), - src_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_access_mask: Default::default(), - dst_access_mask: vk::ACCESS_COLOR_ATTACHMENT_READ_BIT - | vk::ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - dst_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_READ + | vk::AccessFlags::COLOR_ATTACHMENT_WRITE, + dst_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, }; let subpass = vk::SubpassDescription { color_attachment_count: 1, p_color_attachments: &color_attachment_ref, p_depth_stencil_attachment: &depth_attachment_ref, flags: Default::default(), - pipeline_bind_point: vk::PipelineBindPoint::Graphics, + pipeline_bind_point: vk::PipelineBindPoint::GRAPHICS, input_attachment_count: 0, p_input_attachments: ptr::null(), p_resolve_attachments: ptr::null(), @@ -87,7 +87,7 @@ fn main() { p_preserve_attachments: ptr::null(), }; let renderpass_create_info = vk::RenderPassCreateInfo { - s_type: vk::StructureType::RenderPassCreateInfo, + s_type: vk::StructureType::RENDER_PASS_CREATE_INFO, flags: Default::default(), p_next: ptr::null(), attachment_count: renderpass_attachments.len() as u32, @@ -105,7 +105,7 @@ fn main() { .map(|&present_image_view| { let framebuffer_attachments = [present_image_view, base.depth_image_view]; let frame_buffer_create_info = vk::FramebufferCreateInfo { - s_type: vk::StructureType::FramebufferCreateInfo, + s_type: vk::StructureType::FRAMEBUFFER_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), render_pass: renderpass, @@ -122,12 +122,12 @@ fn main() { .collect(); let index_buffer_data = [0u32, 1, 2, 2, 3, 0]; let index_buffer_info = vk::BufferCreateInfo { - s_type: vk::StructureType::BufferCreateInfo, + s_type: vk::StructureType::BUFFER_CREATE_INFO, p_next: ptr::null(), flags: vk::BufferCreateFlags::empty(), size: std::mem::size_of_val(&index_buffer_data) as u64, - usage: vk::BUFFER_USAGE_INDEX_BUFFER_BIT, - sharing_mode: vk::SharingMode::Exclusive, + usage: vk::BufferUsageFlags::INDEX_BUFFER, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; @@ -137,10 +137,10 @@ fn main() { find_memorytype_index( &index_buffer_memory_req, &base.device_memory_properties, - vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT, + vk::MemoryPropertyFlags::HOST_VISIBLE, ).expect("Unable to find suitable memorytype for the index buffer."); let index_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: index_buffer_memory_req.size, memory_type_index: index_buffer_memory_index, @@ -186,12 +186,12 @@ fn main() { }, ]; let vertex_input_buffer_info = vk::BufferCreateInfo { - s_type: vk::StructureType::BufferCreateInfo, + s_type: vk::StructureType::BUFFER_CREATE_INFO, p_next: ptr::null(), flags: vk::BufferCreateFlags::empty(), size: std::mem::size_of_val(&vertices) as u64, - usage: vk::BUFFER_USAGE_VERTEX_BUFFER_BIT, - sharing_mode: vk::SharingMode::Exclusive, + usage: vk::BufferUsageFlags::VERTEX_BUFFER, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; @@ -204,11 +204,11 @@ fn main() { find_memorytype_index( &vertex_input_buffer_memory_req, &base.device_memory_properties, - vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT, + vk::MemoryPropertyFlags::HOST_VISIBLE, ).expect("Unable to find suitable memorytype for the vertex buffer."); let vertex_buffer_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: vertex_input_buffer_memory_req.size, memory_type_index: vertex_input_buffer_memory_index, @@ -242,12 +242,12 @@ fn main() { _pad: 0.0, }; let uniform_color_buffer_info = vk::BufferCreateInfo { - s_type: vk::StructureType::BufferCreateInfo, + s_type: vk::StructureType::BUFFER_CREATE_INFO, p_next: ptr::null(), flags: vk::BufferCreateFlags::empty(), size: std::mem::size_of_val(&uniform_color_buffer_data) as u64, - usage: vk::BUFFER_USAGE_UNIFORM_BUFFER_BIT, - sharing_mode: vk::SharingMode::Exclusive, + usage: vk::BufferUsageFlags::UNIFORM_BUFFER, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; @@ -260,11 +260,11 @@ fn main() { find_memorytype_index( &uniform_color_buffer_memory_req, &base.device_memory_properties, - vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT, + vk::MemoryPropertyFlags::HOST_VISIBLE, ).expect("Unable to find suitable memorytype for the vertex buffer."); let uniform_color_buffer_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: uniform_color_buffer_memory_req.size, memory_type_index: uniform_color_buffer_memory_index, @@ -295,12 +295,12 @@ fn main() { let image_dimensions = image.dimensions(); let image_data = image.into_raw(); let image_buffer_info = vk::BufferCreateInfo { - s_type: vk::StructureType::BufferCreateInfo, + s_type: vk::StructureType::BUFFER_CREATE_INFO, p_next: ptr::null(), flags: vk::BufferCreateFlags::empty(), size: (std::mem::size_of::() * image_data.len()) as u64, - usage: vk::BUFFER_USAGE_TRANSFER_SRC_BIT, - sharing_mode: vk::SharingMode::Exclusive, + usage: vk::BufferUsageFlags::TRANSFER_SRC, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; @@ -310,11 +310,11 @@ fn main() { find_memorytype_index( &image_buffer_memory_req, &base.device_memory_properties, - vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT, + vk::MemoryPropertyFlags::HOST_VISIBLE, ).expect("Unable to find suitable memorytype for the vertex buffer."); let image_buffer_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: image_buffer_memory_req.size, memory_type_index: image_buffer_memory_index, @@ -342,11 +342,11 @@ fn main() { .unwrap(); let texture_create_info = vk::ImageCreateInfo { - s_type: vk::StructureType::ImageCreateInfo, + s_type: vk::StructureType::IMAGE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - image_type: vk::ImageType::Type2d, - format: vk::Format::R8g8b8a8Unorm, + image_type: vk::ImageType::TYPE_2D, + format: vk::Format::R8G8B8A8_UNORM, extent: vk::Extent3D { width: image_dimensions.0, height: image_dimensions.1, @@ -354,13 +354,13 @@ fn main() { }, mip_levels: 1, array_layers: 1, - samples: vk::SAMPLE_COUNT_1_BIT, - tiling: vk::ImageTiling::Optimal, - usage: vk::IMAGE_USAGE_TRANSFER_DST_BIT | vk::IMAGE_USAGE_SAMPLED_BIT, - sharing_mode: vk::SharingMode::Exclusive, + samples: vk::SampleCountFlags::TYPE_1, + tiling: vk::ImageTiling::OPTIMAL, + usage: vk::ImageUsageFlags::TRANSFER_DST | vk::ImageUsageFlags::SAMPLED, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), - initial_layout: vk::ImageLayout::Undefined, + initial_layout: vk::ImageLayout::UNDEFINED, }; let texture_image = base.device .create_image(&texture_create_info, None) @@ -370,11 +370,11 @@ fn main() { find_memorytype_index( &texture_memory_req, &base.device_memory_properties, - vk::MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + vk::MemoryPropertyFlags::DEVICE_LOCAL, ).expect("Unable to find suitable memory index for depth image."); let texture_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: texture_memory_req.size, memory_type_index: texture_memory_index, @@ -390,22 +390,22 @@ fn main() { &base.device, base.setup_command_buffer, base.present_queue, - &[vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT], + &[vk::PipelineStageFlags::TOP_OF_PIPE], &[], &[], |device, texture_command_buffer| { let texture_barrier = vk::ImageMemoryBarrier { - s_type: vk::StructureType::ImageMemoryBarrier, + s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, p_next: ptr::null(), src_access_mask: Default::default(), - dst_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT, - old_layout: vk::ImageLayout::Undefined, - new_layout: vk::ImageLayout::TransferDstOptimal, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + dst_access_mask: vk::AccessFlags::TRANSFER_WRITE, + old_layout: vk::ImageLayout::UNDEFINED, + new_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, image: texture_image, subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + aspect_mask: vk::ImageAspectFlags::COLOR, base_mip_level: 0, level_count: 1, base_array_layer: 0, @@ -414,8 +414,8 @@ fn main() { }; device.cmd_pipeline_barrier( texture_command_buffer, - vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - vk::PIPELINE_STAGE_TRANSFER_BIT, + vk::PipelineStageFlags::BOTTOM_OF_PIPE, + vk::PipelineStageFlags::TRANSFER, vk::DependencyFlags::empty(), &[], &[], @@ -424,7 +424,7 @@ fn main() { let buffer_copy_regions = [ vk::BufferImageCopy { image_subresource: vk::ImageSubresourceLayers { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + aspect_mask: vk::ImageAspectFlags::COLOR, mip_level: 0, base_array_layer: 0, layer_count: 1, @@ -445,21 +445,21 @@ fn main() { texture_command_buffer, image_buffer, texture_image, - vk::ImageLayout::TransferDstOptimal, + vk::ImageLayout::TRANSFER_DST_OPTIMAL, &buffer_copy_regions, ); let texture_barrier_end = vk::ImageMemoryBarrier { - s_type: vk::StructureType::ImageMemoryBarrier, + s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, p_next: ptr::null(), - src_access_mask: vk::ACCESS_TRANSFER_WRITE_BIT, - dst_access_mask: vk::ACCESS_SHADER_READ_BIT, - old_layout: vk::ImageLayout::TransferDstOptimal, - new_layout: vk::ImageLayout::ShaderReadOnlyOptimal, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + src_access_mask: vk::AccessFlags::TRANSFER_WRITE, + dst_access_mask: vk::AccessFlags::SHADER_READ, + old_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, + new_layout: vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, image: texture_image, subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + aspect_mask: vk::ImageAspectFlags::COLOR, base_mip_level: 0, level_count: 1, base_array_layer: 0, @@ -468,8 +468,8 @@ fn main() { }; device.cmd_pipeline_barrier( texture_command_buffer, - vk::PIPELINE_STAGE_TRANSFER_BIT, - vk::PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + vk::PipelineStageFlags::TRANSFER, + vk::PipelineStageFlags::FRAGMENT_SHADER, vk::DependencyFlags::empty(), &[], &[], @@ -479,33 +479,33 @@ fn main() { ); let sampler_info = vk::SamplerCreateInfo { - s_type: vk::StructureType::SamplerCreateInfo, + s_type: vk::StructureType::SAMPLER_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - mag_filter: vk::Filter::Linear, - min_filter: vk::Filter::Linear, - mipmap_mode: vk::SamplerMipmapMode::Linear, - address_mode_u: vk::SamplerAddressMode::MirroredRepeat, - address_mode_v: vk::SamplerAddressMode::MirroredRepeat, - address_mode_w: vk::SamplerAddressMode::MirroredRepeat, + mag_filter: vk::Filter::LINEAR, + min_filter: vk::Filter::LINEAR, + mipmap_mode: vk::SamplerMipmapMode::LINEAR, + address_mode_u: vk::SamplerAddressMode::MIRRORED_REPEAT, + address_mode_v: vk::SamplerAddressMode::MIRRORED_REPEAT, + address_mode_w: vk::SamplerAddressMode::MIRRORED_REPEAT, mip_lod_bias: 0.0, min_lod: 0.0, max_lod: 0.0, anisotropy_enable: 0, max_anisotropy: 1.0, - border_color: vk::BorderColor::FloatOpaqueWhite, + border_color: vk::BorderColor::FLOAT_OPAQUE_WHITE, compare_enable: 0, - compare_op: vk::CompareOp::Never, + compare_op: vk::CompareOp::NEVER, unnormalized_coordinates: 0, }; let sampler = base.device.create_sampler(&sampler_info, None).unwrap(); let tex_image_view_info = vk::ImageViewCreateInfo { - s_type: vk::StructureType::ImageViewCreateInfo, + s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - view_type: vk::ImageViewType::Type2d, + view_type: vk::ImageViewType::TYPE_2D, format: texture_create_info.format, components: vk::ComponentMapping { r: vk::ComponentSwizzle::R, @@ -514,7 +514,7 @@ fn main() { a: vk::ComponentSwizzle::A, }, subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::IMAGE_ASPECT_COLOR_BIT, + aspect_mask: vk::ImageAspectFlags::COLOR, base_mip_level: 0, level_count: 1, base_array_layer: 0, @@ -527,16 +527,16 @@ fn main() { .unwrap(); let descriptor_sizes = [ vk::DescriptorPoolSize { - typ: vk::DescriptorType::UniformBuffer, + ty: vk::DescriptorType::UNIFORM_BUFFER, descriptor_count: 1, }, vk::DescriptorPoolSize { - typ: vk::DescriptorType::CombinedImageSampler, + ty: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, descriptor_count: 1, }, ]; let descriptor_pool_info = vk::DescriptorPoolCreateInfo { - s_type: vk::StructureType::DescriptorPoolCreateInfo, + s_type: vk::StructureType::DESCRIPTOR_POOL_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), pool_size_count: descriptor_sizes.len() as u32, @@ -549,21 +549,21 @@ fn main() { let desc_layout_bindings = [ vk::DescriptorSetLayoutBinding { binding: 0, - descriptor_type: vk::DescriptorType::UniformBuffer, + descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, descriptor_count: 1, - stage_flags: vk::SHADER_STAGE_FRAGMENT_BIT, + stage_flags: vk::ShaderStageFlags::FRAGMENT, p_immutable_samplers: ptr::null(), }, vk::DescriptorSetLayoutBinding { binding: 1, - descriptor_type: vk::DescriptorType::CombinedImageSampler, + descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, descriptor_count: 1, - stage_flags: vk::SHADER_STAGE_FRAGMENT_BIT, + stage_flags: vk::ShaderStageFlags::FRAGMENT, p_immutable_samplers: ptr::null(), }, ]; let descriptor_info = vk::DescriptorSetLayoutCreateInfo { - s_type: vk::StructureType::DescriptorSetLayoutCreateInfo, + s_type: vk::StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), binding_count: desc_layout_bindings.len() as u32, @@ -576,7 +576,7 @@ fn main() { .unwrap(), ]; let desc_alloc_info = vk::DescriptorSetAllocateInfo { - s_type: vk::StructureType::DescriptorSetAllocateInfo, + s_type: vk::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, p_next: ptr::null(), descriptor_pool: descriptor_pool, descriptor_set_count: desc_set_layouts.len() as u32, @@ -593,32 +593,32 @@ fn main() { }; let tex_descriptor = vk::DescriptorImageInfo { - image_layout: vk::ImageLayout::General, + image_layout: vk::ImageLayout::GENERAL, image_view: tex_image_view, sampler: sampler, }; let write_desc_sets = [ vk::WriteDescriptorSet { - s_type: vk::StructureType::WriteDescriptorSet, + s_type: vk::StructureType::WRITE_DESCRIPTOR_SET, p_next: ptr::null(), dst_set: descriptor_sets[0], dst_binding: 0, dst_array_element: 0, descriptor_count: 1, - descriptor_type: vk::DescriptorType::UniformBuffer, + descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, p_image_info: ptr::null(), p_buffer_info: &uniform_color_buffer_descriptor, p_texel_buffer_view: ptr::null(), }, vk::WriteDescriptorSet { - s_type: vk::StructureType::WriteDescriptorSet, + s_type: vk::StructureType::WRITE_DESCRIPTOR_SET, p_next: ptr::null(), dst_set: descriptor_sets[0], dst_binding: 1, dst_array_element: 0, descriptor_count: 1, - descriptor_type: vk::DescriptorType::CombinedImageSampler, + descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, p_image_info: &tex_descriptor, p_buffer_info: ptr::null(), p_texel_buffer_view: ptr::null(), @@ -636,7 +636,7 @@ fn main() { .filter_map(|byte| byte.ok()) .collect(); let vertex_shader_info = vk::ShaderModuleCreateInfo { - s_type: vk::StructureType::ShaderModuleCreateInfo, + s_type: vk::StructureType::SHADER_MODULE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), code_size: vertex_bytes.len(), @@ -644,7 +644,7 @@ fn main() { }; let frag_bytes: Vec = frag_spv_file.bytes().filter_map(|byte| byte.ok()).collect(); let frag_shader_info = vk::ShaderModuleCreateInfo { - s_type: vk::StructureType::ShaderModuleCreateInfo, + s_type: vk::StructureType::SHADER_MODULE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), code_size: frag_bytes.len(), @@ -659,7 +659,7 @@ fn main() { .expect("Fragment shader module error"); let layout_create_info = vk::PipelineLayoutCreateInfo { - s_type: vk::StructureType::PipelineLayoutCreateInfo, + s_type: vk::StructureType::PIPELINE_LAYOUT_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), set_layout_count: desc_set_layouts.len() as u32, @@ -675,47 +675,47 @@ fn main() { let shader_entry_name = CString::new("main").unwrap(); let shader_stage_create_infos = [ vk::PipelineShaderStageCreateInfo { - s_type: vk::StructureType::PipelineShaderStageCreateInfo, + s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), module: vertex_shader_module, p_name: shader_entry_name.as_ptr(), p_specialization_info: ptr::null(), - stage: vk::SHADER_STAGE_VERTEX_BIT, + stage: vk::ShaderStageFlags::VERTEX, }, vk::PipelineShaderStageCreateInfo { - s_type: vk::StructureType::PipelineShaderStageCreateInfo, + s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), module: fragment_shader_module, p_name: shader_entry_name.as_ptr(), p_specialization_info: ptr::null(), - stage: vk::SHADER_STAGE_FRAGMENT_BIT, + stage: vk::ShaderStageFlags::FRAGMENT, }, ]; let vertex_input_binding_descriptions = [ vk::VertexInputBindingDescription { binding: 0, stride: mem::size_of::() as u32, - input_rate: vk::VertexInputRate::Vertex, + input_rate: vk::VertexInputRate::VERTEX, }, ]; let vertex_input_attribute_descriptions = [ vk::VertexInputAttributeDescription { location: 0, binding: 0, - format: vk::Format::R32g32b32a32Sfloat, + format: vk::Format::R32G32B32A32_SFLOAT, offset: offset_of!(Vertex, pos) as u32, }, vk::VertexInputAttributeDescription { location: 1, binding: 0, - format: vk::Format::R32g32Sfloat, + format: vk::Format::R32G32_SFLOAT, offset: offset_of!(Vertex, uv) as u32, }, ]; let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo { - s_type: vk::StructureType::PipelineVertexInputStateCreateInfo, + s_type: vk::StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), vertex_attribute_description_count: vertex_input_attribute_descriptions.len() as u32, @@ -724,11 +724,11 @@ fn main() { p_vertex_binding_descriptions: vertex_input_binding_descriptions.as_ptr(), }; let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo { - s_type: vk::StructureType::PipelineInputAssemblyStateCreateInfo, + s_type: vk::StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, flags: Default::default(), p_next: ptr::null(), primitive_restart_enable: 0, - topology: vk::PrimitiveTopology::TriangleList, + topology: vk::PrimitiveTopology::TRIANGLE_LIST, }; let viewports = [ vk::Viewport { @@ -747,7 +747,7 @@ fn main() { }, ]; let viewport_state_info = vk::PipelineViewportStateCreateInfo { - s_type: vk::StructureType::PipelineViewportStateCreateInfo, + s_type: vk::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), scissor_count: scissors.len() as u32, @@ -756,25 +756,25 @@ fn main() { p_viewports: viewports.as_ptr(), }; let rasterization_info = vk::PipelineRasterizationStateCreateInfo { - s_type: vk::StructureType::PipelineRasterizationStateCreateInfo, + s_type: vk::StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - cull_mode: vk::CULL_MODE_NONE, + cull_mode: vk::CullModeFlags::NONE, depth_bias_clamp: 0.0, depth_bias_constant_factor: 0.0, depth_bias_enable: 0, depth_bias_slope_factor: 0.0, depth_clamp_enable: 0, - front_face: vk::FrontFace::CounterClockwise, + front_face: vk::FrontFace::COUNTER_CLOCKWISE, line_width: 1.0, - polygon_mode: vk::PolygonMode::Fill, + polygon_mode: vk::PolygonMode::FILL, rasterizer_discard_enable: 0, }; let multisample_state_info = vk::PipelineMultisampleStateCreateInfo { - s_type: vk::StructureType::PipelineMultisampleStateCreateInfo, + s_type: vk::StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, flags: Default::default(), p_next: ptr::null(), - rasterization_samples: vk::SAMPLE_COUNT_1_BIT, + rasterization_samples: vk::SampleCountFlags::TYPE_1, sample_shading_enable: 0, min_sample_shading: 0.0, p_sample_mask: ptr::null(), @@ -782,21 +782,21 @@ fn main() { alpha_to_coverage_enable: 0, }; let noop_stencil_state = vk::StencilOpState { - fail_op: vk::StencilOp::Keep, - pass_op: vk::StencilOp::Keep, - depth_fail_op: vk::StencilOp::Keep, - compare_op: vk::CompareOp::Always, + fail_op: vk::StencilOp::KEEP, + pass_op: vk::StencilOp::KEEP, + depth_fail_op: vk::StencilOp::KEEP, + compare_op: vk::CompareOp::ALWAYS, compare_mask: 0, write_mask: 0, reference: 0, }; let depth_state_info = vk::PipelineDepthStencilStateCreateInfo { - s_type: vk::StructureType::PipelineDepthStencilStateCreateInfo, + s_type: vk::StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), depth_test_enable: 1, depth_write_enable: 1, - depth_compare_op: vk::CompareOp::LessOrEqual, + depth_compare_op: vk::CompareOp::LESS_OR_EQUAL, depth_bounds_test_enable: 0, stencil_test_enable: 0, front: noop_stencil_state.clone(), @@ -807,35 +807,35 @@ fn main() { let color_blend_attachment_states = [ vk::PipelineColorBlendAttachmentState { blend_enable: 0, - src_color_blend_factor: vk::BlendFactor::SrcColor, - dst_color_blend_factor: vk::BlendFactor::OneMinusDstColor, - color_blend_op: vk::BlendOp::Add, - src_alpha_blend_factor: vk::BlendFactor::Zero, - dst_alpha_blend_factor: vk::BlendFactor::Zero, - alpha_blend_op: vk::BlendOp::Add, + src_color_blend_factor: vk::BlendFactor::SRC_COLOR, + dst_color_blend_factor: vk::BlendFactor::ONE_MINUS_DST_COLOR, + color_blend_op: vk::BlendOp::ADD, + src_alpha_blend_factor: vk::BlendFactor::ZERO, + dst_alpha_blend_factor: vk::BlendFactor::ZERO, + alpha_blend_op: vk::BlendOp::ADD, color_write_mask: vk::ColorComponentFlags::all(), }, ]; let color_blend_state = vk::PipelineColorBlendStateCreateInfo { - s_type: vk::StructureType::PipelineColorBlendStateCreateInfo, + s_type: vk::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), logic_op_enable: 0, - logic_op: vk::LogicOp::Clear, + logic_op: vk::LogicOp::CLEAR, attachment_count: color_blend_attachment_states.len() as u32, p_attachments: color_blend_attachment_states.as_ptr(), blend_constants: [0.0, 0.0, 0.0, 0.0], }; - let dynamic_state = [vk::DynamicState::Viewport, vk::DynamicState::Scissor]; + let dynamic_state = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR]; let dynamic_state_info = vk::PipelineDynamicStateCreateInfo { - s_type: vk::StructureType::PipelineDynamicStateCreateInfo, + s_type: vk::StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), dynamic_state_count: dynamic_state.len() as u32, p_dynamic_states: dynamic_state.as_ptr(), }; let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo { - s_type: vk::StructureType::GraphicsPipelineCreateInfo, + s_type: vk::StructureType::GRAPHICS_PIPELINE_CREATE_INFO, p_next: ptr::null(), flags: vk::PipelineCreateFlags::empty(), stage_count: shader_stage_create_infos.len() as u32, @@ -877,7 +877,7 @@ fn main() { }, }, vk::ClearValue { - depth: vk::ClearDepthStencilValue { + depth_stencil: vk::ClearDepthStencilValue { depth: 1.0, stencil: 0, }, @@ -885,7 +885,7 @@ fn main() { ]; let render_pass_begin_info = vk::RenderPassBeginInfo { - s_type: vk::StructureType::RenderPassBeginInfo, + s_type: vk::StructureType::RENDER_PASS_BEGIN_INFO, p_next: ptr::null(), render_pass: renderpass, framebuffer: framebuffers[present_index as usize], @@ -899,21 +899,21 @@ fn main() { record_submit_commandbuffer(&base.device, base.draw_command_buffer, base.present_queue, - &[vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT], + &[vk::PipelineStageFlags::BOTTOM_OF_PIPE], &[base.present_complete_semaphore], &[base.rendering_complete_semaphore], |device, draw_command_buffer| { device.cmd_begin_render_pass(draw_command_buffer, &render_pass_begin_info, - vk::SubpassContents::Inline); + vk::SubpassContents::INLINE); device.cmd_bind_descriptor_sets(draw_command_buffer, - vk::PipelineBindPoint::Graphics, + vk::PipelineBindPoint::GRAPHICS, pipeline_layout, 0, &descriptor_sets[..], &[]); device.cmd_bind_pipeline(draw_command_buffer, - vk::PipelineBindPoint::Graphics, + vk::PipelineBindPoint::GRAPHICS, graphic_pipeline); device.cmd_set_viewport(draw_command_buffer, 0, &viewports); device.cmd_set_scissor(draw_command_buffer, 0, &scissors); @@ -922,7 +922,7 @@ fn main() { device.cmd_bind_index_buffer(draw_command_buffer, index_buffer, 0, - vk::IndexType::Uint32); + vk::IndexType::UINT32); device.cmd_draw_indexed(draw_command_buffer, index_buffer_data.len() as u32, 1, @@ -935,7 +935,7 @@ fn main() { }); //let mut present_info_err = mem::uninitialized(); let present_info = vk::PresentInfoKHR { - s_type: vk::StructureType::PresentInfoKhr, + s_type: vk::StructureType::PRESENT_INFO_KHR, p_next: ptr::null(), wait_semaphore_count: 1, p_wait_semaphores: &base.rendering_complete_semaphore, From 253f79eef533c7677125eca5538b20268c15162b Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 13:16:04 +0200 Subject: [PATCH 041/122] Adjust examples lib to match #75 --- examples/src/lib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 0d0b0de..81750a0 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -556,8 +556,8 @@ impl ExampleBase { | vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE, old_layout: vk::ImageLayout::UNDEFINED, new_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, image: depth_image, subresource_range: vk::ImageSubresourceRange { aspect_mask: vk::ImageAspectFlags::DEPTH, From dc80b74ea909c68724951c6b7de5d3e94d290427 Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 13:22:16 +0200 Subject: [PATCH 042/122] Port triangle example --- examples/src/bin/triangle.rs | 158 +++++++++++++++++------------------ 1 file changed, 79 insertions(+), 79 deletions(-) diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index e05837d..9192e6b 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -27,50 +27,50 @@ fn main() { vk::AttachmentDescription { format: base.surface_format.format, flags: vk::AttachmentDescriptionFlags::empty(), - samples: vk::SAMPLE_COUNT_1_BIT, - load_op: vk::AttachmentLoadOp::Clear, - store_op: vk::AttachmentStoreOp::Store, - stencil_load_op: vk::AttachmentLoadOp::DontCare, - stencil_store_op: vk::AttachmentStoreOp::DontCare, - initial_layout: vk::ImageLayout::Undefined, - final_layout: vk::ImageLayout::PresentSrcKhr, + samples: vk::SampleCountFlags::TYPE_1, + load_op: vk::AttachmentLoadOp::CLEAR, + store_op: vk::AttachmentStoreOp::STORE, + stencil_load_op: vk::AttachmentLoadOp::DONT_CARE, + stencil_store_op: vk::AttachmentStoreOp::DONT_CARE, + initial_layout: vk::ImageLayout::UNDEFINED, + final_layout: vk::ImageLayout::PRESENT_SRC_KHR, }, vk::AttachmentDescription { - format: vk::Format::D16Unorm, + format: vk::Format::D16_UNORM, flags: vk::AttachmentDescriptionFlags::empty(), - samples: vk::SAMPLE_COUNT_1_BIT, - load_op: vk::AttachmentLoadOp::Clear, - store_op: vk::AttachmentStoreOp::DontCare, - stencil_load_op: vk::AttachmentLoadOp::DontCare, - stencil_store_op: vk::AttachmentStoreOp::DontCare, - initial_layout: vk::ImageLayout::DepthStencilAttachmentOptimal, - final_layout: vk::ImageLayout::DepthStencilAttachmentOptimal, + samples: vk::SampleCountFlags::TYPE_1, + load_op: vk::AttachmentLoadOp::CLEAR, + store_op: vk::AttachmentStoreOp::DONT_CARE, + stencil_load_op: vk::AttachmentLoadOp::DONT_CARE, + stencil_store_op: vk::AttachmentStoreOp::DONT_CARE, + initial_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + final_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }, ]; let color_attachment_ref = vk::AttachmentReference { attachment: 0, - layout: vk::ImageLayout::ColorAttachmentOptimal, + layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL, }; let depth_attachment_ref = vk::AttachmentReference { attachment: 1, - layout: vk::ImageLayout::DepthStencilAttachmentOptimal, + layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }; let dependency = vk::SubpassDependency { dependency_flags: Default::default(), - src_subpass: vk::VK_SUBPASS_EXTERNAL, + src_subpass: vk::SUBPASS_EXTERNAL, dst_subpass: Default::default(), - src_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_access_mask: Default::default(), - dst_access_mask: vk::ACCESS_COLOR_ATTACHMENT_READ_BIT - | vk::ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - dst_stage_mask: vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_READ + | vk::AccessFlags::COLOR_ATTACHMENT_WRITE, + dst_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, }; let subpass = vk::SubpassDescription { color_attachment_count: 1, p_color_attachments: &color_attachment_ref, p_depth_stencil_attachment: &depth_attachment_ref, flags: Default::default(), - pipeline_bind_point: vk::PipelineBindPoint::Graphics, + pipeline_bind_point: vk::PipelineBindPoint::GRAPHICS, input_attachment_count: 0, p_input_attachments: ptr::null(), p_resolve_attachments: ptr::null(), @@ -78,7 +78,7 @@ fn main() { p_preserve_attachments: ptr::null(), }; let renderpass_create_info = vk::RenderPassCreateInfo { - s_type: vk::StructureType::RenderPassCreateInfo, + s_type: vk::StructureType::RENDER_PASS_CREATE_INFO, flags: Default::default(), p_next: ptr::null(), attachment_count: renderpass_attachments.len() as u32, @@ -96,7 +96,7 @@ fn main() { .map(|&present_image_view| { let framebuffer_attachments = [present_image_view, base.depth_image_view]; let frame_buffer_create_info = vk::FramebufferCreateInfo { - s_type: vk::StructureType::FramebufferCreateInfo, + s_type: vk::StructureType::FRAMEBUFFER_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), render_pass: renderpass, @@ -113,12 +113,12 @@ fn main() { .collect(); let index_buffer_data = [0u32, 1, 2]; let index_buffer_info = vk::BufferCreateInfo { - s_type: vk::StructureType::BufferCreateInfo, + s_type: vk::StructureType::BUFFER_CREATE_INFO, p_next: ptr::null(), flags: vk::BufferCreateFlags::empty(), size: std::mem::size_of_val(&index_buffer_data) as u64, - usage: vk::BUFFER_USAGE_INDEX_BUFFER_BIT, - sharing_mode: vk::SharingMode::Exclusive, + usage: vk::BufferUsageFlags::INDEX_BUFFER, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; @@ -128,10 +128,10 @@ fn main() { find_memorytype_index( &index_buffer_memory_req, &base.device_memory_properties, - vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT, + vk::MemoryPropertyFlags::HOST_VISIBLE, ).expect("Unable to find suitable memorytype for the index buffer."); let index_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: index_buffer_memory_req.size, memory_type_index: index_buffer_memory_index, @@ -159,12 +159,12 @@ fn main() { .unwrap(); let vertex_input_buffer_info = vk::BufferCreateInfo { - s_type: vk::StructureType::BufferCreateInfo, + s_type: vk::StructureType::BUFFER_CREATE_INFO, p_next: ptr::null(), flags: vk::BufferCreateFlags::empty(), size: 3 * std::mem::size_of::() as u64, - usage: vk::BUFFER_USAGE_VERTEX_BUFFER_BIT, - sharing_mode: vk::SharingMode::Exclusive, + usage: vk::BufferUsageFlags::VERTEX_BUFFER, + sharing_mode: vk::SharingMode::EXCLUSIVE, queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; @@ -177,11 +177,11 @@ fn main() { find_memorytype_index( &vertex_input_buffer_memory_req, &base.device_memory_properties, - vk::MEMORY_PROPERTY_HOST_VISIBLE_BIT, + vk::MemoryPropertyFlags::HOST_VISIBLE, ).expect("Unable to find suitable memorytype for the vertex buffer."); let vertex_buffer_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MemoryAllocateInfo, + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, p_next: ptr::null(), allocation_size: vertex_input_buffer_memory_req.size, memory_type_index: vertex_input_buffer_memory_index, @@ -231,7 +231,7 @@ fn main() { .filter_map(|byte| byte.ok()) .collect(); let vertex_shader_info = vk::ShaderModuleCreateInfo { - s_type: vk::StructureType::ShaderModuleCreateInfo, + s_type: vk::StructureType::SHADER_MODULE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), code_size: vertex_bytes.len(), @@ -239,7 +239,7 @@ fn main() { }; let frag_bytes: Vec = frag_spv_file.bytes().filter_map(|byte| byte.ok()).collect(); let frag_shader_info = vk::ShaderModuleCreateInfo { - s_type: vk::StructureType::ShaderModuleCreateInfo, + s_type: vk::StructureType::SHADER_MODULE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), code_size: frag_bytes.len(), @@ -254,7 +254,7 @@ fn main() { .expect("Fragment shader module error"); let layout_create_info = vk::PipelineLayoutCreateInfo { - s_type: vk::StructureType::PipelineLayoutCreateInfo, + s_type: vk::StructureType::PIPELINE_LAYOUT_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), set_layout_count: 0, @@ -270,47 +270,47 @@ fn main() { let shader_entry_name = CString::new("main").unwrap(); let shader_stage_create_infos = [ vk::PipelineShaderStageCreateInfo { - s_type: vk::StructureType::PipelineShaderStageCreateInfo, + s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), module: vertex_shader_module, p_name: shader_entry_name.as_ptr(), p_specialization_info: ptr::null(), - stage: vk::SHADER_STAGE_VERTEX_BIT, + stage: vk::ShaderStageFlags::VERTEX, }, vk::PipelineShaderStageCreateInfo { - s_type: vk::StructureType::PipelineShaderStageCreateInfo, + s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), module: fragment_shader_module, p_name: shader_entry_name.as_ptr(), p_specialization_info: ptr::null(), - stage: vk::SHADER_STAGE_FRAGMENT_BIT, + stage: vk::ShaderStageFlags::FRAGMENT, }, ]; let vertex_input_binding_descriptions = [ vk::VertexInputBindingDescription { binding: 0, stride: mem::size_of::() as u32, - input_rate: vk::VertexInputRate::Vertex, + input_rate: vk::VertexInputRate::VERTEX, }, ]; let vertex_input_attribute_descriptions = [ vk::VertexInputAttributeDescription { location: 0, binding: 0, - format: vk::Format::R32g32b32a32Sfloat, + format: vk::Format::R32G32B32A32_SFLOAT, offset: offset_of!(Vertex, pos) as u32, }, vk::VertexInputAttributeDescription { location: 1, binding: 0, - format: vk::Format::R32g32b32a32Sfloat, + format: vk::Format::R32G32B32A32_SFLOAT, offset: offset_of!(Vertex, color) as u32, }, ]; let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo { - s_type: vk::StructureType::PipelineVertexInputStateCreateInfo, + s_type: vk::StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), vertex_attribute_description_count: vertex_input_attribute_descriptions.len() as u32, @@ -319,11 +319,11 @@ fn main() { p_vertex_binding_descriptions: vertex_input_binding_descriptions.as_ptr(), }; let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo { - s_type: vk::StructureType::PipelineInputAssemblyStateCreateInfo, + s_type: vk::StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, flags: Default::default(), p_next: ptr::null(), primitive_restart_enable: 0, - topology: vk::PrimitiveTopology::TriangleList, + topology: vk::PrimitiveTopology::TRIANGLE_LIST, }; let viewports = [ vk::Viewport { @@ -342,7 +342,7 @@ fn main() { }, ]; let viewport_state_info = vk::PipelineViewportStateCreateInfo { - s_type: vk::StructureType::PipelineViewportStateCreateInfo, + s_type: vk::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), scissor_count: scissors.len() as u32, @@ -351,25 +351,25 @@ fn main() { p_viewports: viewports.as_ptr(), }; let rasterization_info = vk::PipelineRasterizationStateCreateInfo { - s_type: vk::StructureType::PipelineRasterizationStateCreateInfo, + s_type: vk::StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), - cull_mode: vk::CULL_MODE_NONE, + cull_mode: vk::CullModeFlags::NONE, depth_bias_clamp: 0.0, depth_bias_constant_factor: 0.0, depth_bias_enable: 0, depth_bias_slope_factor: 0.0, depth_clamp_enable: 0, - front_face: vk::FrontFace::CounterClockwise, + front_face: vk::FrontFace::COUNTER_CLOCKWISE, line_width: 1.0, - polygon_mode: vk::PolygonMode::Fill, + polygon_mode: vk::PolygonMode::FILL, rasterizer_discard_enable: 0, }; let multisample_state_info = vk::PipelineMultisampleStateCreateInfo { - s_type: vk::StructureType::PipelineMultisampleStateCreateInfo, + s_type: vk::StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, flags: Default::default(), p_next: ptr::null(), - rasterization_samples: vk::SAMPLE_COUNT_1_BIT, + rasterization_samples: vk::SampleCountFlags::TYPE_1, sample_shading_enable: 0, min_sample_shading: 0.0, p_sample_mask: ptr::null(), @@ -377,21 +377,21 @@ fn main() { alpha_to_coverage_enable: 0, }; let noop_stencil_state = vk::StencilOpState { - fail_op: vk::StencilOp::Keep, - pass_op: vk::StencilOp::Keep, - depth_fail_op: vk::StencilOp::Keep, - compare_op: vk::CompareOp::Always, + fail_op: vk::StencilOp::KEEP, + pass_op: vk::StencilOp::KEEP, + depth_fail_op: vk::StencilOp::KEEP, + compare_op: vk::CompareOp::ALWAYS, compare_mask: 0, write_mask: 0, reference: 0, }; let depth_state_info = vk::PipelineDepthStencilStateCreateInfo { - s_type: vk::StructureType::PipelineDepthStencilStateCreateInfo, + s_type: vk::StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), depth_test_enable: 1, depth_write_enable: 1, - depth_compare_op: vk::CompareOp::LessOrEqual, + depth_compare_op: vk::CompareOp::LESS_OR_EQUAL, depth_bounds_test_enable: 0, stencil_test_enable: 0, front: noop_stencil_state.clone(), @@ -402,35 +402,35 @@ fn main() { let color_blend_attachment_states = [ vk::PipelineColorBlendAttachmentState { blend_enable: 0, - src_color_blend_factor: vk::BlendFactor::SrcColor, - dst_color_blend_factor: vk::BlendFactor::OneMinusDstColor, - color_blend_op: vk::BlendOp::Add, - src_alpha_blend_factor: vk::BlendFactor::Zero, - dst_alpha_blend_factor: vk::BlendFactor::Zero, - alpha_blend_op: vk::BlendOp::Add, + src_color_blend_factor: vk::BlendFactor::SRC_COLOR, + dst_color_blend_factor: vk::BlendFactor::ONE_MINUS_DST_COLOR, + color_blend_op: vk::BlendOp::ADD, + src_alpha_blend_factor: vk::BlendFactor::ZERO, + dst_alpha_blend_factor: vk::BlendFactor::ZERO, + alpha_blend_op: vk::BlendOp::ADD, color_write_mask: vk::ColorComponentFlags::all(), }, ]; let color_blend_state = vk::PipelineColorBlendStateCreateInfo { - s_type: vk::StructureType::PipelineColorBlendStateCreateInfo, + s_type: vk::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), logic_op_enable: 0, - logic_op: vk::LogicOp::Clear, + logic_op: vk::LogicOp::CLEAR, attachment_count: color_blend_attachment_states.len() as u32, p_attachments: color_blend_attachment_states.as_ptr(), blend_constants: [0.0, 0.0, 0.0, 0.0], }; - let dynamic_state = [vk::DynamicState::Viewport, vk::DynamicState::Scissor]; + let dynamic_state = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR]; let dynamic_state_info = vk::PipelineDynamicStateCreateInfo { - s_type: vk::StructureType::PipelineDynamicStateCreateInfo, + s_type: vk::StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO, p_next: ptr::null(), flags: Default::default(), dynamic_state_count: dynamic_state.len() as u32, p_dynamic_states: dynamic_state.as_ptr(), }; let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo { - s_type: vk::StructureType::GraphicsPipelineCreateInfo, + s_type: vk::StructureType::GRAPHICS_PIPELINE_CREATE_INFO, p_next: ptr::null(), flags: vk::PipelineCreateFlags::empty(), stage_count: shader_stage_create_infos.len() as u32, @@ -472,7 +472,7 @@ fn main() { }, }, vk::ClearValue { - depth: vk::ClearDepthStencilValue { + depth_stencil: vk::ClearDepthStencilValue { depth: 1.0, stencil: 0, }, @@ -480,7 +480,7 @@ fn main() { ]; let render_pass_begin_info = vk::RenderPassBeginInfo { - s_type: vk::StructureType::RenderPassBeginInfo, + s_type: vk::StructureType::RENDER_PASS_BEGIN_INFO, p_next: ptr::null(), render_pass: renderpass, framebuffer: framebuffers[present_index as usize], @@ -495,18 +495,18 @@ fn main() { &base.device, base.draw_command_buffer, base.present_queue, - &[vk::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT], + &[vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT], &[base.present_complete_semaphore], &[base.rendering_complete_semaphore], |device, draw_command_buffer| { device.cmd_begin_render_pass( draw_command_buffer, &render_pass_begin_info, - vk::SubpassContents::Inline, + vk::SubpassContents::INLINE, ); device.cmd_bind_pipeline( draw_command_buffer, - vk::PipelineBindPoint::Graphics, + vk::PipelineBindPoint::GRAPHICS, graphic_pipeline, ); device.cmd_set_viewport(draw_command_buffer, 0, &viewports); @@ -521,7 +521,7 @@ fn main() { draw_command_buffer, index_buffer, 0, - vk::IndexType::Uint32, + vk::IndexType::UINT32, ); device.cmd_draw_indexed( draw_command_buffer, @@ -538,7 +538,7 @@ fn main() { ); //let mut present_info_err = mem::uninitialized(); let present_info = vk::PresentInfoKHR { - s_type: vk::StructureType::PresentInfoKhr, + s_type: vk::StructureType::PRESENT_INFO_KHR, p_next: ptr::null(), wait_semaphore_count: 1, p_wait_semaphores: &base.rendering_complete_semaphore, From 56bf57acf5b7a58442f6ad734d8f75b9535a0694 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 31 Jul 2018 13:30:35 +0200 Subject: [PATCH 043/122] Fix *const *const ptr --- ash/src/vk.rs | 12 ++++++------ generator/src/lib.rs | 2 +- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 24aa663..476ded1 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -5132,9 +5132,9 @@ pub struct DeviceCreateInfo { pub queue_create_info_count: uint32_t, pub p_queue_create_infos: *const DeviceQueueCreateInfo, pub enabled_layer_count: uint32_t, - pub pp_enabled_layer_names: *const c_char, + pub pp_enabled_layer_names: *const *const c_char, pub enabled_extension_count: uint32_t, - pub pp_enabled_extension_names: *const c_char, + pub pp_enabled_extension_names: *const *const c_char, pub p_enabled_features: *const PhysicalDeviceFeatures, } impl ::std::default::Default for DeviceCreateInfo { @@ -5161,9 +5161,9 @@ pub struct InstanceCreateInfo { pub flags: InstanceCreateFlags, pub p_application_info: *const ApplicationInfo, pub enabled_layer_count: uint32_t, - pub pp_enabled_layer_names: *const c_char, + pub pp_enabled_layer_names: *const *const c_char, pub enabled_extension_count: uint32_t, - pub pp_enabled_extension_names: *const c_char, + pub pp_enabled_extension_names: *const *const c_char, } impl ::std::default::Default for InstanceCreateInfo { fn default() -> InstanceCreateInfo { @@ -17493,7 +17493,7 @@ pub mod extensions { device: Device, object_table: ObjectTableNVX, object_count: uint32_t, - pp_object_table_entries: *const ObjectTableEntryNVX, + pp_object_table_entries: *const *const ObjectTableEntryNVX, p_object_indices: *const uint32_t, ) -> Result, unregister_objects_nvx: extern "system" fn( @@ -17685,7 +17685,7 @@ pub mod extensions { device: Device, object_table: ObjectTableNVX, object_count: uint32_t, - pp_object_table_entries: *const ObjectTableEntryNVX, + pp_object_table_entries: *const *const ObjectTableEntryNVX, p_object_indices: *const uint32_t, ) -> Result { (self.register_objects_nvx)( diff --git a/generator/src/lib.rs b/generator/src/lib.rs index b7028be..30076fa 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -563,7 +563,7 @@ impl ToTokens for vkxml::ReferenceType { let ptr_name = match self { vkxml::ReferenceType::Pointer => "*const", vkxml::ReferenceType::PointerToPointer => "*mut *mut", - vkxml::ReferenceType::PointerToConstPointer => "*const", + vkxml::ReferenceType::PointerToConstPointer => "*const *const", }; let ident = Term::intern(ptr_name); quote!{ From 2921a03638e52cb192b0822a6ce755333f8100e2 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 31 Jul 2018 13:44:22 +0200 Subject: [PATCH 044/122] Fix repeating name in constants --- ash/src/vk.rs | 321 ++++++++++++++++++++++--------------------- generator/src/lib.rs | 9 +- 2 files changed, 173 insertions(+), 157 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 476ded1..4958d95 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -12466,139 +12466,132 @@ impl ObjectType { #[repr(C)] pub struct PresentModeKHR(pub(crate) i32); impl PresentModeKHR { - pub const PRESENT_MODE_IMMEDIATE_KHR: Self = PresentModeKHR(0); - pub const PRESENT_MODE_MAILBOX_KHR: Self = PresentModeKHR(1); - pub const PRESENT_MODE_FIFO_KHR: Self = PresentModeKHR(2); - pub const PRESENT_MODE_FIFO_RELAXED_KHR: Self = PresentModeKHR(3); + pub const IMMEDIATE_KHR: Self = PresentModeKHR(0); + pub const MAILBOX_KHR: Self = PresentModeKHR(1); + pub const FIFO_KHR: Self = PresentModeKHR(2); + pub const FIFO_RELAXED_KHR: Self = PresentModeKHR(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ColorSpaceKHR(pub(crate) i32); impl ColorSpaceKHR { - pub const COLOR_SPACE_SRGB_NONLINEAR_KHR: Self = ColorSpaceKHR(0); + pub const SRGB_NONLINEAR_KHR: Self = ColorSpaceKHR(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DebugReportObjectTypeEXT(pub(crate) i32); impl DebugReportObjectTypeEXT { - pub const DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: Self = DebugReportObjectTypeEXT(0); - pub const DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: Self = DebugReportObjectTypeEXT(1); - pub const DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: Self = DebugReportObjectTypeEXT(2); - pub const DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: Self = DebugReportObjectTypeEXT(3); - pub const DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: Self = DebugReportObjectTypeEXT(4); - pub const DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: Self = DebugReportObjectTypeEXT(5); - pub const DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: Self = DebugReportObjectTypeEXT(6); - pub const DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: Self = DebugReportObjectTypeEXT(7); - pub const DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: Self = DebugReportObjectTypeEXT(8); - pub const DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: Self = DebugReportObjectTypeEXT(9); - pub const DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: Self = DebugReportObjectTypeEXT(10); - pub const DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: Self = DebugReportObjectTypeEXT(11); - pub const DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: Self = DebugReportObjectTypeEXT(12); - pub const DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: Self = DebugReportObjectTypeEXT(13); - pub const DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: Self = DebugReportObjectTypeEXT(14); - pub const DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: Self = DebugReportObjectTypeEXT(15); - pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: Self = DebugReportObjectTypeEXT(16); - pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: Self = DebugReportObjectTypeEXT(17); - pub const DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: Self = DebugReportObjectTypeEXT(18); - pub const DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: Self = DebugReportObjectTypeEXT(19); - pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: Self = - DebugReportObjectTypeEXT(20); - pub const DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: Self = DebugReportObjectTypeEXT(21); - pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: Self = DebugReportObjectTypeEXT(22); - pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: Self = DebugReportObjectTypeEXT(23); - pub const DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: Self = DebugReportObjectTypeEXT(24); - pub const DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: Self = DebugReportObjectTypeEXT(25); - pub const DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: Self = DebugReportObjectTypeEXT(26); - pub const DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: Self = DebugReportObjectTypeEXT(27); - pub const DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: Self = - DebugReportObjectTypeEXT(28); - pub const DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: Self = DebugReportObjectTypeEXT(29); - pub const DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: Self = DebugReportObjectTypeEXT(30); - pub const DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT: Self = DebugReportObjectTypeEXT(31); - pub const DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT: Self = - DebugReportObjectTypeEXT(32); - pub const DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: Self = - DebugReportObjectTypeEXT(33); + pub const UNKNOWN_EXT: Self = DebugReportObjectTypeEXT(0); + pub const INSTANCE_EXT: Self = DebugReportObjectTypeEXT(1); + pub const PHYSICAL_DEVICE_EXT: Self = DebugReportObjectTypeEXT(2); + pub const DEVICE_EXT: Self = DebugReportObjectTypeEXT(3); + pub const QUEUE_EXT: Self = DebugReportObjectTypeEXT(4); + pub const SEMAPHORE_EXT: Self = DebugReportObjectTypeEXT(5); + pub const COMMAND_BUFFER_EXT: Self = DebugReportObjectTypeEXT(6); + pub const FENCE_EXT: Self = DebugReportObjectTypeEXT(7); + pub const DEVICE_MEMORY_EXT: Self = DebugReportObjectTypeEXT(8); + pub const BUFFER_EXT: Self = DebugReportObjectTypeEXT(9); + pub const IMAGE_EXT: Self = DebugReportObjectTypeEXT(10); + pub const EVENT_EXT: Self = DebugReportObjectTypeEXT(11); + pub const QUERY_POOL_EXT: Self = DebugReportObjectTypeEXT(12); + pub const BUFFER_VIEW_EXT: Self = DebugReportObjectTypeEXT(13); + pub const IMAGE_VIEW_EXT: Self = DebugReportObjectTypeEXT(14); + pub const SHADER_MODULE_EXT: Self = DebugReportObjectTypeEXT(15); + pub const PIPELINE_CACHE_EXT: Self = DebugReportObjectTypeEXT(16); + pub const PIPELINE_LAYOUT_EXT: Self = DebugReportObjectTypeEXT(17); + pub const RENDER_PASS_EXT: Self = DebugReportObjectTypeEXT(18); + pub const PIPELINE_EXT: Self = DebugReportObjectTypeEXT(19); + pub const DESCRIPTOR_SET_LAYOUT_EXT: Self = DebugReportObjectTypeEXT(20); + pub const SAMPLER_EXT: Self = DebugReportObjectTypeEXT(21); + pub const DESCRIPTOR_POOL_EXT: Self = DebugReportObjectTypeEXT(22); + pub const DESCRIPTOR_SET_EXT: Self = DebugReportObjectTypeEXT(23); + pub const FRAMEBUFFER_EXT: Self = DebugReportObjectTypeEXT(24); + pub const COMMAND_POOL_EXT: Self = DebugReportObjectTypeEXT(25); + pub const SURFACE_KHR_EXT: Self = DebugReportObjectTypeEXT(26); + pub const SWAPCHAIN_KHR_EXT: Self = DebugReportObjectTypeEXT(27); + pub const DEBUG_REPORT_CALLBACK_EXT_EXT: Self = DebugReportObjectTypeEXT(28); + pub const DISPLAY_KHR_EXT: Self = DebugReportObjectTypeEXT(29); + pub const DISPLAY_MODE_KHR_EXT: Self = DebugReportObjectTypeEXT(30); + pub const OBJECT_TABLE_NVX_EXT: Self = DebugReportObjectTypeEXT(31); + pub const INDIRECT_COMMANDS_LAYOUT_NVX_EXT: Self = DebugReportObjectTypeEXT(32); + pub const VALIDATION_CACHE_EXT_EXT: Self = DebugReportObjectTypeEXT(33); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct RasterizationOrderAMD(pub(crate) i32); impl RasterizationOrderAMD { - pub const RASTERIZATION_ORDER_STRICT_AMD: Self = RasterizationOrderAMD(0); - pub const RASTERIZATION_ORDER_RELAXED_AMD: Self = RasterizationOrderAMD(1); + pub const STRICT_AMD: Self = RasterizationOrderAMD(0); + pub const RELAXED_AMD: Self = RasterizationOrderAMD(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ValidationCheckEXT(pub(crate) i32); impl ValidationCheckEXT { - pub const VALIDATION_CHECK_ALL_EXT: Self = ValidationCheckEXT(0); - pub const VALIDATION_CHECK_SHADERS_EXT: Self = ValidationCheckEXT(1); + pub const ALL_EXT: Self = ValidationCheckEXT(0); + pub const SHADERS_EXT: Self = ValidationCheckEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct IndirectCommandsTokenTypeNVX(pub(crate) i32); impl IndirectCommandsTokenTypeNVX { - pub const INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX: Self = IndirectCommandsTokenTypeNVX(0); - pub const INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX: Self = - IndirectCommandsTokenTypeNVX(1); - pub const INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX: Self = IndirectCommandsTokenTypeNVX(2); - pub const INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX: Self = - IndirectCommandsTokenTypeNVX(3); - pub const INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX: Self = - IndirectCommandsTokenTypeNVX(4); - pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX: Self = IndirectCommandsTokenTypeNVX(5); - pub const INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX: Self = IndirectCommandsTokenTypeNVX(6); - pub const INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX: Self = IndirectCommandsTokenTypeNVX(7); + pub const PIPELINE_NVX: Self = IndirectCommandsTokenTypeNVX(0); + pub const DESCRIPTOR_SET_NVX: Self = IndirectCommandsTokenTypeNVX(1); + pub const INDEX_BUFFER_NVX: Self = IndirectCommandsTokenTypeNVX(2); + pub const VERTEX_BUFFER_NVX: Self = IndirectCommandsTokenTypeNVX(3); + pub const PUSH_CONSTANT_NVX: Self = IndirectCommandsTokenTypeNVX(4); + pub const DRAW_INDEXED_NVX: Self = IndirectCommandsTokenTypeNVX(5); + pub const DRAW_NVX: Self = IndirectCommandsTokenTypeNVX(6); + pub const DISPATCH_NVX: Self = IndirectCommandsTokenTypeNVX(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ObjectEntryTypeNVX(pub(crate) i32); impl ObjectEntryTypeNVX { - pub const OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX: Self = ObjectEntryTypeNVX(0); - pub const OBJECT_ENTRY_TYPE_PIPELINE_NVX: Self = ObjectEntryTypeNVX(1); - pub const OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(2); - pub const OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(3); - pub const OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX: Self = ObjectEntryTypeNVX(4); + pub const DESCRIPTOR_SET_NVX: Self = ObjectEntryTypeNVX(0); + pub const PIPELINE_NVX: Self = ObjectEntryTypeNVX(1); + pub const INDEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(2); + pub const VERTEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(3); + pub const PUSH_CONSTANT_NVX: Self = ObjectEntryTypeNVX(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DisplayPowerStateEXT(pub(crate) i32); impl DisplayPowerStateEXT { - pub const DISPLAY_POWER_STATE_OFF_EXT: Self = DisplayPowerStateEXT(0); - pub const DISPLAY_POWER_STATE_SUSPEND_EXT: Self = DisplayPowerStateEXT(1); - pub const DISPLAY_POWER_STATE_ON_EXT: Self = DisplayPowerStateEXT(2); + pub const OFF_EXT: Self = DisplayPowerStateEXT(0); + pub const SUSPEND_EXT: Self = DisplayPowerStateEXT(1); + pub const ON_EXT: Self = DisplayPowerStateEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DeviceEventTypeEXT(pub(crate) i32); impl DeviceEventTypeEXT { - pub const DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: Self = DeviceEventTypeEXT(0); + pub const DISPLAY_HOTPLUG_EXT: Self = DeviceEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DisplayEventTypeEXT(pub(crate) i32); impl DisplayEventTypeEXT { - pub const DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: Self = DisplayEventTypeEXT(0); + pub const FIRST_PIXEL_OUT_EXT: Self = DisplayEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); impl ViewportCoordinateSwizzleNV { - pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: Self = ViewportCoordinateSwizzleNV(0); - pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: Self = ViewportCoordinateSwizzleNV(1); - pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(2); - pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(3); - pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(4); - pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(5); - pub const VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: Self = ViewportCoordinateSwizzleNV(6); - pub const VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: Self = ViewportCoordinateSwizzleNV(7); + pub const POSITIVE_X_NV: Self = ViewportCoordinateSwizzleNV(0); + pub const NEGATIVE_X_NV: Self = ViewportCoordinateSwizzleNV(1); + pub const POSITIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(2); + pub const NEGATIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(3); + pub const POSITIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(4); + pub const NEGATIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(5); + pub const POSITIVE_W_NV: Self = ViewportCoordinateSwizzleNV(6); + pub const NEGATIVE_W_NV: Self = ViewportCoordinateSwizzleNV(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DiscardRectangleModeEXT(pub(crate) i32); impl DiscardRectangleModeEXT { - pub const DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: Self = DiscardRectangleModeEXT(0); - pub const DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: Self = DiscardRectangleModeEXT(1); + pub const INCLUSIVE_EXT: Self = DiscardRectangleModeEXT(0); + pub const EXCLUSIVE_EXT: Self = DiscardRectangleModeEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] @@ -12611,9 +12604,9 @@ impl PointClippingBehavior { #[repr(C)] pub struct SamplerReductionModeEXT(pub(crate) i32); impl SamplerReductionModeEXT { - pub const SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT: Self = SamplerReductionModeEXT(0); - pub const SAMPLER_REDUCTION_MODE_MIN_EXT: Self = SamplerReductionModeEXT(1); - pub const SAMPLER_REDUCTION_MODE_MAX_EXT: Self = SamplerReductionModeEXT(2); + pub const WEIGHTED_AVERAGE_EXT: Self = SamplerReductionModeEXT(0); + pub const MIN_EXT: Self = SamplerReductionModeEXT(1); + pub const MAX_EXT: Self = SamplerReductionModeEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] @@ -12656,52 +12649,49 @@ impl ChromaLocation { #[repr(C)] pub struct BlendOverlapEXT(pub(crate) i32); impl BlendOverlapEXT { - pub const BLEND_OVERLAP_UNCORRELATED_EXT: Self = BlendOverlapEXT(0); - pub const BLEND_OVERLAP_DISJOINT_EXT: Self = BlendOverlapEXT(1); - pub const BLEND_OVERLAP_CONJOINT_EXT: Self = BlendOverlapEXT(2); + pub const UNCORRELATED_EXT: Self = BlendOverlapEXT(0); + pub const DISJOINT_EXT: Self = BlendOverlapEXT(1); + pub const CONJOINT_EXT: Self = BlendOverlapEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct CoverageModulationModeNV(pub(crate) i32); impl CoverageModulationModeNV { - pub const COVERAGE_MODULATION_MODE_NONE_NV: Self = CoverageModulationModeNV(0); - pub const COVERAGE_MODULATION_MODE_RGB_NV: Self = CoverageModulationModeNV(1); - pub const COVERAGE_MODULATION_MODE_ALPHA_NV: Self = CoverageModulationModeNV(2); - pub const COVERAGE_MODULATION_MODE_RGBA_NV: Self = CoverageModulationModeNV(3); + pub const NONE_NV: Self = CoverageModulationModeNV(0); + pub const RGB_NV: Self = CoverageModulationModeNV(1); + pub const ALPHA_NV: Self = CoverageModulationModeNV(2); + pub const RGBA_NV: Self = CoverageModulationModeNV(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); impl ValidationCacheHeaderVersionEXT { - pub const VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: Self = ValidationCacheHeaderVersionEXT(1); + pub const ONE_EXT: Self = ValidationCacheHeaderVersionEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ShaderInfoTypeAMD(pub(crate) i32); impl ShaderInfoTypeAMD { - pub const SHADER_INFO_TYPE_STATISTICS_AMD: Self = ShaderInfoTypeAMD(0); - pub const SHADER_INFO_TYPE_BINARY_AMD: Self = ShaderInfoTypeAMD(1); - pub const SHADER_INFO_TYPE_DISASSEMBLY_AMD: Self = ShaderInfoTypeAMD(2); + pub const STATISTICS_AMD: Self = ShaderInfoTypeAMD(0); + pub const BINARY_AMD: Self = ShaderInfoTypeAMD(1); + pub const DISASSEMBLY_AMD: Self = ShaderInfoTypeAMD(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct QueueGlobalPriorityEXT(pub(crate) i32); impl QueueGlobalPriorityEXT { - pub const QUEUE_GLOBAL_PRIORITY_LOW_EXT: Self = QueueGlobalPriorityEXT(128); - pub const QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT: Self = QueueGlobalPriorityEXT(256); - pub const QUEUE_GLOBAL_PRIORITY_HIGH_EXT: Self = QueueGlobalPriorityEXT(512); - pub const QUEUE_GLOBAL_PRIORITY_REALTIME_EXT: Self = QueueGlobalPriorityEXT(1024); + pub const LOW_EXT: Self = QueueGlobalPriorityEXT(128); + pub const MEDIUM_EXT: Self = QueueGlobalPriorityEXT(256); + pub const HIGH_EXT: Self = QueueGlobalPriorityEXT(512); + pub const REALTIME_EXT: Self = QueueGlobalPriorityEXT(1024); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ConservativeRasterizationModeEXT(pub(crate) i32); impl ConservativeRasterizationModeEXT { - pub const CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: Self = - ConservativeRasterizationModeEXT(0); - pub const CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT: Self = - ConservativeRasterizationModeEXT(1); - pub const CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: Self = - ConservativeRasterizationModeEXT(2); + pub const DISABLED_EXT: Self = ConservativeRasterizationModeEXT(0); + pub const OVERESTIMATE_EXT: Self = ConservativeRasterizationModeEXT(1); + pub const UNDERESTIMATE_EXT: Self = ConservativeRasterizationModeEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] @@ -13220,19 +13210,24 @@ pub mod bitflags { pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); impl ExternalMemoryHandleTypeFlagsNV { - pub const OPAQUE_WIN32_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b1); - pub const OPAQUE_WIN32_KMT_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b10); - pub const D3D11_IMAGE_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b100); - pub const D3D11_IMAGE_KMT_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b1000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b1); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b10); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b100); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b1000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); impl ExternalMemoryFeatureFlagsNV { - pub const DEDICATED_ONLY_NV: Self = ExternalMemoryFeatureFlagsNV(0b1); - pub const EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10); - pub const IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100); + pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV: Self = + ExternalMemoryFeatureFlagsNV(0b1); + pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10); + pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -13284,41 +13279,52 @@ pub mod bitflags { pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); impl ExternalMemoryHandleTypeFlags { - pub const OPAQUE_FD: Self = ExternalMemoryHandleTypeFlags(0b1); - pub const OPAQUE_WIN32: Self = ExternalMemoryHandleTypeFlags(0b10); - pub const OPAQUE_WIN32_KMT: Self = ExternalMemoryHandleTypeFlags(0b100); - pub const D3D11_TEXTURE: Self = ExternalMemoryHandleTypeFlags(0b1000); - pub const D3D11_TEXTURE_KMT: Self = ExternalMemoryHandleTypeFlags(0b10000); - pub const D3D12_HEAP: Self = ExternalMemoryHandleTypeFlags(0b100000); - pub const D3D12_RESOURCE: Self = ExternalMemoryHandleTypeFlags(0b1000000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: Self = ExternalMemoryHandleTypeFlags(0b1); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32: Self = + ExternalMemoryHandleTypeFlags(0b10); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = + ExternalMemoryHandleTypeFlags(0b100); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE: Self = + ExternalMemoryHandleTypeFlags(0b1000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT: Self = + ExternalMemoryHandleTypeFlags(0b10000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP: Self = + ExternalMemoryHandleTypeFlags(0b100000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: Self = + ExternalMemoryHandleTypeFlags(0b1000000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); impl ExternalMemoryFeatureFlags { - pub const DEDICATED_ONLY: Self = ExternalMemoryFeatureFlags(0b1); - pub const EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10); - pub const IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100); + pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY: Self = ExternalMemoryFeatureFlags(0b1); + pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10); + pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); impl ExternalSemaphoreHandleTypeFlags { - pub const OPAQUE_FD: Self = ExternalSemaphoreHandleTypeFlags(0b1); - pub const OPAQUE_WIN32: Self = ExternalSemaphoreHandleTypeFlags(0b10); - pub const OPAQUE_WIN32_KMT: Self = ExternalSemaphoreHandleTypeFlags(0b100); - pub const D3D12_FENCE: Self = ExternalSemaphoreHandleTypeFlags(0b1000); - pub const SYNC_FD: Self = ExternalSemaphoreHandleTypeFlags(0b10000); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: Self = + ExternalSemaphoreHandleTypeFlags(0b1); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32: Self = + ExternalSemaphoreHandleTypeFlags(0b10); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = + ExternalSemaphoreHandleTypeFlags(0b100); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE: Self = + ExternalSemaphoreHandleTypeFlags(0b1000); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: Self = + ExternalSemaphoreHandleTypeFlags(0b10000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); impl ExternalSemaphoreFeatureFlags { - pub const EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1); - pub const IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10); + pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1); + pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -13332,18 +13338,20 @@ pub mod bitflags { pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); impl ExternalFenceHandleTypeFlags { - pub const OPAQUE_FD: Self = ExternalFenceHandleTypeFlags(0b1); - pub const OPAQUE_WIN32: Self = ExternalFenceHandleTypeFlags(0b10); - pub const OPAQUE_WIN32_KMT: Self = ExternalFenceHandleTypeFlags(0b100); - pub const SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000); + pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD: Self = ExternalFenceHandleTypeFlags(0b1); + pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32: Self = + ExternalFenceHandleTypeFlags(0b10); + pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = + ExternalFenceHandleTypeFlags(0b100); + pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalFenceFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); impl ExternalFenceFeatureFlags { - pub const EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1); - pub const IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10); + pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1); + pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -14952,13 +14960,11 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_debug_report\'"] impl DebugReportObjectTypeEXT { - pub const DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: Self = - DebugReportObjectTypeEXT(1000156000); + pub const SAMPLER_YCBCR_CONVERSION_EXT: Self = DebugReportObjectTypeEXT(1000156000); } #[doc = "Generated from \'VK_EXT_debug_report\'"] impl DebugReportObjectTypeEXT { - pub const DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: Self = - DebugReportObjectTypeEXT(1000085000); + pub const DESCRIPTOR_UPDATE_TEMPLATE_EXT: Self = DebugReportObjectTypeEXT(1000085000); } pub struct NvGlslShaderFn {} unsafe impl Send for NvGlslShaderFn {} @@ -18561,59 +18567,59 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104001); + pub const DISPLAY_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104001); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104002); + pub const EXTENDED_SRGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104002); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_DCI_P3_LINEAR_EXT: Self = ColorSpaceKHR(1000104003); + pub const DCI_P3_LINEAR_EXT: Self = ColorSpaceKHR(1000104003); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_DCI_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104004); + pub const DCI_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104004); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_BT709_LINEAR_EXT: Self = ColorSpaceKHR(1000104005); + pub const BT709_LINEAR_EXT: Self = ColorSpaceKHR(1000104005); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_BT709_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104006); + pub const BT709_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104006); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_BT2020_LINEAR_EXT: Self = ColorSpaceKHR(1000104007); + pub const BT2020_LINEAR_EXT: Self = ColorSpaceKHR(1000104007); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_HDR10_ST2084_EXT: Self = ColorSpaceKHR(1000104008); + pub const HDR10_ST2084_EXT: Self = ColorSpaceKHR(1000104008); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_DOLBYVISION_EXT: Self = ColorSpaceKHR(1000104009); + pub const DOLBYVISION_EXT: Self = ColorSpaceKHR(1000104009); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_HDR10_HLG_EXT: Self = ColorSpaceKHR(1000104010); + pub const HDR10_HLG_EXT: Self = ColorSpaceKHR(1000104010); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_ADOBERGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104011); + pub const ADOBERGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104011); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_ADOBERGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104012); + pub const ADOBERGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104012); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_PASS_THROUGH_EXT: Self = ColorSpaceKHR(1000104013); + pub const PASS_THROUGH_EXT: Self = ColorSpaceKHR(1000104013); } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] impl ColorSpaceKHR { - pub const COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104014); + pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104014); } pub struct ExtHdrMetadataFn { set_hdr_metadata_ext: extern "system" fn( @@ -18829,11 +18835,11 @@ pub mod extensions { } #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] impl PresentModeKHR { - pub const PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR: Self = PresentModeKHR(1000111000); + pub const SHARED_DEMAND_REFRESH_KHR: Self = PresentModeKHR(1000111000); } #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] impl PresentModeKHR { - pub const PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR: Self = PresentModeKHR(1000111001); + pub const SHARED_CONTINUOUS_REFRESH_KHR: Self = PresentModeKHR(1000111001); } #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] impl ImageLayout { @@ -19533,7 +19539,8 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_external_memory_dma_buf\'"] impl ExternalMemoryHandleTypeFlags { - pub const DMA_BUF_EXT: Self = ExternalMemoryHandleTypeFlags(0b1000000000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_EXT: Self = + ExternalMemoryHandleTypeFlags(0b1000000000); } pub struct ExtQueueFamilyForeignFn {} unsafe impl Send for ExtQueueFamilyForeignFn {} @@ -19944,7 +19951,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] impl ExternalMemoryHandleTypeFlags { - pub const ANDROID_HARDWARE_BUFFER_ANDROID: Self = + pub const EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID: Self = ExternalMemoryHandleTypeFlags(0b10000000000); } #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] @@ -21629,11 +21636,13 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_external_memory_host\'"] impl ExternalMemoryHandleTypeFlags { - pub const HOST_ALLOCATION_EXT: Self = ExternalMemoryHandleTypeFlags(0b10000000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_EXT: Self = + ExternalMemoryHandleTypeFlags(0b10000000); } #[doc = "Generated from \'VK_EXT_external_memory_host\'"] impl ExternalMemoryHandleTypeFlags { - pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = ExternalMemoryHandleTypeFlags(0b100000000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = + ExternalMemoryHandleTypeFlags(0b100000000); } pub struct AmdBufferMarkerFn { cmd_write_buffer_marker_amd: extern "system" fn( diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 30076fa..0662ba6 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -903,7 +903,14 @@ pub enum EnumType { pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { let _name = enum_name.split("FlagBits").nth(0).expect("split"); - let struct_name = _name.to_shouty_snake_case(); + // TODO: Should be read from vk.xml + // TODO: Also needs to be more robust, vendor names can be substrings from itself, + // like NVX and NV + let vendors = ["_NVX", "_KHR", "_EXT", "_NV", "_AMD", "_ANDROID", "_GOOGLE"]; + let mut struct_name = _name.to_shouty_snake_case(); + for vendor in &vendors { + struct_name = struct_name.replace(vendor, ""); + } let new_variant_name = variant_name.replace(&struct_name, "").replace("VK", ""); let new_variant_name = new_variant_name .trim_matches('_') From 197b06b0d85fc2619aaab71aa1df8f75040ee281 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 31 Jul 2018 14:17:24 +0200 Subject: [PATCH 045/122] Fix: Some *const pointers should have been *mut pointers --- ash/src/instance.rs | 4 +- ash/src/vk.rs | 881 +++++++++++++++++++++++-------------------- generator/src/lib.rs | 25 +- 3 files changed, 493 insertions(+), 417 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 004c41f..0550e7e 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -85,9 +85,9 @@ impl Instance { #[allow(non_camel_case_types)] pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; - unsafe fn enumerate_instance_version(&self, api_version: &vk::uint32_t) -> vk::Result { + unsafe fn enumerate_instance_version(&self, api_version: &mut vk::uint32_t) -> vk::Result { self.fp_v1_1() - .enumerate_instance_version(api_version as *const _) + .enumerate_instance_version(api_version as *mut _) } } diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 4958d95..b1fe1ea 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -272,16 +272,16 @@ pub struct EntryFnV1_0 { create_instance: extern "system" fn( p_create_info: *const InstanceCreateInfo, p_allocator: *const AllocationCallbacks, - p_instance: *const Instance, + p_instance: *mut Instance, ) -> Result, enumerate_instance_extension_properties: extern "system" fn( p_layer_name: *const c_char, - p_property_count: *const uint32_t, - p_properties: *const ExtensionProperties, + p_property_count: *mut uint32_t, + p_properties: *mut ExtensionProperties, ) -> Result, enumerate_instance_layer_properties: - extern "system" fn(p_property_count: *const uint32_t, p_properties: *const LayerProperties) + extern "system" fn(p_property_count: *mut uint32_t, p_properties: *mut LayerProperties) -> Result, } unsafe impl Send for EntryFnV1_0 {} @@ -340,22 +340,22 @@ impl EntryFnV1_0 { &self, p_create_info: *const InstanceCreateInfo, p_allocator: *const AllocationCallbacks, - p_instance: *const Instance, + p_instance: *mut Instance, ) -> Result { (self.create_instance)(p_create_info, p_allocator, p_instance) } pub unsafe fn enumerate_instance_extension_properties( &self, p_layer_name: *const c_char, - p_property_count: *const uint32_t, - p_properties: *const ExtensionProperties, + p_property_count: *mut uint32_t, + p_properties: *mut ExtensionProperties, ) -> Result { (self.enumerate_instance_extension_properties)(p_layer_name, p_property_count, p_properties) } pub unsafe fn enumerate_instance_layer_properties( &self, - p_property_count: *const uint32_t, - p_properties: *const LayerProperties, + p_property_count: *mut uint32_t, + p_properties: *mut LayerProperties, ) -> Result { (self.enumerate_instance_layer_properties)(p_property_count, p_properties) } @@ -365,18 +365,18 @@ pub struct InstanceFnV1_0 { extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks) -> c_void, enumerate_physical_devices: extern "system" fn( instance: Instance, - p_physical_device_count: *const uint32_t, - p_physical_devices: *const PhysicalDevice, + p_physical_device_count: *mut uint32_t, + p_physical_devices: *mut PhysicalDevice, ) -> Result, get_physical_device_features: extern "system" fn( physical_device: PhysicalDevice, - p_features: *const PhysicalDeviceFeatures, + p_features: *mut PhysicalDeviceFeatures, ) -> c_void, get_physical_device_format_properties: extern "system" fn( physical_device: PhysicalDevice, format: Format, - p_format_properties: *const FormatProperties, + p_format_properties: *mut FormatProperties, ) -> c_void, get_physical_device_image_format_properties: extern "system" fn( @@ -386,23 +386,22 @@ pub struct InstanceFnV1_0 { tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, - p_image_format_properties: *const ImageFormatProperties, + p_image_format_properties: *mut ImageFormatProperties, ) -> Result, - get_physical_device_properties: - extern "system" fn( - physical_device: PhysicalDevice, - p_properties: *const PhysicalDeviceProperties, - ) -> c_void, + get_physical_device_properties: extern "system" fn( + physical_device: PhysicalDevice, + p_properties: *mut PhysicalDeviceProperties, + ) -> c_void, get_physical_device_queue_family_properties: extern "system" fn( physical_device: PhysicalDevice, - p_queue_family_property_count: *const uint32_t, - p_queue_family_properties: *const QueueFamilyProperties, + p_queue_family_property_count: *mut uint32_t, + p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void, get_physical_device_memory_properties: extern "system" fn( physical_device: PhysicalDevice, - p_memory_properties: *const PhysicalDeviceMemoryProperties, + p_memory_properties: *mut PhysicalDeviceMemoryProperties, ) -> c_void, get_device_proc_addr: extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction, @@ -410,19 +409,19 @@ pub struct InstanceFnV1_0 { physical_device: PhysicalDevice, p_create_info: *const DeviceCreateInfo, p_allocator: *const AllocationCallbacks, - p_device: *const Device, + p_device: *mut Device, ) -> Result, enumerate_device_extension_properties: extern "system" fn( physical_device: PhysicalDevice, p_layer_name: *const c_char, - p_property_count: *const uint32_t, - p_properties: *const ExtensionProperties, + p_property_count: *mut uint32_t, + p_properties: *mut ExtensionProperties, ) -> Result, enumerate_device_layer_properties: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const LayerProperties, + p_property_count: *mut uint32_t, + p_properties: *mut LayerProperties, ) -> Result, get_physical_device_sparse_image_format_properties: extern "system" fn( @@ -432,8 +431,8 @@ pub struct InstanceFnV1_0 { samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, - p_property_count: *const uint32_t, - p_properties: *const SparseImageFormatProperties, + p_property_count: *mut uint32_t, + p_properties: *mut SparseImageFormatProperties, ) -> c_void, } unsafe impl Send for InstanceFnV1_0 {} @@ -601,15 +600,15 @@ impl InstanceFnV1_0 { pub unsafe fn enumerate_physical_devices( &self, instance: Instance, - p_physical_device_count: *const uint32_t, - p_physical_devices: *const PhysicalDevice, + p_physical_device_count: *mut uint32_t, + p_physical_devices: *mut PhysicalDevice, ) -> Result { (self.enumerate_physical_devices)(instance, p_physical_device_count, p_physical_devices) } pub unsafe fn get_physical_device_features( &self, physical_device: PhysicalDevice, - p_features: *const PhysicalDeviceFeatures, + p_features: *mut PhysicalDeviceFeatures, ) -> c_void { (self.get_physical_device_features)(physical_device, p_features) } @@ -617,7 +616,7 @@ impl InstanceFnV1_0 { &self, physical_device: PhysicalDevice, format: Format, - p_format_properties: *const FormatProperties, + p_format_properties: *mut FormatProperties, ) -> c_void { (self.get_physical_device_format_properties)(physical_device, format, p_format_properties) } @@ -629,7 +628,7 @@ impl InstanceFnV1_0 { tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, - p_image_format_properties: *const ImageFormatProperties, + p_image_format_properties: *mut ImageFormatProperties, ) -> Result { (self.get_physical_device_image_format_properties)( physical_device, @@ -644,15 +643,15 @@ impl InstanceFnV1_0 { pub unsafe fn get_physical_device_properties( &self, physical_device: PhysicalDevice, - p_properties: *const PhysicalDeviceProperties, + p_properties: *mut PhysicalDeviceProperties, ) -> c_void { (self.get_physical_device_properties)(physical_device, p_properties) } pub unsafe fn get_physical_device_queue_family_properties( &self, physical_device: PhysicalDevice, - p_queue_family_property_count: *const uint32_t, - p_queue_family_properties: *const QueueFamilyProperties, + p_queue_family_property_count: *mut uint32_t, + p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void { (self.get_physical_device_queue_family_properties)( physical_device, @@ -663,7 +662,7 @@ impl InstanceFnV1_0 { pub unsafe fn get_physical_device_memory_properties( &self, physical_device: PhysicalDevice, - p_memory_properties: *const PhysicalDeviceMemoryProperties, + p_memory_properties: *mut PhysicalDeviceMemoryProperties, ) -> c_void { (self.get_physical_device_memory_properties)(physical_device, p_memory_properties) } @@ -679,7 +678,7 @@ impl InstanceFnV1_0 { physical_device: PhysicalDevice, p_create_info: *const DeviceCreateInfo, p_allocator: *const AllocationCallbacks, - p_device: *const Device, + p_device: *mut Device, ) -> Result { (self.create_device)(physical_device, p_create_info, p_allocator, p_device) } @@ -687,8 +686,8 @@ impl InstanceFnV1_0 { &self, physical_device: PhysicalDevice, p_layer_name: *const c_char, - p_property_count: *const uint32_t, - p_properties: *const ExtensionProperties, + p_property_count: *mut uint32_t, + p_properties: *mut ExtensionProperties, ) -> Result { (self.enumerate_device_extension_properties)( physical_device, @@ -700,8 +699,8 @@ impl InstanceFnV1_0 { pub unsafe fn enumerate_device_layer_properties( &self, physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const LayerProperties, + p_property_count: *mut uint32_t, + p_properties: *mut LayerProperties, ) -> Result { (self.enumerate_device_layer_properties)(physical_device, p_property_count, p_properties) } @@ -713,8 +712,8 @@ impl InstanceFnV1_0 { samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, - p_property_count: *const uint32_t, - p_properties: *const SparseImageFormatProperties, + p_property_count: *mut uint32_t, + p_properties: *mut SparseImageFormatProperties, ) -> c_void { (self.get_physical_device_sparse_image_format_properties)( physical_device, @@ -735,7 +734,7 @@ pub struct DeviceFnV1_0 { device: Device, queue_family_index: uint32_t, queue_index: uint32_t, - p_queue: *const Queue, + p_queue: *mut Queue, ) -> c_void, queue_submit: extern "system" fn( queue: Queue, @@ -749,7 +748,7 @@ pub struct DeviceFnV1_0 { device: Device, p_allocate_info: *const MemoryAllocateInfo, p_allocator: *const AllocationCallbacks, - p_memory: *const DeviceMemory, + p_memory: *mut DeviceMemory, ) -> Result, free_memory: extern "system" fn( device: Device, @@ -775,12 +774,11 @@ pub struct DeviceFnV1_0 { memory_range_count: uint32_t, p_memory_ranges: *const MappedMemoryRange, ) -> Result, - get_device_memory_commitment: - extern "system" fn( - device: Device, - memory: DeviceMemory, - p_committed_memory_in_bytes: *const DeviceSize, - ) -> c_void, + get_device_memory_commitment: extern "system" fn( + device: Device, + memory: DeviceMemory, + p_committed_memory_in_bytes: *mut DeviceSize, + ) -> c_void, bind_buffer_memory: extern "system" fn( device: Device, buffer: Buffer, @@ -797,20 +795,20 @@ pub struct DeviceFnV1_0 { extern "system" fn( device: Device, buffer: Buffer, - p_memory_requirements: *const MemoryRequirements, + p_memory_requirements: *mut MemoryRequirements, ) -> c_void, get_image_memory_requirements: extern "system" fn( device: Device, image: Image, - p_memory_requirements: *const MemoryRequirements, + p_memory_requirements: *mut MemoryRequirements, ) -> c_void, get_image_sparse_memory_requirements: extern "system" fn( device: Device, image: Image, - p_sparse_memory_requirement_count: *const uint32_t, - p_sparse_memory_requirements: *const SparseImageMemoryRequirements, + p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void, queue_bind_sparse: extern "system" fn( queue: Queue, @@ -822,7 +820,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const FenceCreateInfo, p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, + p_fence: *mut Fence, ) -> Result, destroy_fence: extern "system" fn(device: Device, fence: Fence, p_allocator: *const AllocationCallbacks) @@ -841,7 +839,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const SemaphoreCreateInfo, p_allocator: *const AllocationCallbacks, - p_semaphore: *const Semaphore, + p_semaphore: *mut Semaphore, ) -> Result, destroy_semaphore: extern "system" fn( device: Device, @@ -852,7 +850,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const EventCreateInfo, p_allocator: *const AllocationCallbacks, - p_event: *const Event, + p_event: *mut Event, ) -> Result, destroy_event: extern "system" fn(device: Device, event: Event, p_allocator: *const AllocationCallbacks) @@ -864,7 +862,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const QueryPoolCreateInfo, p_allocator: *const AllocationCallbacks, - p_query_pool: *const QueryPool, + p_query_pool: *mut QueryPool, ) -> Result, destroy_query_pool: extern "system" fn( device: Device, @@ -877,7 +875,7 @@ pub struct DeviceFnV1_0 { first_query: uint32_t, query_count: uint32_t, data_size: size_t, - p_data: *const c_void, + p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, ) -> Result, @@ -885,7 +883,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const BufferCreateInfo, p_allocator: *const AllocationCallbacks, - p_buffer: *const Buffer, + p_buffer: *mut Buffer, ) -> Result, destroy_buffer: extern "system" fn(device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks) @@ -894,7 +892,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const BufferViewCreateInfo, p_allocator: *const AllocationCallbacks, - p_view: *const BufferView, + p_view: *mut BufferView, ) -> Result, destroy_buffer_view: extern "system" fn( device: Device, @@ -905,7 +903,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const ImageCreateInfo, p_allocator: *const AllocationCallbacks, - p_image: *const Image, + p_image: *mut Image, ) -> Result, destroy_image: extern "system" fn(device: Device, image: Image, p_allocator: *const AllocationCallbacks) @@ -914,13 +912,13 @@ pub struct DeviceFnV1_0 { device: Device, image: Image, p_subresource: *const ImageSubresource, - p_layout: *const SubresourceLayout, + p_layout: *mut SubresourceLayout, ) -> c_void, create_image_view: extern "system" fn( device: Device, p_create_info: *const ImageViewCreateInfo, p_allocator: *const AllocationCallbacks, - p_view: *const ImageView, + p_view: *mut ImageView, ) -> Result, destroy_image_view: extern "system" fn( device: Device, @@ -931,7 +929,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const ShaderModuleCreateInfo, p_allocator: *const AllocationCallbacks, - p_shader_module: *const ShaderModule, + p_shader_module: *mut ShaderModule, ) -> Result, destroy_shader_module: extern "system" fn( device: Device, @@ -942,7 +940,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const PipelineCacheCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipeline_cache: *const PipelineCache, + p_pipeline_cache: *mut PipelineCache, ) -> Result, destroy_pipeline_cache: extern "system" fn( device: Device, @@ -952,8 +950,8 @@ pub struct DeviceFnV1_0 { get_pipeline_cache_data: extern "system" fn( device: Device, pipeline_cache: PipelineCache, - p_data_size: *const size_t, - p_data: *const c_void, + p_data_size: *mut size_t, + p_data: *mut c_void, ) -> Result, merge_pipeline_caches: extern "system" fn( device: Device, @@ -968,7 +966,7 @@ pub struct DeviceFnV1_0 { create_info_count: uint32_t, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipelines: *const Pipeline, + p_pipelines: *mut Pipeline, ) -> Result, create_compute_pipelines: extern "system" fn( device: Device, @@ -976,7 +974,7 @@ pub struct DeviceFnV1_0 { create_info_count: uint32_t, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipelines: *const Pipeline, + p_pipelines: *mut Pipeline, ) -> Result, destroy_pipeline: extern "system" fn( device: Device, @@ -987,7 +985,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const PipelineLayoutCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipeline_layout: *const PipelineLayout, + p_pipeline_layout: *mut PipelineLayout, ) -> Result, destroy_pipeline_layout: extern "system" fn( device: Device, @@ -998,7 +996,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const SamplerCreateInfo, p_allocator: *const AllocationCallbacks, - p_sampler: *const Sampler, + p_sampler: *mut Sampler, ) -> Result, destroy_sampler: extern "system" fn( device: Device, @@ -1010,7 +1008,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, - p_set_layout: *const DescriptorSetLayout, + p_set_layout: *mut DescriptorSetLayout, ) -> Result, destroy_descriptor_set_layout: extern "system" fn( device: Device, @@ -1021,7 +1019,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const DescriptorPoolCreateInfo, p_allocator: *const AllocationCallbacks, - p_descriptor_pool: *const DescriptorPool, + p_descriptor_pool: *mut DescriptorPool, ) -> Result, destroy_descriptor_pool: extern "system" fn( device: Device, @@ -1036,7 +1034,7 @@ pub struct DeviceFnV1_0 { allocate_descriptor_sets: extern "system" fn( device: Device, p_allocate_info: *const DescriptorSetAllocateInfo, - p_descriptor_sets: *const DescriptorSet, + p_descriptor_sets: *mut DescriptorSet, ) -> Result, free_descriptor_sets: extern "system" fn( device: Device, @@ -1055,7 +1053,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const FramebufferCreateInfo, p_allocator: *const AllocationCallbacks, - p_framebuffer: *const Framebuffer, + p_framebuffer: *mut Framebuffer, ) -> Result, destroy_framebuffer: extern "system" fn( device: Device, @@ -1066,7 +1064,7 @@ pub struct DeviceFnV1_0 { device: Device, p_create_info: *const RenderPassCreateInfo, p_allocator: *const AllocationCallbacks, - p_render_pass: *const RenderPass, + p_render_pass: *mut RenderPass, ) -> Result, destroy_render_pass: extern "system" fn( device: Device, @@ -1074,13 +1072,13 @@ pub struct DeviceFnV1_0 { p_allocator: *const AllocationCallbacks, ) -> c_void, get_render_area_granularity: - extern "system" fn(device: Device, render_pass: RenderPass, p_granularity: *const Extent2D) + extern "system" fn(device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D) -> c_void, create_command_pool: extern "system" fn( device: Device, p_create_info: *const CommandPoolCreateInfo, p_allocator: *const AllocationCallbacks, - p_command_pool: *const CommandPool, + p_command_pool: *mut CommandPool, ) -> Result, destroy_command_pool: extern "system" fn( device: Device, @@ -1093,7 +1091,7 @@ pub struct DeviceFnV1_0 { allocate_command_buffers: extern "system" fn( device: Device, p_allocate_info: *const CommandBufferAllocateInfo, - p_command_buffers: *const CommandBuffer, + p_command_buffers: *mut CommandBuffer, ) -> Result, free_command_buffers: extern "system" fn( device: Device, @@ -2627,7 +2625,7 @@ impl DeviceFnV1_0 { device: Device, queue_family_index: uint32_t, queue_index: uint32_t, - p_queue: *const Queue, + p_queue: *mut Queue, ) -> c_void { (self.get_device_queue)(device, queue_family_index, queue_index, p_queue) } @@ -2651,7 +2649,7 @@ impl DeviceFnV1_0 { device: Device, p_allocate_info: *const MemoryAllocateInfo, p_allocator: *const AllocationCallbacks, - p_memory: *const DeviceMemory, + p_memory: *mut DeviceMemory, ) -> Result { (self.allocate_memory)(device, p_allocate_info, p_allocator, p_memory) } @@ -2697,7 +2695,7 @@ impl DeviceFnV1_0 { &self, device: Device, memory: DeviceMemory, - p_committed_memory_in_bytes: *const DeviceSize, + p_committed_memory_in_bytes: *mut DeviceSize, ) -> c_void { (self.get_device_memory_commitment)(device, memory, p_committed_memory_in_bytes) } @@ -2723,7 +2721,7 @@ impl DeviceFnV1_0 { &self, device: Device, buffer: Buffer, - p_memory_requirements: *const MemoryRequirements, + p_memory_requirements: *mut MemoryRequirements, ) -> c_void { (self.get_buffer_memory_requirements)(device, buffer, p_memory_requirements) } @@ -2731,7 +2729,7 @@ impl DeviceFnV1_0 { &self, device: Device, image: Image, - p_memory_requirements: *const MemoryRequirements, + p_memory_requirements: *mut MemoryRequirements, ) -> c_void { (self.get_image_memory_requirements)(device, image, p_memory_requirements) } @@ -2739,8 +2737,8 @@ impl DeviceFnV1_0 { &self, device: Device, image: Image, - p_sparse_memory_requirement_count: *const uint32_t, - p_sparse_memory_requirements: *const SparseImageMemoryRequirements, + p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void { (self.get_image_sparse_memory_requirements)( device, @@ -2763,7 +2761,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const FenceCreateInfo, p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, + p_fence: *mut Fence, ) -> Result { (self.create_fence)(device, p_create_info, p_allocator, p_fence) } @@ -2801,7 +2799,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const SemaphoreCreateInfo, p_allocator: *const AllocationCallbacks, - p_semaphore: *const Semaphore, + p_semaphore: *mut Semaphore, ) -> Result { (self.create_semaphore)(device, p_create_info, p_allocator, p_semaphore) } @@ -2818,7 +2816,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const EventCreateInfo, p_allocator: *const AllocationCallbacks, - p_event: *const Event, + p_event: *mut Event, ) -> Result { (self.create_event)(device, p_create_info, p_allocator, p_event) } @@ -2844,7 +2842,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const QueryPoolCreateInfo, p_allocator: *const AllocationCallbacks, - p_query_pool: *const QueryPool, + p_query_pool: *mut QueryPool, ) -> Result { (self.create_query_pool)(device, p_create_info, p_allocator, p_query_pool) } @@ -2863,7 +2861,7 @@ impl DeviceFnV1_0 { first_query: uint32_t, query_count: uint32_t, data_size: size_t, - p_data: *const c_void, + p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, ) -> Result { @@ -2883,7 +2881,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const BufferCreateInfo, p_allocator: *const AllocationCallbacks, - p_buffer: *const Buffer, + p_buffer: *mut Buffer, ) -> Result { (self.create_buffer)(device, p_create_info, p_allocator, p_buffer) } @@ -2900,7 +2898,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const BufferViewCreateInfo, p_allocator: *const AllocationCallbacks, - p_view: *const BufferView, + p_view: *mut BufferView, ) -> Result { (self.create_buffer_view)(device, p_create_info, p_allocator, p_view) } @@ -2917,7 +2915,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const ImageCreateInfo, p_allocator: *const AllocationCallbacks, - p_image: *const Image, + p_image: *mut Image, ) -> Result { (self.create_image)(device, p_create_info, p_allocator, p_image) } @@ -2934,7 +2932,7 @@ impl DeviceFnV1_0 { device: Device, image: Image, p_subresource: *const ImageSubresource, - p_layout: *const SubresourceLayout, + p_layout: *mut SubresourceLayout, ) -> c_void { (self.get_image_subresource_layout)(device, image, p_subresource, p_layout) } @@ -2943,7 +2941,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const ImageViewCreateInfo, p_allocator: *const AllocationCallbacks, - p_view: *const ImageView, + p_view: *mut ImageView, ) -> Result { (self.create_image_view)(device, p_create_info, p_allocator, p_view) } @@ -2960,7 +2958,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const ShaderModuleCreateInfo, p_allocator: *const AllocationCallbacks, - p_shader_module: *const ShaderModule, + p_shader_module: *mut ShaderModule, ) -> Result { (self.create_shader_module)(device, p_create_info, p_allocator, p_shader_module) } @@ -2977,7 +2975,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const PipelineCacheCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipeline_cache: *const PipelineCache, + p_pipeline_cache: *mut PipelineCache, ) -> Result { (self.create_pipeline_cache)(device, p_create_info, p_allocator, p_pipeline_cache) } @@ -2993,8 +2991,8 @@ impl DeviceFnV1_0 { &self, device: Device, pipeline_cache: PipelineCache, - p_data_size: *const size_t, - p_data: *const c_void, + p_data_size: *mut size_t, + p_data: *mut c_void, ) -> Result { (self.get_pipeline_cache_data)(device, pipeline_cache, p_data_size, p_data) } @@ -3014,7 +3012,7 @@ impl DeviceFnV1_0 { create_info_count: uint32_t, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipelines: *const Pipeline, + p_pipelines: *mut Pipeline, ) -> Result { (self.create_graphics_pipelines)( device, @@ -3032,7 +3030,7 @@ impl DeviceFnV1_0 { create_info_count: uint32_t, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipelines: *const Pipeline, + p_pipelines: *mut Pipeline, ) -> Result { (self.create_compute_pipelines)( device, @@ -3056,7 +3054,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const PipelineLayoutCreateInfo, p_allocator: *const AllocationCallbacks, - p_pipeline_layout: *const PipelineLayout, + p_pipeline_layout: *mut PipelineLayout, ) -> Result { (self.create_pipeline_layout)(device, p_create_info, p_allocator, p_pipeline_layout) } @@ -3073,7 +3071,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const SamplerCreateInfo, p_allocator: *const AllocationCallbacks, - p_sampler: *const Sampler, + p_sampler: *mut Sampler, ) -> Result { (self.create_sampler)(device, p_create_info, p_allocator, p_sampler) } @@ -3090,7 +3088,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, - p_set_layout: *const DescriptorSetLayout, + p_set_layout: *mut DescriptorSetLayout, ) -> Result { (self.create_descriptor_set_layout)(device, p_create_info, p_allocator, p_set_layout) } @@ -3107,7 +3105,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const DescriptorPoolCreateInfo, p_allocator: *const AllocationCallbacks, - p_descriptor_pool: *const DescriptorPool, + p_descriptor_pool: *mut DescriptorPool, ) -> Result { (self.create_descriptor_pool)(device, p_create_info, p_allocator, p_descriptor_pool) } @@ -3131,7 +3129,7 @@ impl DeviceFnV1_0 { &self, device: Device, p_allocate_info: *const DescriptorSetAllocateInfo, - p_descriptor_sets: *const DescriptorSet, + p_descriptor_sets: *mut DescriptorSet, ) -> Result { (self.allocate_descriptor_sets)(device, p_allocate_info, p_descriptor_sets) } @@ -3170,7 +3168,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const FramebufferCreateInfo, p_allocator: *const AllocationCallbacks, - p_framebuffer: *const Framebuffer, + p_framebuffer: *mut Framebuffer, ) -> Result { (self.create_framebuffer)(device, p_create_info, p_allocator, p_framebuffer) } @@ -3187,7 +3185,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const RenderPassCreateInfo, p_allocator: *const AllocationCallbacks, - p_render_pass: *const RenderPass, + p_render_pass: *mut RenderPass, ) -> Result { (self.create_render_pass)(device, p_create_info, p_allocator, p_render_pass) } @@ -3203,7 +3201,7 @@ impl DeviceFnV1_0 { &self, device: Device, render_pass: RenderPass, - p_granularity: *const Extent2D, + p_granularity: *mut Extent2D, ) -> c_void { (self.get_render_area_granularity)(device, render_pass, p_granularity) } @@ -3212,7 +3210,7 @@ impl DeviceFnV1_0 { device: Device, p_create_info: *const CommandPoolCreateInfo, p_allocator: *const AllocationCallbacks, - p_command_pool: *const CommandPool, + p_command_pool: *mut CommandPool, ) -> Result { (self.create_command_pool)(device, p_create_info, p_allocator, p_command_pool) } @@ -3236,7 +3234,7 @@ impl DeviceFnV1_0 { &self, device: Device, p_allocate_info: *const CommandBufferAllocateInfo, - p_command_buffers: *const CommandBuffer, + p_command_buffers: *mut CommandBuffer, ) -> Result { (self.allocate_command_buffers)(device, p_allocate_info, p_command_buffers) } @@ -3848,7 +3846,72 @@ impl EntryFnV1_1 { } } } -pub struct InstanceFnV1_1 { enumerate_instance_version : extern "system" fn ( p_api_version : *const uint32_t , ) -> Result , enumerate_physical_device_groups : extern "system" fn ( instance : Instance , p_physical_device_group_count : *const uint32_t , p_physical_device_group_properties : *const PhysicalDeviceGroupProperties , ) -> Result , get_physical_device_features2 : extern "system" fn ( physical_device : PhysicalDevice , p_features : *const PhysicalDeviceFeatures2 , ) -> c_void , get_physical_device_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_properties : *const PhysicalDeviceProperties2 , ) -> c_void , get_physical_device_format_properties2 : extern "system" fn ( physical_device : PhysicalDevice , format : Format , p_format_properties : *const FormatProperties2 , ) -> c_void , get_physical_device_image_format_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_image_format_info : *const PhysicalDeviceImageFormatInfo2 , p_image_format_properties : *const ImageFormatProperties2 , ) -> Result , get_physical_device_queue_family_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_queue_family_property_count : *const uint32_t , p_queue_family_properties : *const QueueFamilyProperties2 , ) -> c_void , get_physical_device_memory_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_memory_properties : *const PhysicalDeviceMemoryProperties2 , ) -> c_void , get_physical_device_sparse_image_format_properties2 : extern "system" fn ( physical_device : PhysicalDevice , p_format_info : *const PhysicalDeviceSparseImageFormatInfo2 , p_property_count : *const uint32_t , p_properties : *const SparseImageFormatProperties2 , ) -> c_void , get_physical_device_external_buffer_properties : extern "system" fn ( physical_device : PhysicalDevice , p_external_buffer_info : *const PhysicalDeviceExternalBufferInfo , p_external_buffer_properties : *const ExternalBufferProperties , ) -> c_void , get_physical_device_external_fence_properties : extern "system" fn ( physical_device : PhysicalDevice , p_external_fence_info : *const PhysicalDeviceExternalFenceInfo , p_external_fence_properties : *const ExternalFenceProperties , ) -> c_void , get_physical_device_external_semaphore_properties : extern "system" fn ( physical_device : PhysicalDevice , p_external_semaphore_info : *const PhysicalDeviceExternalSemaphoreInfo , p_external_semaphore_properties : *const ExternalSemaphoreProperties , ) -> c_void , } +pub struct InstanceFnV1_1 { + enumerate_instance_version: extern "system" fn(p_api_version: *mut uint32_t) -> Result, + enumerate_physical_device_groups: + extern "system" fn( + instance: Instance, + p_physical_device_group_count: *mut uint32_t, + p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, + ) -> Result, + get_physical_device_features2: extern "system" fn( + physical_device: PhysicalDevice, + p_features: *mut PhysicalDeviceFeatures2, + ) -> c_void, + get_physical_device_properties2: + extern "system" fn( + physical_device: PhysicalDevice, + p_properties: *mut PhysicalDeviceProperties2, + ) -> c_void, + get_physical_device_format_properties2: + extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *mut FormatProperties2, + ) -> c_void, + get_physical_device_image_format_properties2: + extern "system" fn( + physical_device: PhysicalDevice, + p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + p_image_format_properties: *mut ImageFormatProperties2, + ) -> Result, + get_physical_device_queue_family_properties2: + extern "system" fn( + physical_device: PhysicalDevice, + p_queue_family_property_count: *mut uint32_t, + p_queue_family_properties: *mut QueueFamilyProperties2, + ) -> c_void, + get_physical_device_memory_properties2: + extern "system" fn( + physical_device: PhysicalDevice, + p_memory_properties: *mut PhysicalDeviceMemoryProperties2, + ) -> c_void, + get_physical_device_sparse_image_format_properties2: + extern "system" fn( + physical_device: PhysicalDevice, + p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + p_property_count: *mut uint32_t, + p_properties: *mut SparseImageFormatProperties2, + ) -> c_void, + get_physical_device_external_buffer_properties: + extern "system" fn( + physical_device: PhysicalDevice, + p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + p_external_buffer_properties: *mut ExternalBufferProperties, + ) -> c_void, + get_physical_device_external_fence_properties: + extern "system" fn( + physical_device: PhysicalDevice, + p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + p_external_fence_properties: *mut ExternalFenceProperties, + ) -> c_void, + get_physical_device_external_semaphore_properties: + extern "system" fn( + physical_device: PhysicalDevice, + p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + p_external_semaphore_properties: *mut ExternalSemaphoreProperties, + ) -> c_void, +} unsafe impl Send for InstanceFnV1_1 {} unsafe impl Sync for InstanceFnV1_1 {} impl ::std::clone::Clone for InstanceFnV1_1 { @@ -3997,14 +4060,14 @@ impl InstanceFnV1_1 { Err(_err_str) } } - pub unsafe fn enumerate_instance_version(&self, p_api_version: *const uint32_t) -> Result { + pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut uint32_t) -> Result { (self.enumerate_instance_version)(p_api_version) } pub unsafe fn enumerate_physical_device_groups( &self, instance: Instance, - p_physical_device_group_count: *const uint32_t, - p_physical_device_group_properties: *const PhysicalDeviceGroupProperties, + p_physical_device_group_count: *mut uint32_t, + p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result { (self.enumerate_physical_device_groups)( instance, @@ -4015,14 +4078,14 @@ impl InstanceFnV1_1 { pub unsafe fn get_physical_device_features2( &self, physical_device: PhysicalDevice, - p_features: *const PhysicalDeviceFeatures2, + p_features: *mut PhysicalDeviceFeatures2, ) -> c_void { (self.get_physical_device_features2)(physical_device, p_features) } pub unsafe fn get_physical_device_properties2( &self, physical_device: PhysicalDevice, - p_properties: *const PhysicalDeviceProperties2, + p_properties: *mut PhysicalDeviceProperties2, ) -> c_void { (self.get_physical_device_properties2)(physical_device, p_properties) } @@ -4030,7 +4093,7 @@ impl InstanceFnV1_1 { &self, physical_device: PhysicalDevice, format: Format, - p_format_properties: *const FormatProperties2, + p_format_properties: *mut FormatProperties2, ) -> c_void { (self.get_physical_device_format_properties2)(physical_device, format, p_format_properties) } @@ -4038,7 +4101,7 @@ impl InstanceFnV1_1 { &self, physical_device: PhysicalDevice, p_image_format_info: *const PhysicalDeviceImageFormatInfo2, - p_image_format_properties: *const ImageFormatProperties2, + p_image_format_properties: *mut ImageFormatProperties2, ) -> Result { (self.get_physical_device_image_format_properties2)( physical_device, @@ -4049,8 +4112,8 @@ impl InstanceFnV1_1 { pub unsafe fn get_physical_device_queue_family_properties2( &self, physical_device: PhysicalDevice, - p_queue_family_property_count: *const uint32_t, - p_queue_family_properties: *const QueueFamilyProperties2, + p_queue_family_property_count: *mut uint32_t, + p_queue_family_properties: *mut QueueFamilyProperties2, ) -> c_void { (self.get_physical_device_queue_family_properties2)( physical_device, @@ -4061,7 +4124,7 @@ impl InstanceFnV1_1 { pub unsafe fn get_physical_device_memory_properties2( &self, physical_device: PhysicalDevice, - p_memory_properties: *const PhysicalDeviceMemoryProperties2, + p_memory_properties: *mut PhysicalDeviceMemoryProperties2, ) -> c_void { (self.get_physical_device_memory_properties2)(physical_device, p_memory_properties) } @@ -4069,8 +4132,8 @@ impl InstanceFnV1_1 { &self, physical_device: PhysicalDevice, p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, - p_property_count: *const uint32_t, - p_properties: *const SparseImageFormatProperties2, + p_property_count: *mut uint32_t, + p_properties: *mut SparseImageFormatProperties2, ) -> c_void { (self.get_physical_device_sparse_image_format_properties2)( physical_device, @@ -4083,7 +4146,7 @@ impl InstanceFnV1_1 { &self, physical_device: PhysicalDevice, p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, - p_external_buffer_properties: *const ExternalBufferProperties, + p_external_buffer_properties: *mut ExternalBufferProperties, ) -> c_void { (self.get_physical_device_external_buffer_properties)( physical_device, @@ -4095,7 +4158,7 @@ impl InstanceFnV1_1 { &self, physical_device: PhysicalDevice, p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, - p_external_fence_properties: *const ExternalFenceProperties, + p_external_fence_properties: *mut ExternalFenceProperties, ) -> c_void { (self.get_physical_device_external_fence_properties)( physical_device, @@ -4107,7 +4170,7 @@ impl InstanceFnV1_1 { &self, physical_device: PhysicalDevice, p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, - p_external_semaphore_properties: *const ExternalSemaphoreProperties, + p_external_semaphore_properties: *mut ExternalSemaphoreProperties, ) -> c_void { (self.get_physical_device_external_semaphore_properties)( physical_device, @@ -4133,7 +4196,7 @@ pub struct DeviceFnV1_1 { heap_index: uint32_t, local_device_index: uint32_t, remote_device_index: uint32_t, - p_peer_memory_features: *const PeerMemoryFeatureFlags, + p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void, cmd_set_device_mask: extern "system" fn(command_buffer: CommandBuffer, device_mask: uint32_t) -> c_void, @@ -4150,20 +4213,20 @@ pub struct DeviceFnV1_1 { extern "system" fn( device: Device, p_info: *const ImageMemoryRequirementsInfo2, - p_memory_requirements: *const MemoryRequirements2, + p_memory_requirements: *mut MemoryRequirements2, ) -> c_void, get_buffer_memory_requirements2: extern "system" fn( device: Device, p_info: *const BufferMemoryRequirementsInfo2, - p_memory_requirements: *const MemoryRequirements2, + p_memory_requirements: *mut MemoryRequirements2, ) -> c_void, get_image_sparse_memory_requirements2: extern "system" fn( device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, - p_sparse_memory_requirement_count: *const uint32_t, - p_sparse_memory_requirements: *const SparseImageMemoryRequirements2, + p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void, trim_command_pool: extern "system" fn(device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags) @@ -4171,14 +4234,14 @@ pub struct DeviceFnV1_1 { get_device_queue2: extern "system" fn( device: Device, p_queue_info: *const DeviceQueueInfo2, - p_queue: *const Queue, + p_queue: *mut Queue, ) -> c_void, create_sampler_ycbcr_conversion: extern "system" fn( device: Device, p_create_info: *const SamplerYcbcrConversionCreateInfo, p_allocator: *const AllocationCallbacks, - p_ycbcr_conversion: *const SamplerYcbcrConversion, + p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result, destroy_sampler_ycbcr_conversion: extern "system" fn( device: Device, @@ -4190,7 +4253,7 @@ pub struct DeviceFnV1_1 { device: Device, p_create_info: *const DescriptorUpdateTemplateCreateInfo, p_allocator: *const AllocationCallbacks, - p_descriptor_update_template: *const DescriptorUpdateTemplate, + p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result, destroy_descriptor_update_template: extern "system" fn( @@ -4209,7 +4272,7 @@ pub struct DeviceFnV1_1 { extern "system" fn( device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, - p_support: *const DescriptorSetLayoutSupport, + p_support: *mut DescriptorSetLayoutSupport, ) -> c_void, } unsafe impl Send for DeviceFnV1_1 {} @@ -4416,7 +4479,7 @@ impl DeviceFnV1_1 { heap_index: uint32_t, local_device_index: uint32_t, remote_device_index: uint32_t, - p_peer_memory_features: *const PeerMemoryFeatureFlags, + p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void { (self.get_device_group_peer_memory_features)( device, @@ -4457,7 +4520,7 @@ impl DeviceFnV1_1 { &self, device: Device, p_info: *const ImageMemoryRequirementsInfo2, - p_memory_requirements: *const MemoryRequirements2, + p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { (self.get_image_memory_requirements2)(device, p_info, p_memory_requirements) } @@ -4465,7 +4528,7 @@ impl DeviceFnV1_1 { &self, device: Device, p_info: *const BufferMemoryRequirementsInfo2, - p_memory_requirements: *const MemoryRequirements2, + p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { (self.get_buffer_memory_requirements2)(device, p_info, p_memory_requirements) } @@ -4473,8 +4536,8 @@ impl DeviceFnV1_1 { &self, device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, - p_sparse_memory_requirement_count: *const uint32_t, - p_sparse_memory_requirements: *const SparseImageMemoryRequirements2, + p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void { (self.get_image_sparse_memory_requirements2)( device, @@ -4495,7 +4558,7 @@ impl DeviceFnV1_1 { &self, device: Device, p_queue_info: *const DeviceQueueInfo2, - p_queue: *const Queue, + p_queue: *mut Queue, ) -> c_void { (self.get_device_queue2)(device, p_queue_info, p_queue) } @@ -4504,7 +4567,7 @@ impl DeviceFnV1_1 { device: Device, p_create_info: *const SamplerYcbcrConversionCreateInfo, p_allocator: *const AllocationCallbacks, - p_ycbcr_conversion: *const SamplerYcbcrConversion, + p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result { (self.create_sampler_ycbcr_conversion)( device, @@ -4526,7 +4589,7 @@ impl DeviceFnV1_1 { device: Device, p_create_info: *const DescriptorUpdateTemplateCreateInfo, p_allocator: *const AllocationCallbacks, - p_descriptor_update_template: *const DescriptorUpdateTemplate, + p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result { (self.create_descriptor_update_template)( device, @@ -4561,7 +4624,7 @@ impl DeviceFnV1_1 { &self, device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, - p_support: *const DescriptorSetLayoutSupport, + p_support: *mut DescriptorSetLayoutSupport, ) -> c_void { (self.get_descriptor_set_layout_support)(device, p_create_info, p_support) } @@ -4797,7 +4860,7 @@ handle_nondispatchable!(DebugUtilsMessengerEXT); #[allow(non_camel_case_types)] pub type PFN_vkInternalAllocationNotification = unsafe extern "system" fn( - p_user_data: *const c_void, + p_user_data: *mut c_void, size: size_t, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationScope, @@ -4805,7 +4868,7 @@ pub type PFN_vkInternalAllocationNotification = #[allow(non_camel_case_types)] pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn( - p_user_data: *const c_void, + p_user_data: *mut c_void, size: size_t, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationScope, @@ -4813,23 +4876,23 @@ pub type PFN_vkInternalFreeNotification = #[allow(non_camel_case_types)] pub type PFN_vkReallocationFunction = unsafe extern "system" fn( - p_user_data: *const c_void, - p_original: *const c_void, + p_user_data: *mut c_void, + p_original: *mut c_void, size: size_t, alignment: size_t, allocation_scope: SystemAllocationScope, - ) -> *const c_void; + ) -> *mut c_void; #[allow(non_camel_case_types)] pub type PFN_vkAllocationFunction = unsafe extern "system" fn( - p_user_data: *const c_void, + p_user_data: *mut c_void, size: size_t, alignment: size_t, allocation_scope: SystemAllocationScope, - ) -> *const c_void; + ) -> *mut c_void; #[allow(non_camel_case_types)] pub type PFN_vkFreeFunction = - unsafe extern "system" fn(p_user_data: *const c_void, p_memory: *const c_void) -> c_void; + unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkVoidFunction = unsafe extern "system" fn() -> c_void; #[allow(non_camel_case_types)] @@ -4842,7 +4905,7 @@ pub type PFN_vkDebugReportCallbackEXT = message_code: int32_t, p_layer_prefix: *const c_char, p_message: *const c_char, - p_user_data: *const c_void, + p_user_data: *mut c_void, ) -> Bool32; #[allow(non_camel_case_types)] pub type PFN_vkDebugUtilsMessengerCallbackEXT = @@ -4850,13 +4913,13 @@ pub type PFN_vkDebugUtilsMessengerCallbackEXT = message_severity: DebugUtilsMessageSeverityFlagsEXT, message_type: DebugUtilsMessageTypeFlagsEXT, p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, - p_user_data: *const c_void, + p_user_data: *mut c_void, ) -> Bool32; #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BaseOutStructure { pub s_type: StructureType, - pub p_next: *const BaseOutStructure, + pub p_next: *mut BaseOutStructure, } impl ::std::default::Default for BaseOutStructure { fn default() -> BaseOutStructure { @@ -5067,7 +5130,7 @@ impl ::std::default::Default for ApplicationInfo { #[repr(C)] #[derive(Copy, Clone)] pub struct AllocationCallbacks { - pub p_user_data: *const c_void, + pub p_user_data: *mut c_void, pub pfn_allocation: PFN_vkAllocationFunction, pub pfn_reallocation: PFN_vkReallocationFunction, pub pfn_free: PFN_vkFreeFunction, @@ -7513,7 +7576,7 @@ pub struct AndroidSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub flags: AndroidSurfaceCreateFlagsKHR, - pub window: *const ANativeWindow, + pub window: *mut ANativeWindow, } impl ::std::default::Default for AndroidSurfaceCreateInfoKHR { fn default() -> AndroidSurfaceCreateInfoKHR { @@ -7531,8 +7594,8 @@ pub struct MirSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub flags: MirSurfaceCreateFlagsKHR, - pub connection: *const MirConnection, - pub mir_surface: *const MirSurface, + pub connection: *mut MirConnection, + pub mir_surface: *mut MirSurface, } impl ::std::default::Default for MirSurfaceCreateInfoKHR { fn default() -> MirSurfaceCreateInfoKHR { @@ -7551,7 +7614,7 @@ pub struct ViSurfaceCreateInfoNN { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ViSurfaceCreateFlagsNN, - pub window: *const c_void, + pub window: *mut c_void, } impl ::std::default::Default for ViSurfaceCreateInfoNN { fn default() -> ViSurfaceCreateInfoNN { @@ -7569,8 +7632,8 @@ pub struct WaylandSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub flags: WaylandSurfaceCreateFlagsKHR, - pub display: *const wl_display, - pub surface: *const wl_surface, + pub display: *mut wl_display, + pub surface: *mut wl_surface, } impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { fn default() -> WaylandSurfaceCreateInfoKHR { @@ -7609,7 +7672,7 @@ pub struct XlibSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub flags: XlibSurfaceCreateFlagsKHR, - pub dpy: *const Display, + pub dpy: *mut Display, pub window: Window, } impl ::std::default::Default for XlibSurfaceCreateInfoKHR { @@ -7629,7 +7692,7 @@ pub struct XcbSurfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub flags: XcbSurfaceCreateFlagsKHR, - pub connection: *const xcb_connection_t, + pub connection: *mut xcb_connection_t, pub window: xcb_window_t, } impl ::std::default::Default for XcbSurfaceCreateInfoKHR { @@ -7705,7 +7768,7 @@ pub struct PresentInfoKHR { pub swapchain_count: uint32_t, pub p_swapchains: *const SwapchainKHR, pub p_image_indices: *const uint32_t, - pub p_results: *const Result, + pub p_results: *mut Result, } impl ::std::default::Default for PresentInfoKHR { fn default() -> PresentInfoKHR { @@ -7728,7 +7791,7 @@ pub struct DebugReportCallbackCreateInfoEXT { pub p_next: *const c_void, pub flags: DebugReportFlagsEXT, pub pfn_callback: PFN_vkDebugReportCallbackEXT, - pub p_user_data: *const c_void, + pub p_user_data: *mut c_void, } impl ::std::fmt::Debug for DebugReportCallbackCreateInfoEXT { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { @@ -7758,7 +7821,7 @@ pub struct ValidationFlagsEXT { pub s_type: StructureType, pub p_next: *const c_void, pub disabled_validation_check_count: uint32_t, - pub p_disabled_validation_checks: *const ValidationCheckEXT, + pub p_disabled_validation_checks: *mut ValidationCheckEXT, } impl ::std::default::Default for ValidationFlagsEXT { fn default() -> ValidationFlagsEXT { @@ -8225,7 +8288,7 @@ pub struct ObjectTablePushConstantEntryNVX { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceFeatures2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub features: PhysicalDeviceFeatures, } impl ::std::default::Default for PhysicalDeviceFeatures2 { @@ -8244,7 +8307,7 @@ pub struct PhysicalDeviceFeatures2KHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProperties2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub properties: PhysicalDeviceProperties, } impl ::std::default::Default for PhysicalDeviceProperties2 { @@ -8263,7 +8326,7 @@ pub struct PhysicalDeviceProperties2KHR {} #[derive(Copy, Clone, Debug)] pub struct FormatProperties2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub format_properties: FormatProperties, } impl ::std::default::Default for FormatProperties2 { @@ -8282,7 +8345,7 @@ pub struct FormatProperties2KHR {} #[derive(Copy, Clone, Debug)] pub struct ImageFormatProperties2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub image_format_properties: ImageFormatProperties, } impl ::std::default::Default for ImageFormatProperties2 { @@ -8328,7 +8391,7 @@ pub struct PhysicalDeviceImageFormatInfo2KHR {} #[derive(Copy, Clone, Debug)] pub struct QueueFamilyProperties2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub queue_family_properties: QueueFamilyProperties, } impl ::std::default::Default for QueueFamilyProperties2 { @@ -8347,7 +8410,7 @@ pub struct QueueFamilyProperties2KHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMemoryProperties2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub memory_properties: PhysicalDeviceMemoryProperties, } impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { @@ -8366,7 +8429,7 @@ pub struct PhysicalDeviceMemoryProperties2KHR {} #[derive(Copy, Clone, Debug)] pub struct SparseImageFormatProperties2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub properties: SparseImageFormatProperties, } impl ::std::default::Default for SparseImageFormatProperties2 { @@ -8412,7 +8475,7 @@ pub struct PhysicalDeviceSparseImageFormatInfo2KHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePushDescriptorPropertiesKHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_push_descriptors: uint32_t, } impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { @@ -8467,7 +8530,7 @@ pub struct RectLayerKHR { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVariablePointerFeatures { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub variable_pointers_storage_buffer: Bool32, pub variable_pointers: Bool32, } @@ -8517,7 +8580,7 @@ pub struct PhysicalDeviceExternalImageFormatInfoKHR {} #[derive(Copy, Clone, Debug)] pub struct ExternalImageFormatProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub external_memory_properties: ExternalMemoryProperties, } impl ::std::default::Default for ExternalImageFormatProperties { @@ -8559,7 +8622,7 @@ pub struct PhysicalDeviceExternalBufferInfoKHR {} #[derive(Copy, Clone, Debug)] pub struct ExternalBufferProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub external_memory_properties: ExternalMemoryProperties, } impl ::std::default::Default for ExternalBufferProperties { @@ -8578,7 +8641,7 @@ pub struct ExternalBufferPropertiesKHR {} #[derive(Copy, Clone)] pub struct PhysicalDeviceIDProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub device_uuid: [uint8_t; VK_UUID_SIZE], pub driver_uuid: [uint8_t; VK_UUID_SIZE], pub device_luid: [uint8_t; VK_LUID_SIZE], @@ -8721,7 +8784,7 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { #[derive(Copy, Clone, Debug)] pub struct MemoryWin32HandlePropertiesKHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub memory_type_bits: uint32_t, } impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { @@ -8773,7 +8836,7 @@ impl ::std::default::Default for ImportMemoryFdInfoKHR { #[derive(Copy, Clone, Debug)] pub struct MemoryFdPropertiesKHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub memory_type_bits: uint32_t, } impl ::std::default::Default for MemoryFdPropertiesKHR { @@ -8854,7 +8917,7 @@ pub struct PhysicalDeviceExternalSemaphoreInfoKHR {} #[derive(Copy, Clone, Debug)] pub struct ExternalSemaphoreProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags, pub external_semaphore_features: ExternalSemaphoreFeatureFlags, @@ -9039,7 +9102,7 @@ pub struct PhysicalDeviceExternalFenceInfoKHR {} #[derive(Copy, Clone, Debug)] pub struct ExternalFenceProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags, pub compatible_handle_types: ExternalFenceHandleTypeFlags, pub external_fence_features: ExternalFenceFeatureFlags, @@ -9183,7 +9246,7 @@ impl ::std::default::Default for FenceGetFdInfoKHR { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewFeatures { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub multiview: Bool32, pub multiview_geometry_shader: Bool32, pub multiview_tessellation_shader: Bool32, @@ -9206,7 +9269,7 @@ pub struct PhysicalDeviceMultiviewFeaturesKHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_multiview_view_count: uint32_t, pub max_multiview_instance_index: uint32_t, } @@ -9256,7 +9319,7 @@ pub struct RenderPassMultiviewCreateInfoKHR {} #[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2EXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub min_image_count: uint32_t, pub max_image_count: uint32_t, pub current_extent: Extent2D, @@ -9356,7 +9419,7 @@ impl ::std::default::Default for SwapchainCounterCreateInfoEXT { #[derive(Copy, Clone)] pub struct PhysicalDeviceGroupProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub physical_device_count: uint32_t, pub physical_devices: [PhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, @@ -9755,7 +9818,7 @@ pub struct DescriptorUpdateTemplateEntryKHR {} #[derive(Copy, Clone, Debug)] pub struct DescriptorUpdateTemplateCreateInfo { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub flags: DescriptorUpdateTemplateCreateFlags, pub descriptor_update_entry_count: uint32_t, pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry, @@ -9952,7 +10015,7 @@ impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_discard_rectangles: uint32_t, } impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { @@ -9990,7 +10053,7 @@ impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub per_view_position_all_components: Bool32, } impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { @@ -10053,7 +10116,7 @@ impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR { #[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2KHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub surface_capabilities: SurfaceCapabilitiesKHR, } impl ::std::default::Default for SurfaceCapabilities2KHR { @@ -10069,7 +10132,7 @@ impl ::std::default::Default for SurfaceCapabilities2KHR { #[derive(Copy, Clone, Debug)] pub struct SurfaceFormat2KHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub surface_format: SurfaceFormatKHR, } impl ::std::default::Default for SurfaceFormat2KHR { @@ -10085,7 +10148,7 @@ impl ::std::default::Default for SurfaceFormat2KHR { #[derive(Copy, Clone, Debug)] pub struct DisplayProperties2KHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub display_properties: DisplayPropertiesKHR, } impl ::std::default::Default for DisplayProperties2KHR { @@ -10101,7 +10164,7 @@ impl ::std::default::Default for DisplayProperties2KHR { #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneProperties2KHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub display_plane_properties: DisplayPlanePropertiesKHR, } impl ::std::default::Default for DisplayPlaneProperties2KHR { @@ -10117,7 +10180,7 @@ impl ::std::default::Default for DisplayPlaneProperties2KHR { #[derive(Copy, Clone, Debug)] pub struct DisplayModeProperties2KHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub display_mode_properties: DisplayModePropertiesKHR, } impl ::std::default::Default for DisplayModeProperties2KHR { @@ -10151,7 +10214,7 @@ impl ::std::default::Default for DisplayPlaneInfo2KHR { #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneCapabilities2KHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub capabilities: DisplayPlaneCapabilitiesKHR, } impl ::std::default::Default for DisplayPlaneCapabilities2KHR { @@ -10167,7 +10230,7 @@ impl ::std::default::Default for DisplayPlaneCapabilities2KHR { #[derive(Copy, Clone, Debug)] pub struct SharedPresentSurfaceCapabilitiesKHR { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub shared_present_supported_usage_flags: ImageUsageFlags, } impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { @@ -10183,7 +10246,7 @@ impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { #[derive(Copy, Clone, Debug)] pub struct PhysicalDevice16BitStorageFeatures { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub storage_buffer16_bit_access: Bool32, pub uniform_and_storage_buffer16_bit_access: Bool32, pub storage_push_constant16: Bool32, @@ -10208,7 +10271,7 @@ pub struct PhysicalDevice16BitStorageFeaturesKHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSubgroupProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub subgroup_size: uint32_t, pub supported_stages: ShaderStageFlags, pub supported_operations: SubgroupFeatureFlags, @@ -10287,7 +10350,7 @@ pub struct ImageSparseMemoryRequirementsInfo2KHR {} #[derive(Copy, Clone, Debug)] pub struct MemoryRequirements2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub memory_requirements: MemoryRequirements, } impl ::std::default::Default for MemoryRequirements2 { @@ -10306,7 +10369,7 @@ pub struct MemoryRequirements2KHR {} #[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryRequirements2 { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub memory_requirements: SparseImageMemoryRequirements, } impl ::std::default::Default for SparseImageMemoryRequirements2 { @@ -10325,7 +10388,7 @@ pub struct SparseImageMemoryRequirements2KHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePointClippingProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub point_clipping_behavior: PointClippingBehavior, } impl ::std::default::Default for PhysicalDevicePointClippingProperties { @@ -10344,7 +10407,7 @@ pub struct PhysicalDevicePointClippingPropertiesKHR {} #[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedRequirements { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub prefers_dedicated_allocation: Bool32, pub requires_dedicated_allocation: Bool32, } @@ -10514,7 +10577,7 @@ pub struct ImagePlaneMemoryRequirementsInfoKHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub sampler_ycbcr_conversion: Bool32, } impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { @@ -10533,7 +10596,7 @@ pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR {} #[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionImageFormatProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub combined_image_sampler_descriptor_count: uint32_t, } impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { @@ -10552,7 +10615,7 @@ pub struct SamplerYcbcrConversionImageFormatPropertiesKHR {} #[derive(Copy, Clone, Debug)] pub struct TextureLODGatherFormatPropertiesAMD { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub supports_texture_gather_lod_bias_amd: Bool32, } impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD { @@ -10584,7 +10647,7 @@ impl ::std::default::Default for ProtectedSubmitInfo { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryFeatures { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub protected_memory: Bool32, } impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { @@ -10600,7 +10663,7 @@ impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryProperties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub protected_no_fault: Bool32, } impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties { @@ -10656,7 +10719,7 @@ impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub filter_minmax_single_component_formats: Bool32, pub filter_minmax_image_component_mapping: Bool32, } @@ -10754,7 +10817,7 @@ impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { #[derive(Copy, Clone)] pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub sample_location_sample_counts: SampleCountFlags, pub max_sample_location_grid_size: Extent2D, pub sample_location_coordinate_range: [c_float; 2], @@ -10804,7 +10867,7 @@ impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { #[derive(Copy, Clone, Debug)] pub struct MultisamplePropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_sample_location_grid_size: Extent2D, } impl ::std::default::Default for MultisamplePropertiesEXT { @@ -10836,7 +10899,7 @@ impl ::std::default::Default for SamplerReductionModeCreateInfoEXT { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub advanced_blend_coherent_operations: Bool32, } impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { @@ -10852,7 +10915,7 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub advanced_blend_max_color_attachments: uint32_t, pub advanced_blend_independent_blend: Bool32, pub advanced_blend_non_premultiplied_src_color: Bool32, @@ -10976,7 +11039,7 @@ impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMaintenance3Properties { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_per_set_descriptors: uint32_t, pub max_memory_allocation_size: DeviceSize, } @@ -10997,7 +11060,7 @@ pub struct PhysicalDeviceMaintenance3PropertiesKHR {} #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutSupport { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub supported: Bool32, } impl ::std::default::Default for DescriptorSetLayoutSupport { @@ -11016,7 +11079,7 @@ pub struct DescriptorSetLayoutSupportKHR {} #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderDrawParameterFeatures { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub shader_draw_parameters: Bool32, } impl ::std::default::Default for PhysicalDeviceShaderDrawParameterFeatures { @@ -11197,7 +11260,7 @@ pub struct DebugUtilsMessengerCreateInfoEXT { pub message_severity: DebugUtilsMessageSeverityFlagsEXT, pub message_type: DebugUtilsMessageTypeFlagsEXT, pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, - pub p_user_data: *const c_void, + pub p_user_data: *mut c_void, } impl ::std::fmt::Debug for DebugUtilsMessengerCreateInfoEXT { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { @@ -11235,11 +11298,11 @@ pub struct DebugUtilsMessengerCallbackDataEXT { pub message_id_number: int32_t, pub p_message: *const c_char, pub queue_label_count: uint32_t, - pub p_queue_labels: *const DebugUtilsLabelEXT, + pub p_queue_labels: *mut DebugUtilsLabelEXT, pub cmd_buf_label_count: uint32_t, - pub p_cmd_buf_labels: *const DebugUtilsLabelEXT, + pub p_cmd_buf_labels: *mut DebugUtilsLabelEXT, pub object_count: uint32_t, - pub p_objects: *const DebugUtilsObjectNameInfoEXT, + pub p_objects: *mut DebugUtilsObjectNameInfoEXT, } impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { fn default() -> DebugUtilsMessengerCallbackDataEXT { @@ -11265,7 +11328,7 @@ pub struct ImportMemoryHostPointerInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, - pub p_host_pointer: *const c_void, + pub p_host_pointer: *mut c_void, } impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { fn default() -> ImportMemoryHostPointerInfoEXT { @@ -11281,7 +11344,7 @@ impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { #[derive(Copy, Clone, Debug)] pub struct MemoryHostPointerPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub memory_type_bits: uint32_t, } impl ::std::default::Default for MemoryHostPointerPropertiesEXT { @@ -11297,7 +11360,7 @@ impl ::std::default::Default for MemoryHostPointerPropertiesEXT { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub min_imported_host_pointer_alignment: DeviceSize, } impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { @@ -11313,7 +11376,7 @@ impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub primitive_overestimation_size: c_float, pub max_extra_primitive_overestimation_size: c_float, pub extra_primitive_overestimation_size_granularity: c_float, @@ -11345,7 +11408,7 @@ impl ::std::default::Default for PhysicalDeviceConservativeRasterizationProperti #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderCorePropertiesAMD { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub shader_engine_count: uint32_t, pub shader_arrays_per_engine_count: uint32_t, pub compute_units_per_shader_array: uint32_t, @@ -11407,7 +11470,7 @@ impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInf #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingFeaturesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub shader_input_attachment_array_dynamic_indexing: Bool32, pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32, pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32, @@ -11461,7 +11524,7 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeaturesEXT { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_update_after_bind_descriptors_in_all_pools: uint32_t, pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, pub shader_sampled_image_array_non_uniform_indexing_native: Bool32, @@ -11557,7 +11620,7 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInf #[derive(Copy, Clone, Debug)] pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_variable_descriptor_count: uint32_t, } impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupportEXT { @@ -11597,7 +11660,7 @@ impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_vertex_attrib_divisor: uint32_t, } impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { @@ -11614,7 +11677,7 @@ impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesE pub struct ImportAndroidHardwareBufferInfoANDROID { pub s_type: StructureType, pub p_next: *const c_void, - pub buffer: *const AHardwareBuffer, + pub buffer: *mut AHardwareBuffer, } impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { fn default() -> ImportAndroidHardwareBufferInfoANDROID { @@ -11629,7 +11692,7 @@ impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferUsageANDROID { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub android_hardware_buffer_usage: uint64_t, } impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { @@ -11645,7 +11708,7 @@ impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferPropertiesANDROID { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub allocation_size: DeviceSize, pub memory_type_bits: uint32_t, } @@ -11679,7 +11742,7 @@ impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID { #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferFormatPropertiesANDROID { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub format: Format, pub external_format: uint64_t, pub format_features: FormatFeatureFlags, @@ -11709,7 +11772,7 @@ impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { #[derive(Copy, Clone, Debug)] pub struct ExternalFormatANDROID { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub external_format: uint64_t, } impl ::std::default::Default for ExternalFormatANDROID { @@ -13475,27 +13538,27 @@ pub mod extensions { physical_device: PhysicalDevice, queue_family_index: uint32_t, surface: SurfaceKHR, - p_supported: *const Bool32, + p_supported: *mut Bool32, ) -> Result, get_physical_device_surface_capabilities_khr: extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_capabilities: *const SurfaceCapabilitiesKHR, + p_surface_capabilities: *mut SurfaceCapabilitiesKHR, ) -> Result, get_physical_device_surface_formats_khr: extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_format_count: *const uint32_t, - p_surface_formats: *const SurfaceFormatKHR, + p_surface_format_count: *mut uint32_t, + p_surface_formats: *mut SurfaceFormatKHR, ) -> Result, get_physical_device_surface_present_modes_khr: extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_present_mode_count: *const uint32_t, - p_present_modes: *const PresentModeKHR, + p_present_mode_count: *mut uint32_t, + p_present_modes: *mut PresentModeKHR, ) -> Result, } unsafe impl Send for KhrSurfaceFn {} @@ -13587,7 +13650,7 @@ pub mod extensions { physical_device: PhysicalDevice, queue_family_index: uint32_t, surface: SurfaceKHR, - p_supported: *const Bool32, + p_supported: *mut Bool32, ) -> Result { (self.get_physical_device_surface_support_khr)( physical_device, @@ -13600,7 +13663,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_capabilities: *const SurfaceCapabilitiesKHR, + p_surface_capabilities: *mut SurfaceCapabilitiesKHR, ) -> Result { (self.get_physical_device_surface_capabilities_khr)( physical_device, @@ -13612,8 +13675,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_format_count: *const uint32_t, - p_surface_formats: *const SurfaceFormatKHR, + p_surface_format_count: *mut uint32_t, + p_surface_formats: *mut SurfaceFormatKHR, ) -> Result { (self.get_physical_device_surface_formats_khr)( physical_device, @@ -13626,8 +13689,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_present_mode_count: *const uint32_t, - p_present_modes: *const PresentModeKHR, + p_present_mode_count: *mut uint32_t, + p_present_modes: *mut PresentModeKHR, ) -> Result { (self.get_physical_device_surface_present_modes_khr)( physical_device, @@ -13649,7 +13712,7 @@ pub mod extensions { impl ObjectType { pub const SURFACE_KHR: Self = ObjectType(1000000000); } - pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *const SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *const uint32_t , p_swapchain_images : *const Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : uint64_t , semaphore : Semaphore , fence : Fence , p_image_index : *const uint32_t , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } + pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *mut SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *mut uint32_t , p_swapchain_images : *mut Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : uint64_t , semaphore : Semaphore , fence : Fence , p_image_index : *mut uint32_t , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut uint32_t , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut uint32_t , ) -> Result , } unsafe impl Send for KhrSwapchainFn {} unsafe impl Sync for KhrSwapchainFn {} impl ::std::clone::Clone for KhrSwapchainFn { @@ -13770,7 +13833,7 @@ pub mod extensions { device: Device, p_create_info: *const SwapchainCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_swapchain: *const SwapchainKHR, + p_swapchain: *mut SwapchainKHR, ) -> Result { (self.create_swapchain_khr)(device, p_create_info, p_allocator, p_swapchain) } @@ -13786,8 +13849,8 @@ pub mod extensions { &self, device: Device, swapchain: SwapchainKHR, - p_swapchain_image_count: *const uint32_t, - p_swapchain_images: *const Image, + p_swapchain_image_count: *mut uint32_t, + p_swapchain_images: *mut Image, ) -> Result { (self.get_swapchain_images_khr)( device, @@ -13803,7 +13866,7 @@ pub mod extensions { timeout: uint64_t, semaphore: Semaphore, fence: Fence, - p_image_index: *const uint32_t, + p_image_index: *mut uint32_t, ) -> Result { (self.acquire_next_image_khr)( device, @@ -13824,7 +13887,7 @@ pub mod extensions { pub unsafe fn get_device_group_present_capabilities_khr( &self, device: Device, - p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, + p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, ) -> Result { (self.get_device_group_present_capabilities_khr)( device, @@ -13835,7 +13898,7 @@ pub mod extensions { &self, device: Device, surface: SurfaceKHR, - p_modes: *const DeviceGroupPresentModeFlagsKHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, ) -> Result { (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) } @@ -13843,8 +13906,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_rect_count: *const uint32_t, - p_rects: *const Rect2D, + p_rect_count: *mut uint32_t, + p_rects: *mut Rect2D, ) -> Result { (self.get_physical_device_present_rectangles_khr)( physical_device, @@ -13857,7 +13920,7 @@ pub mod extensions { &self, device: Device, p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *const uint32_t, + p_image_index: *mut uint32_t, ) -> Result { (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) } @@ -13922,49 +13985,49 @@ pub mod extensions { get_physical_device_display_properties_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPropertiesKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPropertiesKHR, ) -> Result, get_physical_device_display_plane_properties_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPlanePropertiesKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPlanePropertiesKHR, ) -> Result, get_display_plane_supported_displays_khr: extern "system" fn( physical_device: PhysicalDevice, plane_index: uint32_t, - p_display_count: *const uint32_t, - p_displays: *const DisplayKHR, + p_display_count: *mut uint32_t, + p_displays: *mut DisplayKHR, ) -> Result, get_display_mode_properties_khr: extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *const uint32_t, - p_properties: *const DisplayModePropertiesKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayModePropertiesKHR, ) -> Result, create_display_mode_khr: extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, p_create_info: *const DisplayModeCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_mode: *const DisplayModeKHR, + p_mode: *mut DisplayModeKHR, ) -> Result, get_display_plane_capabilities_khr: extern "system" fn( physical_device: PhysicalDevice, mode: DisplayModeKHR, plane_index: uint32_t, - p_capabilities: *const DisplayPlaneCapabilitiesKHR, + p_capabilities: *mut DisplayPlaneCapabilitiesKHR, ) -> Result, create_display_plane_surface_khr: extern "system" fn( instance: Instance, p_create_info: *const DisplaySurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, } unsafe impl Send for KhrDisplayFn {} @@ -14065,8 +14128,8 @@ pub mod extensions { pub unsafe fn get_physical_device_display_properties_khr( &self, physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPropertiesKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPropertiesKHR, ) -> Result { (self.get_physical_device_display_properties_khr)( physical_device, @@ -14077,8 +14140,8 @@ pub mod extensions { pub unsafe fn get_physical_device_display_plane_properties_khr( &self, physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPlanePropertiesKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPlanePropertiesKHR, ) -> Result { (self.get_physical_device_display_plane_properties_khr)( physical_device, @@ -14090,8 +14153,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, plane_index: uint32_t, - p_display_count: *const uint32_t, - p_displays: *const DisplayKHR, + p_display_count: *mut uint32_t, + p_displays: *mut DisplayKHR, ) -> Result { (self.get_display_plane_supported_displays_khr)( physical_device, @@ -14104,8 +14167,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *const uint32_t, - p_properties: *const DisplayModePropertiesKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayModePropertiesKHR, ) -> Result { (self.get_display_mode_properties_khr)( physical_device, @@ -14120,7 +14183,7 @@ pub mod extensions { display: DisplayKHR, p_create_info: *const DisplayModeCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_mode: *const DisplayModeKHR, + p_mode: *mut DisplayModeKHR, ) -> Result { (self.create_display_mode_khr)( physical_device, @@ -14135,7 +14198,7 @@ pub mod extensions { physical_device: PhysicalDevice, mode: DisplayModeKHR, plane_index: uint32_t, - p_capabilities: *const DisplayPlaneCapabilitiesKHR, + p_capabilities: *mut DisplayPlaneCapabilitiesKHR, ) -> Result { (self.get_display_plane_capabilities_khr)( physical_device, @@ -14149,7 +14212,7 @@ pub mod extensions { instance: Instance, p_create_info: *const DisplaySurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_display_plane_surface_khr)(instance, p_create_info, p_allocator, p_surface) } @@ -14177,7 +14240,7 @@ pub mod extensions { swapchain_count: uint32_t, p_create_infos: *const SwapchainCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_swapchains: *const SwapchainKHR, + p_swapchains: *mut SwapchainKHR, ) -> Result, } unsafe impl Send for KhrDisplaySwapchainFn {} @@ -14218,7 +14281,7 @@ pub mod extensions { swapchain_count: uint32_t, p_create_infos: *const SwapchainCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_swapchains: *const SwapchainKHR, + p_swapchains: *mut SwapchainKHR, ) -> Result { (self.create_shared_swapchains_khr)( device, @@ -14242,13 +14305,13 @@ pub mod extensions { instance: Instance, p_create_info: *const XlibSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, get_physical_device_xlib_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, queue_family_index: uint32_t, - dpy: *const Display, + dpy: *mut Display, visual_id: VisualID, ) -> Bool32, } @@ -14300,7 +14363,7 @@ pub mod extensions { instance: Instance, p_create_info: *const XlibSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_xlib_surface_khr)(instance, p_create_info, p_allocator, p_surface) } @@ -14308,7 +14371,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, - dpy: *const Display, + dpy: *mut Display, visual_id: VisualID, ) -> Bool32 { (self.get_physical_device_xlib_presentation_support_khr)( @@ -14328,13 +14391,13 @@ pub mod extensions { instance: Instance, p_create_info: *const XcbSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, get_physical_device_xcb_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, queue_family_index: uint32_t, - connection: *const xcb_connection_t, + connection: *mut xcb_connection_t, visual_id: xcb_visualid_t, ) -> Bool32, } @@ -14386,7 +14449,7 @@ pub mod extensions { instance: Instance, p_create_info: *const XcbSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_xcb_surface_khr)(instance, p_create_info, p_allocator, p_surface) } @@ -14394,7 +14457,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, - connection: *const xcb_connection_t, + connection: *mut xcb_connection_t, visual_id: xcb_visualid_t, ) -> Bool32 { (self.get_physical_device_xcb_presentation_support_khr)( @@ -14415,13 +14478,13 @@ pub mod extensions { instance: Instance, p_create_info: *const WaylandSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, get_physical_device_wayland_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, queue_family_index: uint32_t, - display: *const wl_display, + display: *mut wl_display, ) -> Bool32, } unsafe impl Send for KhrWaylandSurfaceFn {} @@ -14472,7 +14535,7 @@ pub mod extensions { instance: Instance, p_create_info: *const WaylandSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_wayland_surface_khr)(instance, p_create_info, p_allocator, p_surface) } @@ -14480,7 +14543,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, - display: *const wl_display, + display: *mut wl_display, ) -> Bool32 { (self.get_physical_device_wayland_presentation_support_khr)( physical_device, @@ -14498,13 +14561,13 @@ pub mod extensions { instance: Instance, p_create_info: *const MirSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, get_physical_device_mir_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, queue_family_index: uint32_t, - connection: *const MirConnection, + connection: *mut MirConnection, ) -> Bool32, } unsafe impl Send for KhrMirSurfaceFn {} @@ -14555,7 +14618,7 @@ pub mod extensions { instance: Instance, p_create_info: *const MirSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_mir_surface_khr)(instance, p_create_info, p_allocator, p_surface) } @@ -14563,7 +14626,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, queue_family_index: uint32_t, - connection: *const MirConnection, + connection: *mut MirConnection, ) -> Bool32 { (self.get_physical_device_mir_presentation_support_khr)( physical_device, @@ -14582,7 +14645,7 @@ pub mod extensions { instance: Instance, p_create_info: *const AndroidSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, } unsafe impl Send for KhrAndroidSurfaceFn {} @@ -14622,7 +14685,7 @@ pub mod extensions { instance: Instance, p_create_info: *const AndroidSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_android_surface_khr)(instance, p_create_info, p_allocator, p_surface) } @@ -14637,7 +14700,7 @@ pub mod extensions { instance: Instance, p_create_info: *const Win32SurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, get_physical_device_win32_presentation_support_khr: extern "system" fn(physical_device: PhysicalDevice, queue_family_index: uint32_t) @@ -14691,7 +14754,7 @@ pub mod extensions { instance: Instance, p_create_info: *const Win32SurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_win32_surface_khr)(instance, p_create_info, p_allocator, p_surface) } @@ -14715,7 +14778,7 @@ pub mod extensions { device: Device, format: Format, image_usage: ImageUsageFlags, - gralloc_usage: *const c_int, + gralloc_usage: *mut c_int, ) -> Result, acquire_image_android: extern "system" fn( device: Device, @@ -14729,7 +14792,7 @@ pub mod extensions { wait_semaphore_count: uint32_t, p_wait_semaphores: *const Semaphore, image: Image, - p_native_fence_fd: *const c_int, + p_native_fence_fd: *mut c_int, ) -> Result, } unsafe impl Send for AndroidNativeBufferFn {} @@ -14789,7 +14852,7 @@ pub mod extensions { device: Device, format: Format, image_usage: ImageUsageFlags, - gralloc_usage: *const c_int, + gralloc_usage: *mut c_int, ) -> Result { (self.get_swapchain_gralloc_usage_android)(device, format, image_usage, gralloc_usage) } @@ -14809,7 +14872,7 @@ pub mod extensions { wait_semaphore_count: uint32_t, p_wait_semaphores: *const Semaphore, image: Image, - p_native_fence_fd: *const c_int, + p_native_fence_fd: *mut c_int, ) -> Result { (self.queue_signal_release_image_android)( queue, @@ -14830,7 +14893,7 @@ pub mod extensions { instance: Instance, p_create_info: *const DebugReportCallbackCreateInfoEXT, p_allocator: *const AllocationCallbacks, - p_callback: *const DebugReportCallbackEXT, + p_callback: *mut DebugReportCallbackEXT, ) -> Result, destroy_debug_report_callback_ext: extern "system" fn( @@ -14906,7 +14969,7 @@ pub mod extensions { instance: Instance, p_create_info: *const DebugReportCallbackCreateInfoEXT, p_allocator: *const AllocationCallbacks, - p_callback: *const DebugReportCallbackEXT, + p_callback: *mut DebugReportCallbackEXT, ) -> Result { (self.create_debug_report_callback_ext)( instance, @@ -15859,8 +15922,8 @@ pub mod extensions { pipeline: Pipeline, shader_stage: ShaderStageFlags, info_type: ShaderInfoTypeAMD, - p_info_size: *const size_t, - p_info: *const c_void, + p_info_size: *mut size_t, + p_info: *mut c_void, ) -> Result, } unsafe impl Send for AmdShaderInfoFn {} @@ -15901,8 +15964,8 @@ pub mod extensions { pipeline: Pipeline, shader_stage: ShaderStageFlags, info_type: ShaderInfoTypeAMD, - p_info_size: *const size_t, - p_info: *const c_void, + p_info_size: *mut size_t, + p_info: *mut c_void, ) -> Result { (self.get_shader_info_amd)( device, @@ -16210,7 +16273,7 @@ pub mod extensions { impl Format { pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Format(1000054007); } - pub struct NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv : extern "system" fn ( physical_device : PhysicalDevice , format : Format , ty : ImageType , tiling : ImageTiling , usage : ImageUsageFlags , flags : ImageCreateFlags , external_handle_type : ExternalMemoryHandleTypeFlagsNV , p_external_image_format_properties : *const ExternalImageFormatPropertiesNV , ) -> Result , } + pub struct NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv : extern "system" fn ( physical_device : PhysicalDevice , format : Format , ty : ImageType , tiling : ImageTiling , usage : ImageUsageFlags , flags : ImageCreateFlags , external_handle_type : ExternalMemoryHandleTypeFlagsNV , p_external_image_format_properties : *mut ExternalImageFormatPropertiesNV , ) -> Result , } unsafe impl Send for NvExternalMemoryCapabilitiesFn {} unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { @@ -16253,7 +16316,7 @@ pub mod extensions { usage: ImageUsageFlags, flags: ImageCreateFlags, external_handle_type: ExternalMemoryHandleTypeFlagsNV, - p_external_image_format_properties: *const ExternalImageFormatPropertiesNV, + p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, ) -> Result { (self.get_physical_device_external_image_format_properties_nv)( physical_device, @@ -16303,7 +16366,7 @@ pub mod extensions { device: Device, memory: DeviceMemory, handle_type: ExternalMemoryHandleTypeFlagsNV, - p_handle: *const HANDLE, + p_handle: *mut HANDLE, ) -> Result, } unsafe impl Send for NvExternalMemoryWin32Fn {} @@ -16343,7 +16406,7 @@ pub mod extensions { device: Device, memory: DeviceMemory, handle_type: ExternalMemoryHandleTypeFlagsNV, - p_handle: *const HANDLE, + p_handle: *mut HANDLE, ) -> Result { (self.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle) } @@ -16404,7 +16467,7 @@ pub mod extensions { } } } - pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *const DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *const DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *const uint32_t , p_rects : *const Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *const uint32_t , ) -> Result , } + pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut uint32_t , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut uint32_t , ) -> Result , } unsafe impl Send for KhrDeviceGroupFn {} unsafe impl Sync for KhrDeviceGroupFn {} impl ::std::clone::Clone for KhrDeviceGroupFn { @@ -16473,7 +16536,7 @@ pub mod extensions { pub unsafe fn get_device_group_present_capabilities_khr( &self, device: Device, - p_device_group_present_capabilities: *const DeviceGroupPresentCapabilitiesKHR, + p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, ) -> Result { (self.get_device_group_present_capabilities_khr)( device, @@ -16484,7 +16547,7 @@ pub mod extensions { &self, device: Device, surface: SurfaceKHR, - p_modes: *const DeviceGroupPresentModeFlagsKHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, ) -> Result { (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) } @@ -16492,8 +16555,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_rect_count: *const uint32_t, - p_rects: *const Rect2D, + p_rect_count: *mut uint32_t, + p_rects: *mut Rect2D, ) -> Result { (self.get_physical_device_present_rectangles_khr)( physical_device, @@ -16506,7 +16569,7 @@ pub mod extensions { &self, device: Device, p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *const uint32_t, + p_image_index: *mut uint32_t, ) -> Result { (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) } @@ -16542,7 +16605,7 @@ pub mod extensions { instance: Instance, p_create_info: *const ViSurfaceCreateInfoNN, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, } unsafe impl Send for NnViSurfaceFn {} @@ -16582,7 +16645,7 @@ pub mod extensions { instance: Instance, p_create_info: *const ViSurfaceCreateInfoNN, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_vi_surface_nn)(instance, p_create_info, p_allocator, p_surface) } @@ -16811,7 +16874,7 @@ pub mod extensions { } } } - pub struct KhrExternalMemoryWin32Fn { get_memory_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const MemoryGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , get_memory_win32_handle_properties_khr : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , handle : HANDLE , p_memory_win32_handle_properties : *const MemoryWin32HandlePropertiesKHR , ) -> Result , } + pub struct KhrExternalMemoryWin32Fn { get_memory_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const MemoryGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , get_memory_win32_handle_properties_khr : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , handle : HANDLE , p_memory_win32_handle_properties : *mut MemoryWin32HandlePropertiesKHR , ) -> Result , } unsafe impl Send for KhrExternalMemoryWin32Fn {} unsafe impl Sync for KhrExternalMemoryWin32Fn {} impl ::std::clone::Clone for KhrExternalMemoryWin32Fn { @@ -16858,7 +16921,7 @@ pub mod extensions { &self, device: Device, p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, - p_handle: *const HANDLE, + p_handle: *mut HANDLE, ) -> Result { (self.get_memory_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) } @@ -16867,7 +16930,7 @@ pub mod extensions { device: Device, handle_type: ExternalMemoryHandleTypeFlags, handle: HANDLE, - p_memory_win32_handle_properties: *const MemoryWin32HandlePropertiesKHR, + p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, ) -> Result { (self.get_memory_win32_handle_properties_khr)( device, @@ -16897,14 +16960,14 @@ pub mod extensions { get_memory_fd_khr: extern "system" fn( device: Device, p_get_fd_info: *const MemoryGetFdInfoKHR, - p_fd: *const c_int, + p_fd: *mut c_int, ) -> Result, get_memory_fd_properties_khr: extern "system" fn( device: Device, handle_type: ExternalMemoryHandleTypeFlags, fd: c_int, - p_memory_fd_properties: *const MemoryFdPropertiesKHR, + p_memory_fd_properties: *mut MemoryFdPropertiesKHR, ) -> Result, } unsafe impl Send for KhrExternalMemoryFdFn {} @@ -16953,7 +17016,7 @@ pub mod extensions { &self, device: Device, p_get_fd_info: *const MemoryGetFdInfoKHR, - p_fd: *const c_int, + p_fd: *mut c_int, ) -> Result { (self.get_memory_fd_khr)(device, p_get_fd_info, p_fd) } @@ -16962,7 +17025,7 @@ pub mod extensions { device: Device, handle_type: ExternalMemoryHandleTypeFlags, fd: c_int, - p_memory_fd_properties: *const MemoryFdPropertiesKHR, + p_memory_fd_properties: *mut MemoryFdPropertiesKHR, ) -> Result { (self.get_memory_fd_properties_khr)(device, handle_type, fd, p_memory_fd_properties) } @@ -17049,7 +17112,7 @@ pub mod extensions { } } } - pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , } + pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } unsafe impl Send for KhrExternalSemaphoreWin32Fn {} unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} impl ::std::clone::Clone for KhrExternalSemaphoreWin32Fn { @@ -17103,7 +17166,7 @@ pub mod extensions { &self, device: Device, p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, - p_handle: *const HANDLE, + p_handle: *mut HANDLE, ) -> Result { (self.get_semaphore_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) } @@ -17133,7 +17196,7 @@ pub mod extensions { get_semaphore_fd_khr: extern "system" fn( device: Device, p_get_fd_info: *const SemaphoreGetFdInfoKHR, - p_fd: *const c_int, + p_fd: *mut c_int, ) -> Result, } unsafe impl Send for KhrExternalSemaphoreFdFn {} @@ -17189,7 +17252,7 @@ pub mod extensions { &self, device: Device, p_get_fd_info: *const SemaphoreGetFdInfoKHR, - p_fd: *const c_int, + p_fd: *mut c_int, ) -> Result { (self.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd) } @@ -17475,7 +17538,7 @@ pub mod extensions { device: Device, p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, p_allocator: *const AllocationCallbacks, - p_indirect_commands_layout: *const IndirectCommandsLayoutNVX, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, ) -> Result, destroy_indirect_commands_layout_nvx: extern "system" fn( @@ -17487,7 +17550,7 @@ pub mod extensions { device: Device, p_create_info: *const ObjectTableCreateInfoNVX, p_allocator: *const AllocationCallbacks, - p_object_table: *const ObjectTableNVX, + p_object_table: *mut ObjectTableNVX, ) -> Result, destroy_object_table_nvx: extern "system" fn( device: Device, @@ -17512,8 +17575,8 @@ pub mod extensions { get_physical_device_generated_commands_properties_nvx: extern "system" fn( physical_device: PhysicalDevice, - p_features: *const DeviceGeneratedCommandsFeaturesNVX, - p_limits: *const DeviceGeneratedCommandsLimitsNVX, + p_features: *mut DeviceGeneratedCommandsFeaturesNVX, + p_limits: *mut DeviceGeneratedCommandsLimitsNVX, ) -> c_void, } unsafe impl Send for NvxDeviceGeneratedCommandsFn {} @@ -17648,7 +17711,7 @@ pub mod extensions { device: Device, p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, p_allocator: *const AllocationCallbacks, - p_indirect_commands_layout: *const IndirectCommandsLayoutNVX, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, ) -> Result { (self.create_indirect_commands_layout_nvx)( device, @@ -17674,7 +17737,7 @@ pub mod extensions { device: Device, p_create_info: *const ObjectTableCreateInfoNVX, p_allocator: *const AllocationCallbacks, - p_object_table: *const ObjectTableNVX, + p_object_table: *mut ObjectTableNVX, ) -> Result { (self.create_object_table_nvx)(device, p_create_info, p_allocator, p_object_table) } @@ -17721,8 +17784,8 @@ pub mod extensions { pub unsafe fn get_physical_device_generated_commands_properties_nvx( &self, physical_device: PhysicalDevice, - p_features: *const DeviceGeneratedCommandsFeaturesNVX, - p_limits: *const DeviceGeneratedCommandsLimitsNVX, + p_features: *mut DeviceGeneratedCommandsFeaturesNVX, + p_limits: *mut DeviceGeneratedCommandsLimitsNVX, ) -> c_void { (self.get_physical_device_generated_commands_properties_nvx)( physical_device, @@ -17887,14 +17950,14 @@ pub mod extensions { pub struct ExtAcquireXlibDisplayFn { acquire_xlib_display_ext: extern "system" fn( physical_device: PhysicalDevice, - dpy: *const Display, + dpy: *mut Display, display: DisplayKHR, ) -> Result, get_rand_r_output_display_ext: extern "system" fn( physical_device: PhysicalDevice, - dpy: *const Display, + dpy: *mut Display, rr_output: RROutput, - p_display: *const DisplayKHR, + p_display: *mut DisplayKHR, ) -> Result, } unsafe impl Send for ExtAcquireXlibDisplayFn {} @@ -17942,7 +18005,7 @@ pub mod extensions { pub unsafe fn acquire_xlib_display_ext( &self, physical_device: PhysicalDevice, - dpy: *const Display, + dpy: *mut Display, display: DisplayKHR, ) -> Result { (self.acquire_xlib_display_ext)(physical_device, dpy, display) @@ -17950,9 +18013,9 @@ pub mod extensions { pub unsafe fn get_rand_r_output_display_ext( &self, physical_device: PhysicalDevice, - dpy: *const Display, + dpy: *mut Display, rr_output: RROutput, - p_display: *const DisplayKHR, + p_display: *mut DisplayKHR, ) -> Result { (self.get_rand_r_output_display_ext)(physical_device, dpy, rr_output, p_display) } @@ -17962,7 +18025,7 @@ pub mod extensions { extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_capabilities: *const SurfaceCapabilities2EXT, + p_surface_capabilities: *mut SurfaceCapabilities2EXT, ) -> Result, } unsafe impl Send for ExtDisplaySurfaceCounterFn {} @@ -18002,7 +18065,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_capabilities: *const SurfaceCapabilities2EXT, + p_surface_capabilities: *mut SurfaceCapabilities2EXT, ) -> Result { (self.get_physical_device_surface_capabilities2_ext)( physical_device, @@ -18027,7 +18090,7 @@ pub mod extensions { device: Device, p_device_event_info: *const DeviceEventInfoEXT, p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, + p_fence: *mut Fence, ) -> Result, register_display_event_ext: extern "system" fn( @@ -18035,13 +18098,13 @@ pub mod extensions { display: DisplayKHR, p_display_event_info: *const DisplayEventInfoEXT, p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, + p_fence: *mut Fence, ) -> Result, get_swapchain_counter_ext: extern "system" fn( device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, - p_counter_value: *const uint64_t, + p_counter_value: *mut uint64_t, ) -> Result, } unsafe impl Send for ExtDisplayControlFn {} @@ -18119,7 +18182,7 @@ pub mod extensions { device: Device, p_device_event_info: *const DeviceEventInfoEXT, p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, + p_fence: *mut Fence, ) -> Result { (self.register_device_event_ext)(device, p_device_event_info, p_allocator, p_fence) } @@ -18129,7 +18192,7 @@ pub mod extensions { display: DisplayKHR, p_display_event_info: *const DisplayEventInfoEXT, p_allocator: *const AllocationCallbacks, - p_fence: *const Fence, + p_fence: *mut Fence, ) -> Result { (self.register_display_event_ext)( device, @@ -18144,7 +18207,7 @@ pub mod extensions { device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, - p_counter_value: *const uint64_t, + p_counter_value: *mut uint64_t, ) -> Result { (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value) } @@ -18170,14 +18233,14 @@ pub mod extensions { extern "system" fn( device: Device, swapchain: SwapchainKHR, - p_display_timing_properties: *const RefreshCycleDurationGOOGLE, + p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, ) -> Result, get_past_presentation_timing_google: extern "system" fn( device: Device, swapchain: SwapchainKHR, - p_presentation_timing_count: *const uint32_t, - p_presentation_timings: *const PastPresentationTimingGOOGLE, + p_presentation_timing_count: *mut uint32_t, + p_presentation_timings: *mut PastPresentationTimingGOOGLE, ) -> Result, } unsafe impl Send for GoogleDisplayTimingFn {} @@ -18226,7 +18289,7 @@ pub mod extensions { &self, device: Device, swapchain: SwapchainKHR, - p_display_timing_properties: *const RefreshCycleDurationGOOGLE, + p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, ) -> Result { (self.get_refresh_cycle_duration_google)(device, swapchain, p_display_timing_properties) } @@ -18234,8 +18297,8 @@ pub mod extensions { &self, device: Device, swapchain: SwapchainKHR, - p_presentation_timing_count: *const uint32_t, - p_presentation_timings: *const PastPresentationTimingGOOGLE, + p_presentation_timing_count: *mut uint32_t, + p_presentation_timings: *mut PastPresentationTimingGOOGLE, ) -> Result { (self.get_past_presentation_timing_google)( device, @@ -18889,7 +18952,7 @@ pub mod extensions { } } } - pub struct KhrExternalFenceWin32Fn { import_fence_win32_handle_khr : extern "system" fn ( device : Device , p_import_fence_win32_handle_info : *const ImportFenceWin32HandleInfoKHR , ) -> Result , get_fence_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const FenceGetWin32HandleInfoKHR , p_handle : *const HANDLE , ) -> Result , } + pub struct KhrExternalFenceWin32Fn { import_fence_win32_handle_khr : extern "system" fn ( device : Device , p_import_fence_win32_handle_info : *const ImportFenceWin32HandleInfoKHR , ) -> Result , get_fence_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const FenceGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } unsafe impl Send for KhrExternalFenceWin32Fn {} unsafe impl Sync for KhrExternalFenceWin32Fn {} impl ::std::clone::Clone for KhrExternalFenceWin32Fn { @@ -18943,7 +19006,7 @@ pub mod extensions { &self, device: Device, p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, - p_handle: *const HANDLE, + p_handle: *mut HANDLE, ) -> Result { (self.get_fence_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) } @@ -18967,7 +19030,7 @@ pub mod extensions { get_fence_fd_khr: extern "system" fn( device: Device, p_get_fd_info: *const FenceGetFdInfoKHR, - p_fd: *const c_int, + p_fd: *mut c_int, ) -> Result, } unsafe impl Send for KhrExternalFenceFdFn {} @@ -19023,7 +19086,7 @@ pub mod extensions { &self, device: Device, p_get_fd_info: *const FenceGetFdInfoKHR, - p_fd: *const c_int, + p_fd: *mut c_int, ) -> Result { (self.get_fence_fd_khr)(device, p_get_fd_info, p_fd) } @@ -19107,14 +19170,14 @@ pub mod extensions { extern "system" fn( physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_capabilities: *const SurfaceCapabilities2KHR, + p_surface_capabilities: *mut SurfaceCapabilities2KHR, ) -> Result, get_physical_device_surface_formats2_khr: extern "system" fn( physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_format_count: *const uint32_t, - p_surface_formats: *const SurfaceFormat2KHR, + p_surface_format_count: *mut uint32_t, + p_surface_formats: *mut SurfaceFormat2KHR, ) -> Result, } unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} @@ -19165,7 +19228,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_capabilities: *const SurfaceCapabilities2KHR, + p_surface_capabilities: *mut SurfaceCapabilities2KHR, ) -> Result { (self.get_physical_device_surface_capabilities2_khr)( physical_device, @@ -19177,8 +19240,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_format_count: *const uint32_t, - p_surface_formats: *const SurfaceFormat2KHR, + p_surface_format_count: *mut uint32_t, + p_surface_formats: *mut SurfaceFormat2KHR, ) -> Result { (self.get_physical_device_surface_formats2_khr)( physical_device, @@ -19226,27 +19289,27 @@ pub mod extensions { get_physical_device_display_properties2_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayProperties2KHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayProperties2KHR, ) -> Result, get_physical_device_display_plane_properties2_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPlaneProperties2KHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPlaneProperties2KHR, ) -> Result, get_display_mode_properties2_khr: extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *const uint32_t, - p_properties: *const DisplayModeProperties2KHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayModeProperties2KHR, ) -> Result, get_display_plane_capabilities2_khr: extern "system" fn( physical_device: PhysicalDevice, p_display_plane_info: *const DisplayPlaneInfo2KHR, - p_capabilities: *const DisplayPlaneCapabilities2KHR, + p_capabilities: *mut DisplayPlaneCapabilities2KHR, ) -> Result, } unsafe impl Send for KhrGetDisplayProperties2Fn {} @@ -19316,8 +19379,8 @@ pub mod extensions { pub unsafe fn get_physical_device_display_properties2_khr( &self, physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayProperties2KHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayProperties2KHR, ) -> Result { (self.get_physical_device_display_properties2_khr)( physical_device, @@ -19328,8 +19391,8 @@ pub mod extensions { pub unsafe fn get_physical_device_display_plane_properties2_khr( &self, physical_device: PhysicalDevice, - p_property_count: *const uint32_t, - p_properties: *const DisplayPlaneProperties2KHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPlaneProperties2KHR, ) -> Result { (self.get_physical_device_display_plane_properties2_khr)( physical_device, @@ -19341,8 +19404,8 @@ pub mod extensions { &self, physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *const uint32_t, - p_properties: *const DisplayModeProperties2KHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayModeProperties2KHR, ) -> Result { (self.get_display_mode_properties2_khr)( physical_device, @@ -19355,7 +19418,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, p_display_plane_info: *const DisplayPlaneInfo2KHR, - p_capabilities: *const DisplayPlaneCapabilities2KHR, + p_capabilities: *mut DisplayPlaneCapabilities2KHR, ) -> Result { (self.get_display_plane_capabilities2_khr)( physical_device, @@ -19389,7 +19452,7 @@ pub mod extensions { instance: Instance, p_create_info: *const IOSSurfaceCreateInfoMVK, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, } unsafe impl Send for MvkIosSurfaceFn {} @@ -19429,7 +19492,7 @@ pub mod extensions { instance: Instance, p_create_info: *const IOSSurfaceCreateInfoMVK, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_ios_surface_mvk)(instance, p_create_info, p_allocator, p_surface) } @@ -19444,7 +19507,7 @@ pub mod extensions { instance: Instance, p_create_info: *const MacOSSurfaceCreateInfoMVK, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result, } unsafe impl Send for MvkMacosSurfaceFn {} @@ -19484,7 +19547,7 @@ pub mod extensions { instance: Instance, p_create_info: *const MacOSSurfaceCreateInfoMVK, p_allocator: *const AllocationCallbacks, - p_surface: *const SurfaceKHR, + p_surface: *mut SurfaceKHR, ) -> Result { (self.create_mac_os_surface_mvk)(instance, p_create_info, p_allocator, p_surface) } @@ -19614,7 +19677,7 @@ pub mod extensions { instance: Instance, p_create_info: *const DebugUtilsMessengerCreateInfoEXT, p_allocator: *const AllocationCallbacks, - p_messenger: *const DebugUtilsMessengerEXT, + p_messenger: *mut DebugUtilsMessengerEXT, ) -> Result, destroy_debug_utils_messenger_ext: extern "system" fn( @@ -19818,7 +19881,7 @@ pub mod extensions { instance: Instance, p_create_info: *const DebugUtilsMessengerCreateInfoEXT, p_allocator: *const AllocationCallbacks, - p_messenger: *const DebugUtilsMessengerEXT, + p_messenger: *mut DebugUtilsMessengerEXT, ) -> Result { (self.create_debug_utils_messenger_ext)( instance, @@ -19879,7 +19942,7 @@ pub mod extensions { extern "system" fn( device: Device, buffer: *const AHardwareBuffer, - p_properties: *const AndroidHardwareBufferPropertiesANDROID, + p_properties: *mut AndroidHardwareBufferPropertiesANDROID, ) -> Result, get_memory_android_hardware_buffer_android: extern "system" fn( @@ -19936,7 +19999,7 @@ pub mod extensions { &self, device: Device, buffer: *const AHardwareBuffer, - p_properties: *const AndroidHardwareBufferPropertiesANDROID, + p_properties: *mut AndroidHardwareBufferPropertiesANDROID, ) -> Result { (self.get_android_hardware_buffer_properties_android)(device, buffer, p_properties) } @@ -20288,7 +20351,7 @@ pub mod extensions { extern "system" fn( physical_device: PhysicalDevice, samples: SampleCountFlags, - p_multisample_properties: *const MultisamplePropertiesEXT, + p_multisample_properties: *mut MultisamplePropertiesEXT, ) -> c_void, } unsafe impl Send for ExtSampleLocationsFn {} @@ -20345,7 +20408,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, samples: SampleCountFlags, - p_multisample_properties: *const MultisamplePropertiesEXT, + p_multisample_properties: *mut MultisamplePropertiesEXT, ) -> c_void { (self.get_physical_device_multisample_properties_ext)( physical_device, @@ -20938,7 +21001,7 @@ pub mod extensions { device: Device, p_create_info: *const ValidationCacheCreateInfoEXT, p_allocator: *const AllocationCallbacks, - p_validation_cache: *const ValidationCacheEXT, + p_validation_cache: *mut ValidationCacheEXT, ) -> Result, destroy_validation_cache_ext: extern "system" fn( device: Device, @@ -20954,8 +21017,8 @@ pub mod extensions { get_validation_cache_data_ext: extern "system" fn( device: Device, validation_cache: ValidationCacheEXT, - p_data_size: *const size_t, - p_data: *const c_void, + p_data_size: *mut size_t, + p_data: *mut c_void, ) -> Result, } unsafe impl Send for ExtValidationCacheFn {} @@ -21025,7 +21088,7 @@ pub mod extensions { device: Device, p_create_info: *const ValidationCacheCreateInfoEXT, p_allocator: *const AllocationCallbacks, - p_validation_cache: *const ValidationCacheEXT, + p_validation_cache: *mut ValidationCacheEXT, ) -> Result { (self.create_validation_cache_ext)( device, @@ -21055,8 +21118,8 @@ pub mod extensions { &self, device: Device, validation_cache: ValidationCacheEXT, - p_data_size: *const size_t, - p_data: *const c_void, + p_data_size: *mut size_t, + p_data: *mut c_void, ) -> Result { (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) } @@ -21573,7 +21636,7 @@ pub mod extensions { } } } - pub struct ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , p_host_pointer : *const c_void , p_memory_host_pointer_properties : *const MemoryHostPointerPropertiesEXT , ) -> Result , } + pub struct ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , p_host_pointer : *const c_void , p_memory_host_pointer_properties : *mut MemoryHostPointerPropertiesEXT , ) -> Result , } unsafe impl Send for ExtExternalMemoryHostFn {} unsafe impl Sync for ExtExternalMemoryHostFn {} impl ::std::clone::Clone for ExtExternalMemoryHostFn { @@ -21611,7 +21674,7 @@ pub mod extensions { device: Device, handle_type: ExternalMemoryHandleTypeFlags, p_host_pointer: *const c_void, - p_memory_host_pointer_properties: *const MemoryHostPointerPropertiesEXT, + p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, ) -> Result { (self.get_memory_host_pointer_properties_ext)( device, diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 0662ba6..923209c 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -556,14 +556,26 @@ pub trait FieldExt { } pub trait ToTokens { - fn to_tokens(&self) -> Tokens; + fn to_tokens(&self, is_const: bool) -> Tokens; } impl ToTokens for vkxml::ReferenceType { - fn to_tokens(&self) -> Tokens { + fn to_tokens(&self, is_const: bool) -> Tokens { let ptr_name = match self { - vkxml::ReferenceType::Pointer => "*const", + vkxml::ReferenceType::Pointer => { + if is_const { + "*const" + } else { + "*mut" + } + } vkxml::ReferenceType::PointerToPointer => "*mut *mut", - vkxml::ReferenceType::PointerToConstPointer => "*const *const", + vkxml::ReferenceType::PointerToConstPointer => { + if is_const { + "*const *const" + } else { + "*mut *const" + } + } }; let ident = Term::intern(ptr_name); quote!{ @@ -591,7 +603,7 @@ fn name_to_tokens(type_name: &str) -> Ident { } fn to_type_tokens(type_name: &str, reference: Option<&vkxml::ReferenceType>) -> Tokens { let new_name = name_to_tokens(type_name); - let ptr_name = reference.map(|r| r.to_tokens()).unwrap_or(quote!{}); + let ptr_name = reference.map(|r| r.to_tokens(false)).unwrap_or(quote!{}); quote!{#ptr_name #new_name} } @@ -609,11 +621,12 @@ impl FieldExt for vkxml::Field { } fn type_tokens(&self) -> Tokens { + println!("{:#?}", self); let ty = name_to_tokens(&self.basetype); let pointer = self .reference .as_ref() - .map(|r| r.to_tokens()) + .map(|r| r.to_tokens(self.is_const)) .unwrap_or(quote!{}); let pointer_ty = quote!{ #pointer #ty From 1b5f2b105cd11dbb261685c9f8cfab192f65068e Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 14:31:52 +0200 Subject: [PATCH 046/122] Ignore #75 and #84 since it's cosmetic only --- examples/src/bin/texture.rs | 10 +++++----- examples/src/bin/triangle.rs | 2 +- examples/src/lib.rs | 18 +++++++++--------- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index 765c3cb..315d6cc 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -66,7 +66,7 @@ fn main() { }; let dependency = vk::SubpassDependency { dependency_flags: Default::default(), - src_subpass: vk::SUBPASS_EXTERNAL, + src_subpass: vk::VK_SUBPASS_EXTERNAL, dst_subpass: Default::default(), src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_access_mask: Default::default(), @@ -401,8 +401,8 @@ fn main() { dst_access_mask: vk::AccessFlags::TRANSFER_WRITE, old_layout: vk::ImageLayout::UNDEFINED, new_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, - src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, image: texture_image, subresource_range: vk::ImageSubresourceRange { aspect_mask: vk::ImageAspectFlags::COLOR, @@ -455,8 +455,8 @@ fn main() { dst_access_mask: vk::AccessFlags::SHADER_READ, old_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, new_layout: vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL, - src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, image: texture_image, subresource_range: vk::ImageSubresourceRange { aspect_mask: vk::ImageAspectFlags::COLOR, diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index 9192e6b..2329ba9 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -57,7 +57,7 @@ fn main() { }; let dependency = vk::SubpassDependency { dependency_flags: Default::default(), - src_subpass: vk::SUBPASS_EXTERNAL, + src_subpass: vk::VK_SUBPASS_EXTERNAL, dst_subpass: Default::default(), src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_access_mask: Default::default(), diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 81750a0..0fae665 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -303,8 +303,8 @@ impl ExampleBase { let debug_info = vk::DebugReportCallbackCreateInfoEXT { s_type: vk::StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, p_next: ptr::null(), - flags: vk::DebugReportFlagsEXT::ERROR | vk::DebugReportFlagsEXT::WARNING - | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING, + flags: vk::DebugReportFlagsEXT::ERROR_EXT | vk::DebugReportFlagsEXT::WARNING_EXT + | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING_EXT, pfn_callback: vulkan_debug_callback, p_user_data: ptr::null_mut(), }; @@ -408,9 +408,9 @@ impl ExampleBase { }; let pre_transform = if surface_capabilities .supported_transforms - .subset(vk::SurfaceTransformFlagsKHR::IDENTITY) + .subset(vk::SurfaceTransformFlagsKHR::IDENTITY_KHR) { - vk::SurfaceTransformFlagsKHR::IDENTITY + vk::SurfaceTransformFlagsKHR::IDENTITY_KHR } else { surface_capabilities.current_transform }; @@ -420,8 +420,8 @@ impl ExampleBase { let present_mode = present_modes .iter() .cloned() - .find(|&mode| mode == vk::PresentModeKHR::MAILBOX) - .unwrap_or(vk::PresentModeKHR::FIFO); + .find(|&mode| mode == vk::PresentModeKHR::MAILBOX_KHR) + .unwrap_or(vk::PresentModeKHR::FIFO_KHR); let swapchain_loader = Swapchain::new(&instance, &device).expect("Unable to load swapchain"); let swapchain_create_info = vk::SwapchainCreateInfoKHR { @@ -436,7 +436,7 @@ impl ExampleBase { image_usage: vk::ImageUsageFlags::COLOR_ATTACHMENT, image_sharing_mode: vk::SharingMode::EXCLUSIVE, pre_transform: pre_transform, - composite_alpha: vk::CompositeAlphaFlagsKHR::OPAQUE, + composite_alpha: vk::CompositeAlphaFlagsKHR::OPAQUE_KHR, present_mode: present_mode, clipped: 1, old_swapchain: vk::SwapchainKHR::null(), @@ -556,8 +556,8 @@ impl ExampleBase { | vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE, old_layout: vk::ImageLayout::UNDEFINED, new_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, image: depth_image, subresource_range: vk::ImageSubresourceRange { aspect_mask: vk::ImageAspectFlags::DEPTH, From c4566b6ca9aaa435c73aed27372a6e93d56ce858 Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 14:38:11 +0200 Subject: [PATCH 047/122] Conditionally use `XlibSurface` and `Win32Surface` --- examples/src/lib.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 0fae665..0626631 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -10,7 +10,11 @@ use ash::Entry; use ash::Instance; use ash::Device; pub use ash::version::{DeviceV1_0, EntryV1_0, InstanceV1_0, V1_0}; -use ash::extensions::{DebugReport, Surface, Swapchain, Win32Surface, XlibSurface}; +use ash::extensions::{DebugReport, Surface, Swapchain}; +#[cfg(windows)] +use ash::extensions::Win32Surface; +#[cfg(not(windows))] +use ash::extensions::XlibSurface; use std::cell::RefCell; use std::ptr; use std::ffi::{CStr, CString}; From c0d29d49404346e9e2352096406c10c24368ccaf Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 14:51:37 +0200 Subject: [PATCH 048/122] Fix windows structure type --- examples/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 0626631..5cc309a 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -126,7 +126,7 @@ unsafe fn create_surface( let hwnd = window.get_hwnd() as HWND; let hinstance = GetWindow(hwnd, 0) as *const vk::c_void; let win32_create_info = vk::Win32SurfaceCreateInfoKHR { - s_type: vk::StructureType::Win32SurfaceCreateInfoKhr, + s_type: vk::StructureType::WIN32_SURFACE_CREATE_INFO_KHR, p_next: ptr::null(), flags: Default::default(), hinstance: hinstance, From 77cfbf2367eb335717e286981d92db0ff85e656e Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 14:51:45 +0200 Subject: [PATCH 049/122] Apply rustfmt to examples --- examples/src/bin/texture.rs | 291 +++++++++++++++++++---------------- examples/src/bin/triangle.rs | 111 ++++++------- examples/src/lib.rs | 49 +++--- 3 files changed, 243 insertions(+), 208 deletions(-) diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index 315d6cc..aeb29e4 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -3,17 +3,19 @@ extern crate ash; extern crate examples; extern crate image; -use ash::vk; -use std::default::Default; -use std::ptr; -use std::ffi::CString; -use std::mem; -use std::path::Path; -use std::fs::File; -use std::io::Read; +use std::{ + default::Default, + ffi::CString, + fs::File, + io::Read, + mem::{self, align_of}, + path::Path, + ptr, +}; + +use ash::{util::*, vk}; + use examples::*; -use ash::util::*; -use std::mem::align_of; #[derive(Clone, Debug, Copy)] struct Vertex { @@ -97,10 +99,12 @@ fn main() { dependency_count: 1, p_dependencies: &dependency, }; - let renderpass = base.device + let renderpass = base + .device .create_render_pass(&renderpass_create_info, None) .unwrap(); - let framebuffers: Vec = base.present_image_views + let framebuffers: Vec = base + .present_image_views .iter() .map(|&present_image_view| { let framebuffer_attachments = [present_image_view, base.depth_image_view]; @@ -145,10 +149,12 @@ fn main() { allocation_size: index_buffer_memory_req.size, memory_type_index: index_buffer_memory_index, }; - let index_buffer_memory = base.device + let index_buffer_memory = base + .device .allocate_memory(&index_allocate_info, None) .unwrap(); - let index_ptr: *mut vk::c_void = base.device + let index_ptr: *mut vk::c_void = base + .device .map_memory( index_buffer_memory, 0, @@ -195,10 +201,12 @@ fn main() { queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; - let vertex_input_buffer = base.device + let vertex_input_buffer = base + .device .create_buffer(&vertex_input_buffer_info, None) .unwrap(); - let vertex_input_buffer_memory_req = base.device + let vertex_input_buffer_memory_req = base + .device .get_buffer_memory_requirements(vertex_input_buffer); let vertex_input_buffer_memory_index = find_memorytype_index( @@ -213,10 +221,12 @@ fn main() { allocation_size: vertex_input_buffer_memory_req.size, memory_type_index: vertex_input_buffer_memory_index, }; - let vertex_input_buffer_memory = base.device + let vertex_input_buffer_memory = base + .device .allocate_memory(&vertex_buffer_allocate_info, None) .unwrap(); - let vert_ptr = base.device + let vert_ptr = base + .device .map_memory( vertex_input_buffer_memory, 0, @@ -251,10 +261,12 @@ fn main() { queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; - let uniform_color_buffer = base.device + let uniform_color_buffer = base + .device .create_buffer(&uniform_color_buffer_info, None) .unwrap(); - let uniform_color_buffer_memory_req = base.device + let uniform_color_buffer_memory_req = base + .device .get_buffer_memory_requirements(uniform_color_buffer); let uniform_color_buffer_memory_index = find_memorytype_index( @@ -269,10 +281,12 @@ fn main() { allocation_size: uniform_color_buffer_memory_req.size, memory_type_index: uniform_color_buffer_memory_index, }; - let uniform_color_buffer_memory = base.device + let uniform_color_buffer_memory = base + .device .allocate_memory(&uniform_color_buffer_allocate_info, None) .unwrap(); - let uniform_ptr = base.device + let uniform_ptr = base + .device .map_memory( uniform_color_buffer_memory, 0, @@ -319,10 +333,12 @@ fn main() { allocation_size: image_buffer_memory_req.size, memory_type_index: image_buffer_memory_index, }; - let image_buffer_memory = base.device + let image_buffer_memory = base + .device .allocate_memory(&image_buffer_allocate_info, None) .unwrap(); - let image_ptr = base.device + let image_ptr = base + .device .map_memory( image_buffer_memory, 0, @@ -362,7 +378,8 @@ fn main() { p_queue_family_indices: ptr::null(), initial_layout: vk::ImageLayout::UNDEFINED, }; - let texture_image = base.device + let texture_image = base + .device .create_image(&texture_create_info, None) .unwrap(); let texture_memory_req = base.device.get_image_memory_requirements(texture_image); @@ -379,7 +396,8 @@ fn main() { allocation_size: texture_memory_req.size, memory_type_index: texture_memory_index, }; - let texture_memory = base.device + let texture_memory = base + .device .allocate_memory(&texture_allocate_info, None) .unwrap(); base.device @@ -421,26 +439,24 @@ fn main() { &[], &[texture_barrier], ); - let buffer_copy_regions = [ - vk::BufferImageCopy { - image_subresource: vk::ImageSubresourceLayers { - aspect_mask: vk::ImageAspectFlags::COLOR, - mip_level: 0, - base_array_layer: 0, - layer_count: 1, - }, - image_extent: vk::Extent3D { - width: image_dimensions.0, - height: image_dimensions.1, - depth: 1, - }, - buffer_offset: 0, - // FIX ME - buffer_image_height: 0, - buffer_row_length: 0, - image_offset: vk::Offset3D { x: 0, y: 0, z: 0 }, + let buffer_copy_regions = [vk::BufferImageCopy { + image_subresource: vk::ImageSubresourceLayers { + aspect_mask: vk::ImageAspectFlags::COLOR, + mip_level: 0, + base_array_layer: 0, + layer_count: 1, }, - ]; + image_extent: vk::Extent3D { + width: image_dimensions.0, + height: image_dimensions.1, + depth: 1, + }, + buffer_offset: 0, + // FIX ME + buffer_image_height: 0, + buffer_row_length: 0, + image_offset: vk::Offset3D { x: 0, y: 0, z: 0 }, + }]; device.cmd_copy_buffer_to_image( texture_command_buffer, image_buffer, @@ -522,7 +538,8 @@ fn main() { }, image: texture_image, }; - let tex_image_view = base.device + let tex_image_view = base + .device .create_image_view(&tex_image_view_info, None) .unwrap(); let descriptor_sizes = [ @@ -543,7 +560,8 @@ fn main() { p_pool_sizes: descriptor_sizes.as_ptr(), max_sets: 1, }; - let descriptor_pool = base.device + let descriptor_pool = base + .device .create_descriptor_pool(&descriptor_pool_info, None) .unwrap(); let desc_layout_bindings = [ @@ -570,11 +588,10 @@ fn main() { p_bindings: desc_layout_bindings.as_ptr(), }; - let desc_set_layouts = [ - base.device - .create_descriptor_set_layout(&descriptor_info, None) - .unwrap(), - ]; + let desc_set_layouts = [base + .device + .create_descriptor_set_layout(&descriptor_info, None) + .unwrap()]; let desc_alloc_info = vk::DescriptorSetAllocateInfo { s_type: vk::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, p_next: ptr::null(), @@ -582,7 +599,8 @@ fn main() { descriptor_set_count: desc_set_layouts.len() as u32, p_set_layouts: desc_set_layouts.as_ptr(), }; - let descriptor_sets = base.device + let descriptor_sets = base + .device .allocate_descriptor_sets(&desc_alloc_info) .unwrap(); @@ -650,11 +668,13 @@ fn main() { code_size: frag_bytes.len(), p_code: frag_bytes.as_ptr() as *const u32, }; - let vertex_shader_module = base.device + let vertex_shader_module = base + .device .create_shader_module(&vertex_shader_info, None) .expect("Vertex shader module error"); - let fragment_shader_module = base.device + let fragment_shader_module = base + .device .create_shader_module(&frag_shader_info, None) .expect("Fragment shader module error"); @@ -668,7 +688,8 @@ fn main() { p_push_constant_ranges: ptr::null(), }; - let pipeline_layout = base.device + let pipeline_layout = base + .device .create_pipeline_layout(&layout_create_info, None) .unwrap(); @@ -693,13 +714,11 @@ fn main() { stage: vk::ShaderStageFlags::FRAGMENT, }, ]; - let vertex_input_binding_descriptions = [ - vk::VertexInputBindingDescription { - binding: 0, - stride: mem::size_of::() as u32, - input_rate: vk::VertexInputRate::VERTEX, - }, - ]; + let vertex_input_binding_descriptions = [vk::VertexInputBindingDescription { + binding: 0, + stride: mem::size_of::() as u32, + input_rate: vk::VertexInputRate::VERTEX, + }]; let vertex_input_attribute_descriptions = [ vk::VertexInputAttributeDescription { location: 0, @@ -730,22 +749,18 @@ fn main() { primitive_restart_enable: 0, topology: vk::PrimitiveTopology::TRIANGLE_LIST, }; - let viewports = [ - vk::Viewport { - x: 0.0, - y: 0.0, - width: base.surface_resolution.width as f32, - height: base.surface_resolution.height as f32, - min_depth: 0.0, - max_depth: 1.0, - }, - ]; - let scissors = [ - vk::Rect2D { - offset: vk::Offset2D { x: 0, y: 0 }, - extent: base.surface_resolution.clone(), - }, - ]; + let viewports = [vk::Viewport { + x: 0.0, + y: 0.0, + width: base.surface_resolution.width as f32, + height: base.surface_resolution.height as f32, + min_depth: 0.0, + max_depth: 1.0, + }]; + let scissors = [vk::Rect2D { + offset: vk::Offset2D { x: 0, y: 0 }, + extent: base.surface_resolution.clone(), + }]; let viewport_state_info = vk::PipelineViewportStateCreateInfo { s_type: vk::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, p_next: ptr::null(), @@ -804,18 +819,16 @@ fn main() { max_depth_bounds: 1.0, min_depth_bounds: 0.0, }; - let color_blend_attachment_states = [ - vk::PipelineColorBlendAttachmentState { - blend_enable: 0, - src_color_blend_factor: vk::BlendFactor::SRC_COLOR, - dst_color_blend_factor: vk::BlendFactor::ONE_MINUS_DST_COLOR, - color_blend_op: vk::BlendOp::ADD, - src_alpha_blend_factor: vk::BlendFactor::ZERO, - dst_alpha_blend_factor: vk::BlendFactor::ZERO, - alpha_blend_op: vk::BlendOp::ADD, - color_write_mask: vk::ColorComponentFlags::all(), - }, - ]; + let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState { + blend_enable: 0, + src_color_blend_factor: vk::BlendFactor::SRC_COLOR, + dst_color_blend_factor: vk::BlendFactor::ONE_MINUS_DST_COLOR, + color_blend_op: vk::BlendOp::ADD, + src_alpha_blend_factor: vk::BlendFactor::ZERO, + dst_alpha_blend_factor: vk::BlendFactor::ZERO, + alpha_blend_op: vk::BlendOp::ADD, + color_write_mask: vk::ColorComponentFlags::all(), + }]; let color_blend_state = vk::PipelineColorBlendStateCreateInfo { s_type: vk::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, p_next: ptr::null(), @@ -855,14 +868,16 @@ fn main() { base_pipeline_handle: vk::Pipeline::null(), base_pipeline_index: 0, }; - let graphics_pipelines = base.device + let graphics_pipelines = base + .device .create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_info], None) .unwrap(); let graphic_pipeline = graphics_pipelines[0]; base.render_loop(|| { - let present_index = base.swapchain_loader + let present_index = base + .swapchain_loader .acquire_next_image_khr( base.swapchain, std::u64::MAX, @@ -896,43 +911,59 @@ fn main() { clear_value_count: clear_values.len() as u32, p_clear_values: clear_values.as_ptr(), }; - record_submit_commandbuffer(&base.device, - base.draw_command_buffer, - base.present_queue, - &[vk::PipelineStageFlags::BOTTOM_OF_PIPE], - &[base.present_complete_semaphore], - &[base.rendering_complete_semaphore], - |device, draw_command_buffer| { - device.cmd_begin_render_pass(draw_command_buffer, - &render_pass_begin_info, - vk::SubpassContents::INLINE); - device.cmd_bind_descriptor_sets(draw_command_buffer, - vk::PipelineBindPoint::GRAPHICS, - pipeline_layout, - 0, - &descriptor_sets[..], - &[]); - device.cmd_bind_pipeline(draw_command_buffer, - vk::PipelineBindPoint::GRAPHICS, - graphic_pipeline); - device.cmd_set_viewport(draw_command_buffer, 0, &viewports); - device.cmd_set_scissor(draw_command_buffer, 0, &scissors); - device - .cmd_bind_vertex_buffers(draw_command_buffer, 0, &[vertex_input_buffer], &[0]); - device.cmd_bind_index_buffer(draw_command_buffer, - index_buffer, - 0, - vk::IndexType::UINT32); - device.cmd_draw_indexed(draw_command_buffer, - index_buffer_data.len() as u32, - 1, - 0, - 0, - 1); - // Or draw without the index buffer - // device.cmd_draw(draw_command_buffer, 3, 1, 0, 0); - device.cmd_end_render_pass(draw_command_buffer); - }); + record_submit_commandbuffer( + &base.device, + base.draw_command_buffer, + base.present_queue, + &[vk::PipelineStageFlags::BOTTOM_OF_PIPE], + &[base.present_complete_semaphore], + &[base.rendering_complete_semaphore], + |device, draw_command_buffer| { + device.cmd_begin_render_pass( + draw_command_buffer, + &render_pass_begin_info, + vk::SubpassContents::INLINE, + ); + device.cmd_bind_descriptor_sets( + draw_command_buffer, + vk::PipelineBindPoint::GRAPHICS, + pipeline_layout, + 0, + &descriptor_sets[..], + &[], + ); + device.cmd_bind_pipeline( + draw_command_buffer, + vk::PipelineBindPoint::GRAPHICS, + graphic_pipeline, + ); + device.cmd_set_viewport(draw_command_buffer, 0, &viewports); + device.cmd_set_scissor(draw_command_buffer, 0, &scissors); + device.cmd_bind_vertex_buffers( + draw_command_buffer, + 0, + &[vertex_input_buffer], + &[0], + ); + device.cmd_bind_index_buffer( + draw_command_buffer, + index_buffer, + 0, + vk::IndexType::UINT32, + ); + device.cmd_draw_indexed( + draw_command_buffer, + index_buffer_data.len() as u32, + 1, + 0, + 0, + 1, + ); + // Or draw without the index buffer + // device.cmd_draw(draw_command_buffer, 3, 1, 0, 0); + device.cmd_end_render_pass(draw_command_buffer); + }, + ); //let mut present_info_err = mem::uninitialized(); let present_info = vk::PresentInfoKHR { s_type: vk::StructureType::PRESENT_INFO_KHR, diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index 2329ba9..d84d142 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -2,17 +2,17 @@ extern crate ash; #[macro_use] extern crate examples; +use ash::util::*; use ash::vk; +use examples::*; use std::default::Default; -use std::ptr; use std::ffi::CString; -use std::mem; -use std::path::Path; use std::fs::File; use std::io::Read; -use examples::*; -use ash::util::*; +use std::mem; use std::mem::align_of; +use std::path::Path; +use std::ptr; #[derive(Clone, Debug, Copy)] struct Vertex { @@ -88,10 +88,12 @@ fn main() { dependency_count: 1, p_dependencies: &dependency, }; - let renderpass = base.device + let renderpass = base + .device .create_render_pass(&renderpass_create_info, None) .unwrap(); - let framebuffers: Vec = base.present_image_views + let framebuffers: Vec = base + .present_image_views .iter() .map(|&present_image_view| { let framebuffer_attachments = [present_image_view, base.depth_image_view]; @@ -136,10 +138,12 @@ fn main() { allocation_size: index_buffer_memory_req.size, memory_type_index: index_buffer_memory_index, }; - let index_buffer_memory = base.device + let index_buffer_memory = base + .device .allocate_memory(&index_allocate_info, None) .unwrap(); - let index_ptr = base.device + let index_ptr = base + .device .map_memory( index_buffer_memory, 0, @@ -168,10 +172,12 @@ fn main() { queue_family_index_count: 0, p_queue_family_indices: ptr::null(), }; - let vertex_input_buffer = base.device + let vertex_input_buffer = base + .device .create_buffer(&vertex_input_buffer_info, None) .unwrap(); - let vertex_input_buffer_memory_req = base.device + let vertex_input_buffer_memory_req = base + .device .get_buffer_memory_requirements(vertex_input_buffer); let vertex_input_buffer_memory_index = find_memorytype_index( @@ -186,7 +192,8 @@ fn main() { allocation_size: vertex_input_buffer_memory_req.size, memory_type_index: vertex_input_buffer_memory_index, }; - let vertex_input_buffer_memory = base.device + let vertex_input_buffer_memory = base + .device .allocate_memory(&vertex_buffer_allocate_info, None) .unwrap(); let vertices = [ @@ -203,7 +210,8 @@ fn main() { color: [1.0, 0.0, 0.0, 1.0], }, ]; - let vert_ptr = base.device + let vert_ptr = base + .device .map_memory( vertex_input_buffer_memory, 0, @@ -245,11 +253,13 @@ fn main() { code_size: frag_bytes.len(), p_code: frag_bytes.as_ptr() as *const u32, }; - let vertex_shader_module = base.device + let vertex_shader_module = base + .device .create_shader_module(&vertex_shader_info, None) .expect("Vertex shader module error"); - let fragment_shader_module = base.device + let fragment_shader_module = base + .device .create_shader_module(&frag_shader_info, None) .expect("Fragment shader module error"); @@ -263,7 +273,8 @@ fn main() { p_push_constant_ranges: ptr::null(), }; - let pipeline_layout = base.device + let pipeline_layout = base + .device .create_pipeline_layout(&layout_create_info, None) .unwrap(); @@ -288,13 +299,11 @@ fn main() { stage: vk::ShaderStageFlags::FRAGMENT, }, ]; - let vertex_input_binding_descriptions = [ - vk::VertexInputBindingDescription { - binding: 0, - stride: mem::size_of::() as u32, - input_rate: vk::VertexInputRate::VERTEX, - }, - ]; + let vertex_input_binding_descriptions = [vk::VertexInputBindingDescription { + binding: 0, + stride: mem::size_of::() as u32, + input_rate: vk::VertexInputRate::VERTEX, + }]; let vertex_input_attribute_descriptions = [ vk::VertexInputAttributeDescription { location: 0, @@ -325,22 +334,18 @@ fn main() { primitive_restart_enable: 0, topology: vk::PrimitiveTopology::TRIANGLE_LIST, }; - let viewports = [ - vk::Viewport { - x: 0.0, - y: 0.0, - width: base.surface_resolution.width as f32, - height: base.surface_resolution.height as f32, - min_depth: 0.0, - max_depth: 1.0, - }, - ]; - let scissors = [ - vk::Rect2D { - offset: vk::Offset2D { x: 0, y: 0 }, - extent: base.surface_resolution.clone(), - }, - ]; + let viewports = [vk::Viewport { + x: 0.0, + y: 0.0, + width: base.surface_resolution.width as f32, + height: base.surface_resolution.height as f32, + min_depth: 0.0, + max_depth: 1.0, + }]; + let scissors = [vk::Rect2D { + offset: vk::Offset2D { x: 0, y: 0 }, + extent: base.surface_resolution.clone(), + }]; let viewport_state_info = vk::PipelineViewportStateCreateInfo { s_type: vk::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, p_next: ptr::null(), @@ -399,18 +404,16 @@ fn main() { max_depth_bounds: 1.0, min_depth_bounds: 0.0, }; - let color_blend_attachment_states = [ - vk::PipelineColorBlendAttachmentState { - blend_enable: 0, - src_color_blend_factor: vk::BlendFactor::SRC_COLOR, - dst_color_blend_factor: vk::BlendFactor::ONE_MINUS_DST_COLOR, - color_blend_op: vk::BlendOp::ADD, - src_alpha_blend_factor: vk::BlendFactor::ZERO, - dst_alpha_blend_factor: vk::BlendFactor::ZERO, - alpha_blend_op: vk::BlendOp::ADD, - color_write_mask: vk::ColorComponentFlags::all(), - }, - ]; + let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState { + blend_enable: 0, + src_color_blend_factor: vk::BlendFactor::SRC_COLOR, + dst_color_blend_factor: vk::BlendFactor::ONE_MINUS_DST_COLOR, + color_blend_op: vk::BlendOp::ADD, + src_alpha_blend_factor: vk::BlendFactor::ZERO, + dst_alpha_blend_factor: vk::BlendFactor::ZERO, + alpha_blend_op: vk::BlendOp::ADD, + color_write_mask: vk::ColorComponentFlags::all(), + }]; let color_blend_state = vk::PipelineColorBlendStateCreateInfo { s_type: vk::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, p_next: ptr::null(), @@ -450,14 +453,16 @@ fn main() { base_pipeline_handle: vk::Pipeline::null(), base_pipeline_index: 0, }; - let graphics_pipelines = base.device + let graphics_pipelines = base + .device .create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_info], None) .expect("Unable to create graphics pipeline"); let graphic_pipeline = graphics_pipelines[0]; base.render_loop(|| { - let present_index = base.swapchain_loader + let present_index = base + .swapchain_loader .acquire_next_image_khr( base.swapchain, std::u64::MAX, diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 5cc309a..a7740c8 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -4,34 +4,32 @@ extern crate ash; extern crate winapi; extern crate winit; -use ash::vk; -use std::default::Default; -use ash::Entry; -use ash::Instance; -use ash::Device; -pub use ash::version::{DeviceV1_0, EntryV1_0, InstanceV1_0, V1_0}; -use ash::extensions::{DebugReport, Surface, Swapchain}; #[cfg(windows)] use ash::extensions::Win32Surface; #[cfg(not(windows))] use ash::extensions::XlibSurface; +use ash::extensions::{DebugReport, Surface, Swapchain}; +pub use ash::version::{DeviceV1_0, EntryV1_0, InstanceV1_0, V1_0}; +use ash::vk; +use ash::Device; +use ash::Entry; +use ash::Instance; use std::cell::RefCell; -use std::ptr; +use std::default::Default; use std::ffi::{CStr, CString}; use std::ops::Drop; +use std::ptr; // Simple offset_of macro akin to C++ offsetof #[macro_export] -macro_rules! offset_of{ - ($base: path, $field: ident) => { - { - #[allow(unused_unsafe)] - unsafe{ - let b: $base = mem::uninitialized(); - (&b.$field as *const _ as isize) - (&b as *const _ as isize) - } +macro_rules! offset_of { + ($base:path, $field:ident) => {{ + #[allow(unused_unsafe)] + unsafe { + let b: $base = mem::uninitialized(); + (&b.$field as *const _ as isize) - (&b as *const _ as isize) } - } + }}; } pub fn record_submit_commandbuffer( @@ -307,7 +305,8 @@ impl ExampleBase { let debug_info = vk::DebugReportCallbackCreateInfoEXT { s_type: vk::StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, p_next: ptr::null(), - flags: vk::DebugReportFlagsEXT::ERROR_EXT | vk::DebugReportFlagsEXT::WARNING_EXT + flags: vk::DebugReportFlagsEXT::ERROR_EXT + | vk::DebugReportFlagsEXT::WARNING_EXT | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING_EXT, pfn_callback: vulkan_debug_callback, p_user_data: ptr::null_mut(), @@ -331,13 +330,13 @@ impl ExampleBase { .iter() .enumerate() .filter_map(|(index, ref info)| { - let supports_graphic_and_surface = info.queue_flags - .subset(vk::QueueFlags::GRAPHICS) - && surface_loader.get_physical_device_surface_support_khr( - *pdevice, - index as u32, - surface, - ); + let supports_graphic_and_surface = + info.queue_flags.subset(vk::QueueFlags::GRAPHICS) + && surface_loader.get_physical_device_surface_support_khr( + *pdevice, + index as u32, + surface, + ); match supports_graphic_and_surface { true => Some((*pdevice, index)), _ => None, From ec41984cb5fac729137d281a3a5290babdddcc09 Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 14:59:21 +0200 Subject: [PATCH 050/122] Fix formatting in textures.rs --- examples/src/bin/texture.rs | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index aeb29e4..9a5d117 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -3,15 +3,13 @@ extern crate ash; extern crate examples; extern crate image; -use std::{ - default::Default, - ffi::CString, - fs::File, - io::Read, - mem::{self, align_of}, - path::Path, - ptr, -}; +use std::default::Default; +use std::ffi::CString; +use std::fs::File; +use std::io::Read; +use std::mem::{self, align_of}; +use std::path::Path; +use std::ptr; use ash::{util::*, vk}; From d9aa575318f7bde07d3650c638af2dda7638cf62 Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 31 Jul 2018 15:00:28 +0200 Subject: [PATCH 051/122] Fix formatting in textures.rs --- examples/src/bin/texture.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index 9a5d117..bce408c 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -11,7 +11,8 @@ use std::mem::{self, align_of}; use std::path::Path; use std::ptr; -use ash::{util::*, vk}; +use ash::util::*; +use ash::vk; use examples::*; From 666e5628ac9cf37084d0a5f9bc5eb5dd6c41c72c Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 1 Aug 2018 08:51:50 +0200 Subject: [PATCH 052/122] Remove vendor ext from vendor constant variants --- ash/src/vk.rs | 290 +++++++++++++++++++++---------------------- examples/src/lib.rs | 16 +-- generator/src/lib.rs | 15 ++- 3 files changed, 163 insertions(+), 158 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index b1fe1ea..1f694e3 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -12529,132 +12529,132 @@ impl ObjectType { #[repr(C)] pub struct PresentModeKHR(pub(crate) i32); impl PresentModeKHR { - pub const IMMEDIATE_KHR: Self = PresentModeKHR(0); - pub const MAILBOX_KHR: Self = PresentModeKHR(1); - pub const FIFO_KHR: Self = PresentModeKHR(2); - pub const FIFO_RELAXED_KHR: Self = PresentModeKHR(3); + pub const IMMEDIATE: Self = PresentModeKHR(0); + pub const MAILBOX: Self = PresentModeKHR(1); + pub const FIFO: Self = PresentModeKHR(2); + pub const FIFO_RELAXED: Self = PresentModeKHR(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ColorSpaceKHR(pub(crate) i32); impl ColorSpaceKHR { - pub const SRGB_NONLINEAR_KHR: Self = ColorSpaceKHR(0); + pub const SRGB_NONLINEAR: Self = ColorSpaceKHR(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DebugReportObjectTypeEXT(pub(crate) i32); impl DebugReportObjectTypeEXT { - pub const UNKNOWN_EXT: Self = DebugReportObjectTypeEXT(0); - pub const INSTANCE_EXT: Self = DebugReportObjectTypeEXT(1); - pub const PHYSICAL_DEVICE_EXT: Self = DebugReportObjectTypeEXT(2); - pub const DEVICE_EXT: Self = DebugReportObjectTypeEXT(3); - pub const QUEUE_EXT: Self = DebugReportObjectTypeEXT(4); - pub const SEMAPHORE_EXT: Self = DebugReportObjectTypeEXT(5); - pub const COMMAND_BUFFER_EXT: Self = DebugReportObjectTypeEXT(6); - pub const FENCE_EXT: Self = DebugReportObjectTypeEXT(7); - pub const DEVICE_MEMORY_EXT: Self = DebugReportObjectTypeEXT(8); - pub const BUFFER_EXT: Self = DebugReportObjectTypeEXT(9); - pub const IMAGE_EXT: Self = DebugReportObjectTypeEXT(10); - pub const EVENT_EXT: Self = DebugReportObjectTypeEXT(11); - pub const QUERY_POOL_EXT: Self = DebugReportObjectTypeEXT(12); - pub const BUFFER_VIEW_EXT: Self = DebugReportObjectTypeEXT(13); - pub const IMAGE_VIEW_EXT: Self = DebugReportObjectTypeEXT(14); - pub const SHADER_MODULE_EXT: Self = DebugReportObjectTypeEXT(15); - pub const PIPELINE_CACHE_EXT: Self = DebugReportObjectTypeEXT(16); - pub const PIPELINE_LAYOUT_EXT: Self = DebugReportObjectTypeEXT(17); - pub const RENDER_PASS_EXT: Self = DebugReportObjectTypeEXT(18); - pub const PIPELINE_EXT: Self = DebugReportObjectTypeEXT(19); - pub const DESCRIPTOR_SET_LAYOUT_EXT: Self = DebugReportObjectTypeEXT(20); - pub const SAMPLER_EXT: Self = DebugReportObjectTypeEXT(21); - pub const DESCRIPTOR_POOL_EXT: Self = DebugReportObjectTypeEXT(22); - pub const DESCRIPTOR_SET_EXT: Self = DebugReportObjectTypeEXT(23); - pub const FRAMEBUFFER_EXT: Self = DebugReportObjectTypeEXT(24); - pub const COMMAND_POOL_EXT: Self = DebugReportObjectTypeEXT(25); - pub const SURFACE_KHR_EXT: Self = DebugReportObjectTypeEXT(26); - pub const SWAPCHAIN_KHR_EXT: Self = DebugReportObjectTypeEXT(27); - pub const DEBUG_REPORT_CALLBACK_EXT_EXT: Self = DebugReportObjectTypeEXT(28); - pub const DISPLAY_KHR_EXT: Self = DebugReportObjectTypeEXT(29); - pub const DISPLAY_MODE_KHR_EXT: Self = DebugReportObjectTypeEXT(30); - pub const OBJECT_TABLE_NVX_EXT: Self = DebugReportObjectTypeEXT(31); - pub const INDIRECT_COMMANDS_LAYOUT_NVX_EXT: Self = DebugReportObjectTypeEXT(32); - pub const VALIDATION_CACHE_EXT_EXT: Self = DebugReportObjectTypeEXT(33); + pub const UNKNOWN: Self = DebugReportObjectTypeEXT(0); + pub const INSTANCE: Self = DebugReportObjectTypeEXT(1); + pub const PHYSICAL_DEVICE: Self = DebugReportObjectTypeEXT(2); + pub const DEVICE: Self = DebugReportObjectTypeEXT(3); + pub const QUEUE: Self = DebugReportObjectTypeEXT(4); + pub const SEMAPHORE: Self = DebugReportObjectTypeEXT(5); + pub const COMMAND_BUFFER: Self = DebugReportObjectTypeEXT(6); + pub const FENCE: Self = DebugReportObjectTypeEXT(7); + pub const DEVICE_MEMORY: Self = DebugReportObjectTypeEXT(8); + pub const BUFFER: Self = DebugReportObjectTypeEXT(9); + pub const IMAGE: Self = DebugReportObjectTypeEXT(10); + pub const EVENT: Self = DebugReportObjectTypeEXT(11); + pub const QUERY_POOL: Self = DebugReportObjectTypeEXT(12); + pub const BUFFER_VIEW: Self = DebugReportObjectTypeEXT(13); + pub const IMAGE_VIEW: Self = DebugReportObjectTypeEXT(14); + pub const SHADER_MODULE: Self = DebugReportObjectTypeEXT(15); + pub const PIPELINE_CACHE: Self = DebugReportObjectTypeEXT(16); + pub const PIPELINE_LAYOUT: Self = DebugReportObjectTypeEXT(17); + pub const RENDER_PASS: Self = DebugReportObjectTypeEXT(18); + pub const PIPELINE: Self = DebugReportObjectTypeEXT(19); + pub const DESCRIPTOR_SET_LAYOUT: Self = DebugReportObjectTypeEXT(20); + pub const SAMPLER: Self = DebugReportObjectTypeEXT(21); + pub const DESCRIPTOR_POOL: Self = DebugReportObjectTypeEXT(22); + pub const DESCRIPTOR_SET: Self = DebugReportObjectTypeEXT(23); + pub const FRAMEBUFFER: Self = DebugReportObjectTypeEXT(24); + pub const COMMAND_POOL: Self = DebugReportObjectTypeEXT(25); + pub const SURFACE_KHR: Self = DebugReportObjectTypeEXT(26); + pub const SWAPCHAIN_KHR: Self = DebugReportObjectTypeEXT(27); + pub const DEBUG_REPORT_CALLBACK: Self = DebugReportObjectTypeEXT(28); + pub const DISPLAY_KHR: Self = DebugReportObjectTypeEXT(29); + pub const DISPLAY_MODE_KHR: Self = DebugReportObjectTypeEXT(30); + pub const OBJECT_TABLE_NVX: Self = DebugReportObjectTypeEXT(31); + pub const INDIRECT_COMMANDS_LAYOUT_NVX: Self = DebugReportObjectTypeEXT(32); + pub const VALIDATION_CACHE: Self = DebugReportObjectTypeEXT(33); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct RasterizationOrderAMD(pub(crate) i32); impl RasterizationOrderAMD { - pub const STRICT_AMD: Self = RasterizationOrderAMD(0); - pub const RELAXED_AMD: Self = RasterizationOrderAMD(1); + pub const STRICT: Self = RasterizationOrderAMD(0); + pub const RELAXED: Self = RasterizationOrderAMD(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ValidationCheckEXT(pub(crate) i32); impl ValidationCheckEXT { - pub const ALL_EXT: Self = ValidationCheckEXT(0); - pub const SHADERS_EXT: Self = ValidationCheckEXT(1); + pub const ALL: Self = ValidationCheckEXT(0); + pub const SHADERS: Self = ValidationCheckEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct IndirectCommandsTokenTypeNVX(pub(crate) i32); impl IndirectCommandsTokenTypeNVX { - pub const PIPELINE_NVX: Self = IndirectCommandsTokenTypeNVX(0); - pub const DESCRIPTOR_SET_NVX: Self = IndirectCommandsTokenTypeNVX(1); - pub const INDEX_BUFFER_NVX: Self = IndirectCommandsTokenTypeNVX(2); - pub const VERTEX_BUFFER_NVX: Self = IndirectCommandsTokenTypeNVX(3); - pub const PUSH_CONSTANT_NVX: Self = IndirectCommandsTokenTypeNVX(4); - pub const DRAW_INDEXED_NVX: Self = IndirectCommandsTokenTypeNVX(5); - pub const DRAW_NVX: Self = IndirectCommandsTokenTypeNVX(6); - pub const DISPATCH_NVX: Self = IndirectCommandsTokenTypeNVX(7); + pub const PIPELINE: Self = IndirectCommandsTokenTypeNVX(0); + pub const DESCRIPTOR_SET: Self = IndirectCommandsTokenTypeNVX(1); + pub const INDEX_BUFFER: Self = IndirectCommandsTokenTypeNVX(2); + pub const VERTEX_BUFFER: Self = IndirectCommandsTokenTypeNVX(3); + pub const PUSH_CONSTANT: Self = IndirectCommandsTokenTypeNVX(4); + pub const DRAW_INDEXED: Self = IndirectCommandsTokenTypeNVX(5); + pub const DRAW: Self = IndirectCommandsTokenTypeNVX(6); + pub const DISPATCH: Self = IndirectCommandsTokenTypeNVX(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ObjectEntryTypeNVX(pub(crate) i32); impl ObjectEntryTypeNVX { - pub const DESCRIPTOR_SET_NVX: Self = ObjectEntryTypeNVX(0); - pub const PIPELINE_NVX: Self = ObjectEntryTypeNVX(1); - pub const INDEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(2); - pub const VERTEX_BUFFER_NVX: Self = ObjectEntryTypeNVX(3); - pub const PUSH_CONSTANT_NVX: Self = ObjectEntryTypeNVX(4); + pub const DESCRIPTOR_SET: Self = ObjectEntryTypeNVX(0); + pub const PIPELINE: Self = ObjectEntryTypeNVX(1); + pub const INDEX_BUFFER: Self = ObjectEntryTypeNVX(2); + pub const VERTEX_BUFFER: Self = ObjectEntryTypeNVX(3); + pub const PUSH_CONSTANT: Self = ObjectEntryTypeNVX(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DisplayPowerStateEXT(pub(crate) i32); impl DisplayPowerStateEXT { - pub const OFF_EXT: Self = DisplayPowerStateEXT(0); - pub const SUSPEND_EXT: Self = DisplayPowerStateEXT(1); - pub const ON_EXT: Self = DisplayPowerStateEXT(2); + pub const OFF: Self = DisplayPowerStateEXT(0); + pub const SUSPEND: Self = DisplayPowerStateEXT(1); + pub const ON: Self = DisplayPowerStateEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DeviceEventTypeEXT(pub(crate) i32); impl DeviceEventTypeEXT { - pub const DISPLAY_HOTPLUG_EXT: Self = DeviceEventTypeEXT(0); + pub const DISPLAY_HOTPLUG: Self = DeviceEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DisplayEventTypeEXT(pub(crate) i32); impl DisplayEventTypeEXT { - pub const FIRST_PIXEL_OUT_EXT: Self = DisplayEventTypeEXT(0); + pub const FIRST_PIXEL_OUT: Self = DisplayEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); impl ViewportCoordinateSwizzleNV { - pub const POSITIVE_X_NV: Self = ViewportCoordinateSwizzleNV(0); - pub const NEGATIVE_X_NV: Self = ViewportCoordinateSwizzleNV(1); - pub const POSITIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(2); - pub const NEGATIVE_Y_NV: Self = ViewportCoordinateSwizzleNV(3); - pub const POSITIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(4); - pub const NEGATIVE_Z_NV: Self = ViewportCoordinateSwizzleNV(5); - pub const POSITIVE_W_NV: Self = ViewportCoordinateSwizzleNV(6); - pub const NEGATIVE_W_NV: Self = ViewportCoordinateSwizzleNV(7); + pub const POSITIVE_X: Self = ViewportCoordinateSwizzleNV(0); + pub const NEGATIVE_X: Self = ViewportCoordinateSwizzleNV(1); + pub const POSITIVE_Y: Self = ViewportCoordinateSwizzleNV(2); + pub const NEGATIVE_Y: Self = ViewportCoordinateSwizzleNV(3); + pub const POSITIVE_Z: Self = ViewportCoordinateSwizzleNV(4); + pub const NEGATIVE_Z: Self = ViewportCoordinateSwizzleNV(5); + pub const POSITIVE_W: Self = ViewportCoordinateSwizzleNV(6); + pub const NEGATIVE_W: Self = ViewportCoordinateSwizzleNV(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct DiscardRectangleModeEXT(pub(crate) i32); impl DiscardRectangleModeEXT { - pub const INCLUSIVE_EXT: Self = DiscardRectangleModeEXT(0); - pub const EXCLUSIVE_EXT: Self = DiscardRectangleModeEXT(1); + pub const INCLUSIVE: Self = DiscardRectangleModeEXT(0); + pub const EXCLUSIVE: Self = DiscardRectangleModeEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] @@ -12667,9 +12667,9 @@ impl PointClippingBehavior { #[repr(C)] pub struct SamplerReductionModeEXT(pub(crate) i32); impl SamplerReductionModeEXT { - pub const WEIGHTED_AVERAGE_EXT: Self = SamplerReductionModeEXT(0); - pub const MIN_EXT: Self = SamplerReductionModeEXT(1); - pub const MAX_EXT: Self = SamplerReductionModeEXT(2); + pub const WEIGHTED_AVERAGE: Self = SamplerReductionModeEXT(0); + pub const MIN: Self = SamplerReductionModeEXT(1); + pub const MAX: Self = SamplerReductionModeEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] @@ -12712,49 +12712,49 @@ impl ChromaLocation { #[repr(C)] pub struct BlendOverlapEXT(pub(crate) i32); impl BlendOverlapEXT { - pub const UNCORRELATED_EXT: Self = BlendOverlapEXT(0); - pub const DISJOINT_EXT: Self = BlendOverlapEXT(1); - pub const CONJOINT_EXT: Self = BlendOverlapEXT(2); + pub const UNCORRELATED: Self = BlendOverlapEXT(0); + pub const DISJOINT: Self = BlendOverlapEXT(1); + pub const CONJOINT: Self = BlendOverlapEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct CoverageModulationModeNV(pub(crate) i32); impl CoverageModulationModeNV { - pub const NONE_NV: Self = CoverageModulationModeNV(0); - pub const RGB_NV: Self = CoverageModulationModeNV(1); - pub const ALPHA_NV: Self = CoverageModulationModeNV(2); - pub const RGBA_NV: Self = CoverageModulationModeNV(3); + pub const NONE: Self = CoverageModulationModeNV(0); + pub const RGB: Self = CoverageModulationModeNV(1); + pub const ALPHA: Self = CoverageModulationModeNV(2); + pub const RGBA: Self = CoverageModulationModeNV(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); impl ValidationCacheHeaderVersionEXT { - pub const ONE_EXT: Self = ValidationCacheHeaderVersionEXT(1); + pub const ONE: Self = ValidationCacheHeaderVersionEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ShaderInfoTypeAMD(pub(crate) i32); impl ShaderInfoTypeAMD { - pub const STATISTICS_AMD: Self = ShaderInfoTypeAMD(0); - pub const BINARY_AMD: Self = ShaderInfoTypeAMD(1); - pub const DISASSEMBLY_AMD: Self = ShaderInfoTypeAMD(2); + pub const STATISTICS: Self = ShaderInfoTypeAMD(0); + pub const BINARY: Self = ShaderInfoTypeAMD(1); + pub const DISASSEMBLY: Self = ShaderInfoTypeAMD(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct QueueGlobalPriorityEXT(pub(crate) i32); impl QueueGlobalPriorityEXT { - pub const LOW_EXT: Self = QueueGlobalPriorityEXT(128); - pub const MEDIUM_EXT: Self = QueueGlobalPriorityEXT(256); - pub const HIGH_EXT: Self = QueueGlobalPriorityEXT(512); - pub const REALTIME_EXT: Self = QueueGlobalPriorityEXT(1024); + pub const LOW: Self = QueueGlobalPriorityEXT(128); + pub const MEDIUM: Self = QueueGlobalPriorityEXT(256); + pub const HIGH: Self = QueueGlobalPriorityEXT(512); + pub const REALTIME: Self = QueueGlobalPriorityEXT(1024); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] pub struct ConservativeRasterizationModeEXT(pub(crate) i32); impl ConservativeRasterizationModeEXT { - pub const DISABLED_EXT: Self = ConservativeRasterizationModeEXT(0); - pub const OVERESTIMATE_EXT: Self = ConservativeRasterizationModeEXT(1); - pub const UNDERESTIMATE_EXT: Self = ConservativeRasterizationModeEXT(2); + pub const DISABLED: Self = ConservativeRasterizationModeEXT(0); + pub const OVERESTIMATE: Self = ConservativeRasterizationModeEXT(1); + pub const UNDERESTIMATE: Self = ConservativeRasterizationModeEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(C)] @@ -13227,46 +13227,46 @@ pub mod bitflags { pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); impl DisplayPlaneAlphaFlagsKHR { - pub const OPAQUE_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b1); - pub const GLOBAL_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b10); - pub const PER_PIXEL_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b100); - pub const PER_PIXEL_PREMULTIPLIED_KHR: Self = DisplayPlaneAlphaFlagsKHR(0b1000); + pub const OPAQUE: Self = DisplayPlaneAlphaFlagsKHR(0b1); + pub const GLOBAL: Self = DisplayPlaneAlphaFlagsKHR(0b10); + pub const PER_PIXEL: Self = DisplayPlaneAlphaFlagsKHR(0b100); + pub const PER_PIXEL_PREMULTIPLIED: Self = DisplayPlaneAlphaFlagsKHR(0b1000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); impl CompositeAlphaFlagsKHR { - pub const OPAQUE_KHR: Self = CompositeAlphaFlagsKHR(0b1); - pub const PRE_MULTIPLIED_KHR: Self = CompositeAlphaFlagsKHR(0b10); - pub const POST_MULTIPLIED_KHR: Self = CompositeAlphaFlagsKHR(0b100); - pub const INHERIT_KHR: Self = CompositeAlphaFlagsKHR(0b1000); + pub const OPAQUE: Self = CompositeAlphaFlagsKHR(0b1); + pub const PRE_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b10); + pub const POST_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b100); + pub const INHERIT: Self = CompositeAlphaFlagsKHR(0b1000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); impl SurfaceTransformFlagsKHR { - pub const IDENTITY_KHR: Self = SurfaceTransformFlagsKHR(0b1); - pub const ROTATE_90_KHR: Self = SurfaceTransformFlagsKHR(0b10); - pub const ROTATE_180_KHR: Self = SurfaceTransformFlagsKHR(0b100); - pub const ROTATE_270_KHR: Self = SurfaceTransformFlagsKHR(0b1000); - pub const HORIZONTAL_MIRROR_KHR: Self = SurfaceTransformFlagsKHR(0b10000); - pub const HORIZONTAL_MIRROR_ROTATE_90_KHR: Self = SurfaceTransformFlagsKHR(0b100000); - pub const HORIZONTAL_MIRROR_ROTATE_180_KHR: Self = SurfaceTransformFlagsKHR(0b1000000); - pub const HORIZONTAL_MIRROR_ROTATE_270_KHR: Self = SurfaceTransformFlagsKHR(0b10000000); - pub const INHERIT_KHR: Self = SurfaceTransformFlagsKHR(0b100000000); + pub const IDENTITY: Self = SurfaceTransformFlagsKHR(0b1); + pub const ROTATE_90: Self = SurfaceTransformFlagsKHR(0b10); + pub const ROTATE_180: Self = SurfaceTransformFlagsKHR(0b100); + pub const ROTATE_270: Self = SurfaceTransformFlagsKHR(0b1000); + pub const HORIZONTAL_MIRROR: Self = SurfaceTransformFlagsKHR(0b10000); + pub const HORIZONTAL_MIRROR_ROTATE_90: Self = SurfaceTransformFlagsKHR(0b100000); + pub const HORIZONTAL_MIRROR_ROTATE_180: Self = SurfaceTransformFlagsKHR(0b1000000); + pub const HORIZONTAL_MIRROR_ROTATE_270: Self = SurfaceTransformFlagsKHR(0b10000000); + pub const INHERIT: Self = SurfaceTransformFlagsKHR(0b100000000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DebugReportFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); impl DebugReportFlagsEXT { - pub const INFORMATION_EXT: Self = DebugReportFlagsEXT(0b1); - pub const WARNING_EXT: Self = DebugReportFlagsEXT(0b10); - pub const PERFORMANCE_WARNING_EXT: Self = DebugReportFlagsEXT(0b100); - pub const ERROR_EXT: Self = DebugReportFlagsEXT(0b1000); - pub const DEBUG_EXT: Self = DebugReportFlagsEXT(0b10000); + pub const INFORMATION: Self = DebugReportFlagsEXT(0b1); + pub const WARNING: Self = DebugReportFlagsEXT(0b10); + pub const PERFORMANCE_WARNING: Self = DebugReportFlagsEXT(0b100); + pub const ERROR: Self = DebugReportFlagsEXT(0b1000); + pub const DEBUG: Self = DebugReportFlagsEXT(0b10000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -13319,18 +13319,18 @@ pub mod bitflags { pub struct IndirectCommandsLayoutUsageFlagsNVX(pub(crate) Flags); vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); impl IndirectCommandsLayoutUsageFlagsNVX { - pub const UNORDERED_SEQUENCES_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1); - pub const SPARSE_SEQUENCES_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b10); - pub const EMPTY_EXECUTIONS_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b100); - pub const INDEXED_SEQUENCES_NVX: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1000); + pub const UNORDERED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1); + pub const SPARSE_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b10); + pub const EMPTY_EXECUTIONS: Self = IndirectCommandsLayoutUsageFlagsNVX(0b100); + pub const INDEXED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ObjectEntryUsageFlagsNVX(pub(crate) Flags); vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); impl ObjectEntryUsageFlagsNVX { - pub const GRAPHICS_NVX: Self = ObjectEntryUsageFlagsNVX(0b1); - pub const COMPUTE_NVX: Self = ObjectEntryUsageFlagsNVX(0b10); + pub const GRAPHICS: Self = ObjectEntryUsageFlagsNVX(0b1); + pub const COMPUTE: Self = ObjectEntryUsageFlagsNVX(0b10); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -13428,7 +13428,7 @@ pub mod bitflags { pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); impl SurfaceCounterFlagsEXT { - pub const VBLANK_EXT: Self = SurfaceCounterFlagsEXT(0b1); + pub const VBLANK: Self = SurfaceCounterFlagsEXT(0b1); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -13458,13 +13458,13 @@ pub mod bitflags { vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); impl DeviceGroupPresentModeFlagsKHR { #[doc = "Present from local memory"] - pub const LOCAL_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b1); + pub const LOCAL: Self = DeviceGroupPresentModeFlagsKHR(0b1); #[doc = "Present from remote memory"] - pub const REMOTE_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b10); + pub const REMOTE: Self = DeviceGroupPresentModeFlagsKHR(0b10); #[doc = "Present sum of local and/or remote memory"] - pub const SUM_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b100); + pub const SUM: Self = DeviceGroupPresentModeFlagsKHR(0b100); #[doc = "Each physical device presents from local memory"] - pub const LOCAL_MULTI_DEVICE_KHR: Self = DeviceGroupPresentModeFlagsKHR(0b1000); + pub const LOCAL_MULTI_DEVICE: Self = DeviceGroupPresentModeFlagsKHR(0b1000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -13481,29 +13481,29 @@ pub mod bitflags { pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); impl DebugUtilsMessageSeverityFlagsEXT { - pub const VERBOSE_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b1); - pub const INFO_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b10000); - pub const WARNING_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b100000000); - pub const ERROR_EXT: Self = DebugUtilsMessageSeverityFlagsEXT(0b1000000000000); + pub const VERBOSE: Self = DebugUtilsMessageSeverityFlagsEXT(0b1); + pub const INFO: Self = DebugUtilsMessageSeverityFlagsEXT(0b10000); + pub const WARNING: Self = DebugUtilsMessageSeverityFlagsEXT(0b100000000); + pub const ERROR: Self = DebugUtilsMessageSeverityFlagsEXT(0b1000000000000); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); impl DebugUtilsMessageTypeFlagsEXT { - pub const GENERAL_EXT: Self = DebugUtilsMessageTypeFlagsEXT(0b1); - pub const VALIDATION_EXT: Self = DebugUtilsMessageTypeFlagsEXT(0b10); - pub const PERFORMANCE_EXT: Self = DebugUtilsMessageTypeFlagsEXT(0b100); + pub const GENERAL: Self = DebugUtilsMessageTypeFlagsEXT(0b1); + pub const VALIDATION: Self = DebugUtilsMessageTypeFlagsEXT(0b10); + pub const PERFORMANCE: Self = DebugUtilsMessageTypeFlagsEXT(0b100); } #[repr(C)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DescriptorBindingFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); impl DescriptorBindingFlagsEXT { - pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorBindingFlagsEXT(0b1); - pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = DescriptorBindingFlagsEXT(0b10); - pub const PARTIALLY_BOUND_EXT: Self = DescriptorBindingFlagsEXT(0b100); - pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = DescriptorBindingFlagsEXT(0b1000); + pub const UPDATE_AFTER_BIND: Self = DescriptorBindingFlagsEXT(0b1); + pub const UPDATE_UNUSED_WHILE_PENDING: Self = DescriptorBindingFlagsEXT(0b10); + pub const PARTIALLY_BOUND: Self = DescriptorBindingFlagsEXT(0b100); + pub const VARIABLE_DESCRIPTOR_COUNT: Self = DescriptorBindingFlagsEXT(0b1000); } } pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; @@ -13975,11 +13975,11 @@ pub mod extensions { } #[doc = "Generated from \'VK_KHR_swapchain\'"] impl SwapchainCreateFlagsKHR { - pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = SwapchainCreateFlagsKHR(0b1); + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = SwapchainCreateFlagsKHR(0b1); } #[doc = "Generated from \'VK_KHR_swapchain\'"] impl SwapchainCreateFlagsKHR { - pub const PROTECTED_KHR: Self = SwapchainCreateFlagsKHR(0b10); + pub const PROTECTED: Self = SwapchainCreateFlagsKHR(0b10); } pub struct KhrDisplayFn { get_physical_device_display_properties_khr: @@ -15023,11 +15023,11 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_debug_report\'"] impl DebugReportObjectTypeEXT { - pub const SAMPLER_YCBCR_CONVERSION_EXT: Self = DebugReportObjectTypeEXT(1000156000); + pub const SAMPLER_YCBCR_CONVERSION: Self = DebugReportObjectTypeEXT(1000156000); } #[doc = "Generated from \'VK_EXT_debug_report\'"] impl DebugReportObjectTypeEXT { - pub const DESCRIPTOR_UPDATE_TEMPLATE_EXT: Self = DebugReportObjectTypeEXT(1000085000); + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = DebugReportObjectTypeEXT(1000085000); } pub struct NvGlslShaderFn {} unsafe impl Send for NvGlslShaderFn {} @@ -18898,11 +18898,11 @@ pub mod extensions { } #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] impl PresentModeKHR { - pub const SHARED_DEMAND_REFRESH_KHR: Self = PresentModeKHR(1000111000); + pub const SHARED_DEMAND_REFRESH: Self = PresentModeKHR(1000111000); } #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] impl PresentModeKHR { - pub const SHARED_CONTINUOUS_REFRESH_KHR: Self = PresentModeKHR(1000111001); + pub const SHARED_CONTINUOUS_REFRESH: Self = PresentModeKHR(1000111001); } #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] impl ImageLayout { @@ -19602,7 +19602,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_external_memory_dma_buf\'"] impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_EXT: Self = + pub const EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF: Self = ExternalMemoryHandleTypeFlags(0b1000000000); } pub struct ExtQueueFamilyForeignFn {} @@ -21699,12 +21699,12 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_external_memory_host\'"] impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_EXT: Self = + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION: Self = ExternalMemoryHandleTypeFlags(0b10000000); } #[doc = "Generated from \'VK_EXT_external_memory_host\'"] impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY: Self = ExternalMemoryHandleTypeFlags(0b100000000); } pub struct AmdBufferMarkerFn { diff --git a/examples/src/lib.rs b/examples/src/lib.rs index a7740c8..9cee8eb 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -305,9 +305,9 @@ impl ExampleBase { let debug_info = vk::DebugReportCallbackCreateInfoEXT { s_type: vk::StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, p_next: ptr::null(), - flags: vk::DebugReportFlagsEXT::ERROR_EXT - | vk::DebugReportFlagsEXT::WARNING_EXT - | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING_EXT, + flags: vk::DebugReportFlagsEXT::ERROR + | vk::DebugReportFlagsEXT::WARNING + | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING, pfn_callback: vulkan_debug_callback, p_user_data: ptr::null_mut(), }; @@ -411,9 +411,9 @@ impl ExampleBase { }; let pre_transform = if surface_capabilities .supported_transforms - .subset(vk::SurfaceTransformFlagsKHR::IDENTITY_KHR) + .subset(vk::SurfaceTransformFlagsKHR::IDENTITY) { - vk::SurfaceTransformFlagsKHR::IDENTITY_KHR + vk::SurfaceTransformFlagsKHR::IDENTITY } else { surface_capabilities.current_transform }; @@ -423,8 +423,8 @@ impl ExampleBase { let present_mode = present_modes .iter() .cloned() - .find(|&mode| mode == vk::PresentModeKHR::MAILBOX_KHR) - .unwrap_or(vk::PresentModeKHR::FIFO_KHR); + .find(|&mode| mode == vk::PresentModeKHR::MAILBOX) + .unwrap_or(vk::PresentModeKHR::FIFO); let swapchain_loader = Swapchain::new(&instance, &device).expect("Unable to load swapchain"); let swapchain_create_info = vk::SwapchainCreateInfoKHR { @@ -439,7 +439,7 @@ impl ExampleBase { image_usage: vk::ImageUsageFlags::COLOR_ATTACHMENT, image_sharing_mode: vk::SharingMode::EXCLUSIVE, pre_transform: pre_transform, - composite_alpha: vk::CompositeAlphaFlagsKHR::OPAQUE_KHR, + composite_alpha: vk::CompositeAlphaFlagsKHR::OPAQUE, present_mode: present_mode, clipped: 1, old_swapchain: vk::SwapchainKHR::null(), diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 923209c..63489f8 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -915,20 +915,25 @@ pub enum EnumType { } pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { - let _name = enum_name.split("FlagBits").nth(0).expect("split"); + let _name = enum_name.replace("FlagBits", ""); // TODO: Should be read from vk.xml // TODO: Also needs to be more robust, vendor names can be substrings from itself, // like NVX and NV let vendors = ["_NVX", "_KHR", "_EXT", "_NV", "_AMD", "_ANDROID", "_GOOGLE"]; let mut struct_name = _name.to_shouty_snake_case(); - for vendor in &vendors { - struct_name = struct_name.replace(vendor, ""); - } + let vendor = vendors + .into_iter() + .find(|&vendor| struct_name.contains(vendor)) + .cloned() + .unwrap_or(""); + struct_name = struct_name.replace(vendor, ""); let new_variant_name = variant_name.replace(&struct_name, "").replace("VK", ""); let new_variant_name = new_variant_name .trim_matches('_') .to_shouty_snake_case() - .replace("_BIT", ""); + .replace("_BIT", "") + .replace(vendor, ""); + println!("{} {} = {} {}", enum_name, struct_name, vendor, variant_name); let is_digit = new_variant_name .chars() .nth(0) From 89dffac8541625246c5e91f06cbb97a37d5c1662 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 1 Aug 2018 09:10:41 +0200 Subject: [PATCH 053/122] Remove useless println --- generator/Vulkan-Headers | 2 +- generator/src/lib.rs | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index c4e056d..718a04e 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit c4e056d365472174471a243dfefbfe66a03564af +Subproject commit 718a04e51b967fbe6de9d09ecfc15397f0eae5bd diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 63489f8..b3005f8 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -621,7 +621,6 @@ impl FieldExt for vkxml::Field { } fn type_tokens(&self) -> Tokens { - println!("{:#?}", self); let ty = name_to_tokens(&self.basetype); let pointer = self .reference @@ -933,7 +932,6 @@ pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { .to_shouty_snake_case() .replace("_BIT", "") .replace(vendor, ""); - println!("{} {} = {} {}", enum_name, struct_name, vendor, variant_name); let is_digit = new_variant_name .chars() .nth(0) From 33a0eee190d36498b614add321a3f88e1c97baf7 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 1 Aug 2018 09:12:39 +0200 Subject: [PATCH 054/122] Remove "VK" from constants --- ash/src/vk.rs | 38 +++++++++++++++++++------------------- generator/src/lib.rs | 3 ++- 2 files changed, 21 insertions(+), 20 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 1f694e3..e76cf87 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -13506,25 +13506,25 @@ pub mod bitflags { pub const VARIABLE_DESCRIPTOR_COUNT: Self = DescriptorBindingFlagsEXT(0b1000); } } -pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; -pub const VK_UUID_SIZE: usize = 16; -pub const VK_LUID_SIZE: usize = 8; -pub const VK_MAX_EXTENSION_NAME_SIZE: usize = 256; -pub const VK_MAX_DESCRIPTION_SIZE: usize = 256; -pub const VK_MAX_MEMORY_TYPES: usize = 32; -pub const VK_MAX_MEMORY_HEAPS: usize = 16; -pub const VK_LOD_CLAMP_NONE: f32 = 1000.00; -pub const VK_REMAINING_MIP_LEVELS: u32 = !0; -pub const VK_REMAINING_ARRAY_LAYERS: u32 = !0; -pub const VK_WHOLE_SIZE: u64 = !0; -pub const VK_ATTACHMENT_UNUSED: u32 = !0; -pub const VK_TRUE: usize = 1; -pub const VK_FALSE: usize = 0; -pub const VK_QUEUE_FAMILY_IGNORED: u32 = !0; -pub const VK_QUEUE_FAMILY_EXTERNAL: u32 = !0 - 1; -pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = !0 - 2; -pub const VK_SUBPASS_EXTERNAL: u32 = !0; -pub const VK_MAX_DEVICE_GROUP_SIZE: usize = 32; +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; +pub const MAX_MEMORY_HEAPS: usize = 16; +pub const LOD_CLAMP_NONE: f32 = 1000.00; +pub const REMAINING_MIP_LEVELS: u32 = !0; +pub const REMAINING_ARRAY_LAYERS: u32 = !0; +pub const WHOLE_SIZE: u64 = !0; +pub const ATTACHMENT_UNUSED: u32 = !0; +pub const TRUE: usize = 1; +pub const FALSE: usize = 0; +pub const QUEUE_FAMILY_IGNORED: u32 = !0; +pub const QUEUE_FAMILY_EXTERNAL: u32 = !0 - 1; +pub const QUEUE_FAMILY_FOREIGN_EXT: u32 = !0 - 2; +pub const SUBPASS_EXTERNAL: u32 = !0; +pub const MAX_DEVICE_GROUP_SIZE: usize = 32; pub mod extensions { use super::*; pub struct KhrSurfaceFn { diff --git a/generator/src/lib.rs b/generator/src/lib.rs index b3005f8..40996d9 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1399,7 +1399,8 @@ pub fn generate_constant<'a>( ) -> Tokens { cache.insert(constant.name.as_str()); let c = Constant::from_constant(constant); - let ident = Ident::from(constant.name.as_str()); + let name =constant.name.replace("VK_", ""); + let ident = Ident::from(name.as_str()); let value = c.to_tokens(); let ty = c.ty().to_tokens(); quote!{ From a6d5a124df7c052e62b0b9ae266bca3510f79eaf Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 1 Aug 2018 09:22:28 +0200 Subject: [PATCH 055/122] Rename constants in the example and inside static arrays --- ash/src/vk.rs | 24 ++++++++++++------------ examples/src/bin/texture.rs | 10 +++++----- examples/src/bin/triangle.rs | 2 +- examples/src/lib.rs | 4 ++-- generator/src/lib.rs | 11 +++++++++-- 5 files changed, 29 insertions(+), 22 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index e76cf87..cba491d 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -5008,8 +5008,8 @@ pub struct PhysicalDeviceProperties { pub vendor_id: uint32_t, pub device_id: uint32_t, pub device_type: PhysicalDeviceType, - pub device_name: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE], - pub pipeline_cache_uuid: [uint8_t; VK_UUID_SIZE], + pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE], + pub pipeline_cache_uuid: [uint8_t; UUID_SIZE], pub limits: PhysicalDeviceLimits, pub sparse_properties: PhysicalDeviceSparseProperties, } @@ -5050,7 +5050,7 @@ impl ::std::default::Default for PhysicalDeviceProperties { #[repr(C)] #[derive(Copy, Clone)] pub struct ExtensionProperties { - pub extension_name: [c_char; VK_MAX_EXTENSION_NAME_SIZE], + pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], pub spec_version: uint32_t, } impl ::std::fmt::Debug for ExtensionProperties { @@ -5074,10 +5074,10 @@ impl ::std::default::Default for ExtensionProperties { #[repr(C)] #[derive(Copy, Clone)] pub struct LayerProperties { - pub layer_name: [c_char; VK_MAX_EXTENSION_NAME_SIZE], + pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE], pub spec_version: uint32_t, pub implementation_version: uint32_t, - pub description: [c_char; VK_MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], } impl ::std::fmt::Debug for LayerProperties { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { @@ -5254,9 +5254,9 @@ pub struct QueueFamilyProperties { #[derive(Copy, Clone)] pub struct PhysicalDeviceMemoryProperties { pub memory_type_count: uint32_t, - pub memory_types: [MemoryType; VK_MAX_MEMORY_TYPES], + pub memory_types: [MemoryType; MAX_MEMORY_TYPES], pub memory_heap_count: uint32_t, - pub memory_heaps: [MemoryHeap; VK_MAX_MEMORY_HEAPS], + pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], } impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { @@ -8642,9 +8642,9 @@ pub struct ExternalBufferPropertiesKHR {} pub struct PhysicalDeviceIDProperties { pub s_type: StructureType, pub p_next: *mut c_void, - pub device_uuid: [uint8_t; VK_UUID_SIZE], - pub driver_uuid: [uint8_t; VK_UUID_SIZE], - pub device_luid: [uint8_t; VK_LUID_SIZE], + pub device_uuid: [uint8_t; UUID_SIZE], + pub driver_uuid: [uint8_t; UUID_SIZE], + pub device_luid: [uint8_t; LUID_SIZE], pub device_node_mask: uint32_t, pub device_luid_valid: Bool32, } @@ -9421,7 +9421,7 @@ pub struct PhysicalDeviceGroupProperties { pub s_type: StructureType, pub p_next: *mut c_void, pub physical_device_count: uint32_t, - pub physical_devices: [PhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE], + pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, } impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { @@ -9661,7 +9661,7 @@ pub struct DeviceGroupBindSparseInfoKHR {} pub struct DeviceGroupPresentCapabilitiesKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub present_mask: [uint32_t; VK_MAX_DEVICE_GROUP_SIZE], + pub present_mask: [uint32_t; MAX_DEVICE_GROUP_SIZE], pub modes: DeviceGroupPresentModeFlagsKHR, } impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index bce408c..e089bc0 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -67,7 +67,7 @@ fn main() { }; let dependency = vk::SubpassDependency { dependency_flags: Default::default(), - src_subpass: vk::VK_SUBPASS_EXTERNAL, + src_subpass: vk::SUBPASS_EXTERNAL, dst_subpass: Default::default(), src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_access_mask: Default::default(), @@ -418,8 +418,8 @@ fn main() { dst_access_mask: vk::AccessFlags::TRANSFER_WRITE, old_layout: vk::ImageLayout::UNDEFINED, new_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, image: texture_image, subresource_range: vk::ImageSubresourceRange { aspect_mask: vk::ImageAspectFlags::COLOR, @@ -470,8 +470,8 @@ fn main() { dst_access_mask: vk::AccessFlags::SHADER_READ, old_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, new_layout: vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, image: texture_image, subresource_range: vk::ImageSubresourceRange { aspect_mask: vk::ImageAspectFlags::COLOR, diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index d84d142..12a3b85 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -57,7 +57,7 @@ fn main() { }; let dependency = vk::SubpassDependency { dependency_flags: Default::default(), - src_subpass: vk::VK_SUBPASS_EXTERNAL, + src_subpass: vk::SUBPASS_EXTERNAL, dst_subpass: Default::default(), src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_access_mask: Default::default(), diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 9cee8eb..e0df121 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -559,8 +559,8 @@ impl ExampleBase { | vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE, old_layout: vk::ImageLayout::UNDEFINED, new_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, image: depth_image, subresource_range: vk::ImageSubresourceRange { aspect_mask: vk::ImageAspectFlags::DEPTH, diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 40996d9..a071bf9 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -637,7 +637,10 @@ impl FieldExt for vkxml::Field { .as_ref() .or_else(|| self.size_enumref.as_ref()) .expect("Should have size"); - let size = Term::intern(size); + // Make sure we also rename the constant, that is + // used inside the static array + let size = constant_name(size); + let size = Term::intern(&size); Some(quote!{ [#ty; #size] }) @@ -1393,13 +1396,17 @@ pub fn generate_feature(feature: &vkxml::Feature, commands: &CommandMap) -> quot #device } } +pub fn constant_name(name: &str) -> String { + name.replace("VK_", "") +} + pub fn generate_constant<'a>( constant: &'a vkxml::Constant, cache: &mut HashSet<&'a str>, ) -> Tokens { cache.insert(constant.name.as_str()); let c = Constant::from_constant(constant); - let name =constant.name.replace("VK_", ""); + let name = constant_name(&constant.name); let ident = Ident::from(name.as_str()); let value = c.to_tokens(); let ty = c.ty().to_tokens(); From c0e98cdf78b6a5a18a09c726f4f925a9b9e451a0 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 1 Aug 2018 09:50:24 +0200 Subject: [PATCH 056/122] New signature for enumerate_instance_version --- ash/src/instance.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 0550e7e..7c30bbe 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -85,9 +85,15 @@ impl Instance { #[allow(non_camel_case_types)] pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; - unsafe fn enumerate_instance_version(&self, api_version: &mut vk::uint32_t) -> vk::Result { - self.fp_v1_1() - .enumerate_instance_version(api_version as *mut _) + + unsafe fn enumerate_instance_version(&self) -> VkResult { + let mut api_version = 0; + let err_code = self.fp_v1_1() + .enumerate_instance_version(&mut api_version as *mut _); + match err_code { + vk::Result::SUCCESS => Ok(api_version), + _ => Err(err_code) + } } } From e230d6ae81421d2325c4aba206b25aba0fe3b0c7 Mon Sep 17 00:00:00 2001 From: Tim Date: Wed, 1 Aug 2018 16:51:43 +0200 Subject: [PATCH 057/122] Add functions for Instance --- ash/src/instance.rs | 178 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 176 insertions(+), 2 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 7c30bbe..97565dd 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -87,14 +87,188 @@ pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; unsafe fn enumerate_instance_version(&self) -> VkResult { - let mut api_version = 0; + let mut api_version = mem::uninitialized(); let err_code = self.fp_v1_1() - .enumerate_instance_version(&mut api_version as *mut _); + .enumerate_instance_version(&mut api_version); match err_code { vk::Result::SUCCESS => Ok(api_version), _ => Err(err_code) } } + + fn enumerate_physical_device_groups(&self) -> VkResult> { + unsafe { + let mut group_count = mem::uninitialized(); + self.fp_v1_1() + .enumerate_physical_device_groups(self.handle(), &mut group_count, ptr::null_mut()); + let mut physical_device_groups = Vec::with_capacity(group_count as usize); + let err_code = self.fp_v1_1().enumerate_physical_device_groups( + self.handle(), + &mut group_count, + physical_device_groups.as_mut_ptr(), + ); + physical_device_groups.set_len(group_count as usize); + match err_code { + vk::Result::SUCCESS => Ok(physical_device_groups), + _ => Err(err_code), + } + } + } + + fn get_physical_device_properties2( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceProperties2 { + unsafe { + let mut prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_properties2(physical_device, &mut prop); + prop + } + } + + fn get_physical_device_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + ) -> vk::FormatProperties2 { + unsafe { + let mut format_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_format_properties2( + physical_device, + format, + &mut format_prop, + ); + format_prop + } + } + + fn get_physical_device_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceImageFormatInfo2, + ) -> VkResult { + unsafe { + let mut image_format_prop = mem::uninitialized(); + let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( + physical_device, + format_info, + &mut image_format_prop, + ); + if err_code == vk::Result::SUCCESS { + Ok(image_format_prop) + } else { + Err(err_code) + } + } + } + + fn get_physical_device_queue_family_properties2( + &self, + physical_device: vk::PhysicalDevice, + ) -> Vec { + unsafe { + let mut queue_count = 0; + self.fp_v1_1().get_physical_device_queue_family_properties2( + physical_device, + &mut queue_count, + ptr::null_mut(), + ); + let mut queue_families_vec = Vec::with_capacity(queue_count as usize); + self.fp_v1_1().get_physical_device_queue_family_properties2( + physical_device, + &mut queue_count, + queue_families_vec.as_mut_ptr(), + ); + queue_families_vec.set_len(queue_count as usize); + queue_families_vec + } + } + + fn get_physical_device_memory_properties2( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceMemoryProperties2 { + unsafe { + let mut memory_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_memory_properties2(physical_device, &mut memory_prop); + memory_prop + } + } + + fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, + ) -> Vec { + unsafe { + let mut format_count = 0; + self.fp_v1_1().get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); + let mut format_prop = Vec::with_capacity(format_count as usize); + self.fp_v1_1().get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + format_prop.as_mut_ptr(), + ); + format_prop.set_len(format_count as usize); + format_prop + } + } + + fn get_physical_device_external_buffer_properties( + &self, + physical_device: vk::PhysicalDevice, + external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo, + ) -> vk::ExternalBufferProperties { + unsafe { + let mut image_format_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_external_buffer_properties( + physical_device, + external_buffer_info, + &mut image_format_prop, + ); + image_format_prop + } + } + + fn get_physical_device_external_fence_properties( + &self, + physical_device: vk::PhysicalDevice, + external_fence_info: &vk::PhysicalDeviceExternalFenceInfo, + ) -> vk::ExternalFenceProperties { + unsafe { + let mut fence_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_external_fence_properties( + physical_device, + external_fence_info, + &mut fence_prop, + ); + fence_prop + } + } + + fn get_physical_device_external_semaphore_properties( + &self, + physical_device: vk::PhysicalDevice, + external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo, + ) -> vk::ExternalSemaphoreProperties { + unsafe { + let mut semaphore_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_external_semaphore_properties( + physical_device, + external_semaphore_info, + &mut semaphore_prop, + ); + semaphore_prop + } + } } #[allow(non_camel_case_types)] From e3526b467c24ed7bd551b1814d6076c8f0d42b7d Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 1 Aug 2018 18:46:02 +0200 Subject: [PATCH 058/122] Remove unused enumflags dependencies --- ash/Cargo.toml | 2 -- 1 file changed, 2 deletions(-) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 24bf22e..205661e 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -13,8 +13,6 @@ documentation = "https://docs.rs/ash" shared_library = "0.1.5" lazy_static = "0.2.1" libc = "0.2.26" -enumflags = "*" -enumflags_derive = "*" [features] default = [] From 2c5364871e028d33ada891614089219b2c061f71 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Thu, 2 Aug 2018 21:22:46 +0200 Subject: [PATCH 059/122] Update winit to 0.16 --- examples/Cargo.toml | 2 +- examples/src/lib.rs | 38 +++++++++++++++++--------------------- 2 files changed, 18 insertions(+), 22 deletions(-) diff --git a/examples/Cargo.toml b/examples/Cargo.toml index 3ad5c47..8873048 100644 --- a/examples/Cargo.toml +++ b/examples/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" authors = ["maik klein "] [dependencies] -winit = "0.11.1" +winit = "0.16" image = "0.10.4" ash = { path = "../ash" } diff --git a/examples/src/lib.rs b/examples/src/lib.rs index e0df121..a197f4c 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -46,8 +46,7 @@ pub fn record_submit_commandbuffer winit::ControlFlow::Break, + WindowEvent::Destroyed => winit::ControlFlow::Break, _ => ControlFlow::Continue, }, _ => ControlFlow::Continue, @@ -267,8 +266,10 @@ impl ExampleBase { let events_loop = winit::EventsLoop::new(); let window = winit::WindowBuilder::new() .with_title("Ash - Example") - .with_dimensions(window_width, window_height) - .build(&events_loop) + .with_dimensions(winit::dpi::LogicalSize::new( + window_width as f64, + window_height as f64, + )).build(&events_loop) .unwrap(); let entry = Entry::new().unwrap(); let app_name = CString::new("VulkanTriangle").unwrap(); @@ -331,8 +332,8 @@ impl ExampleBase { .enumerate() .filter_map(|(index, ref info)| { let supports_graphic_and_surface = - info.queue_flags.subset(vk::QueueFlags::GRAPHICS) - && surface_loader.get_physical_device_surface_support_khr( + info.queue_flags.subset(vk::QueueFlags::GRAPHICS) && surface_loader + .get_physical_device_surface_support_khr( *pdevice, index as u32, surface, @@ -341,10 +342,8 @@ impl ExampleBase { true => Some((*pdevice, index)), _ => None, } - }) - .nth(0) - }) - .filter_map(|v| v) + }).nth(0) + }).filter_map(|v| v) .nth(0) .expect("Couldn't find suitable device."); let queue_family_index = queue_family_index as u32; @@ -390,8 +389,7 @@ impl ExampleBase { color_space: sfmt.color_space, }, _ => sfmt.clone(), - }) - .nth(0) + }).nth(0) .expect("Unable to find suitable surface format."); let surface_capabilities = surface_loader .get_physical_device_surface_capabilities_khr(pdevice, surface) @@ -498,8 +496,7 @@ impl ExampleBase { image: image, }; device.create_image_view(&create_view_info, None).unwrap() - }) - .collect(); + }).collect(); let device_memory_properties = instance.get_physical_device_memory_properties(pdevice); let depth_image_create_info = vk::ImageCreateInfo { s_type: vk::StructureType::IMAGE_CREATE_INFO, @@ -524,12 +521,11 @@ impl ExampleBase { }; let depth_image = device.create_image(&depth_image_create_info, None).unwrap(); let depth_image_memory_req = device.get_image_memory_requirements(depth_image); - let depth_image_memory_index = - find_memorytype_index( - &depth_image_memory_req, - &device_memory_properties, - vk::MemoryPropertyFlags::DEVICE_LOCAL, - ).expect("Unable to find suitable memory index for depth image."); + let depth_image_memory_index = find_memorytype_index( + &depth_image_memory_req, + &device_memory_properties, + vk::MemoryPropertyFlags::DEVICE_LOCAL, + ).expect("Unable to find suitable memory index for depth image."); let depth_image_allocate_info = vk::MemoryAllocateInfo { s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, From 3bea365299e56430ceb11f1140ddc46ff7ec7e64 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Fri, 3 Aug 2018 08:45:28 +0200 Subject: [PATCH 060/122] Update to rust 1.28 for appveyor --- appveyor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index c587886..5b005a3 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,6 +1,6 @@ environment: matrix: - - TARGET: 1.21.0-x86_64-pc-windows + - TARGET: 1.28.0-x86_64-pc-windows COMPILER: msvc install: - if %COMPILER%==gnu choco install -y mingw From 623c26c9bcf0ac3b00d32857b82e2ed18d531f70 Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 12:22:51 +0200 Subject: [PATCH 061/122] Add functions for DeviceV1_1 --- ash/src/device.rs | 165 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 162 insertions(+), 3 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index 7b5498e..03d4411 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -1,6 +1,7 @@ #![allow(dead_code)] use prelude::*; use std::mem; +use std::ptr; use version::{FunctionPointers, V1_0, V1_1}; use vk; use RawPtr; @@ -8,12 +9,170 @@ use RawPtr; #[allow(non_camel_case_types)] pub trait DeviceV1_1: DeviceV1_0 { fn fp_v1_1(&self) -> &vk::DeviceFnV1_1; - unsafe fn bind_buffer_memory2(&self, bind_infos: &[vk::BindBufferMemoryInfo]) -> vk::Result { - self.fp_v1_1().bind_buffer_memory2( + + unsafe fn bind_buffer_memory2(&self, bind_infos: &[vk::BindBufferMemoryInfo]) -> VkResult<()> { + let err_code = self.fp_v1_1().bind_buffer_memory2( self.handle(), bind_infos.len() as _, bind_infos.as_ptr(), - ) + ); + match err_code { + vk::Result::SUCCESS => Ok(()), + _ => Err(err_code) + } + } + + unsafe fn bind_image_memory2(&self, bind_infos: &[vk::BindImageMemoryInfo]) -> VkResult<()> { + let err_code = self.fp_v1_1().bind_image_memory2( + self.handle(), + bind_infos.len() as _, + bind_infos.as_ptr(), + ); + match err_code { + vk::Result::SUCCESS => Ok(()), + _ => Err(err_code) + } + } + + fn get_device_group_peer_memory_features(&self, heap_index: vk::uint32_t, + local_device_index: vk::uint32_t, + remote_device_index: vk::uint32_t) -> vk::PeerMemoryFeatureFlags { + unsafe { + let mut peer_memory_features = mem::uninitialized(); + self.fp_v1_1().get_device_group_peer_memory_features( + self.handle(), + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features + } + } + + unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: vk::uint32_t) { + self.fp_v1_1().cmd_set_device_mask( + command_buffer, + device_mask + ); + } + + unsafe fn cmd_dispatch_base(&self, command_buffer: vk::CommandBuffer, + base_group_x: vk::uint32_t, + base_group_y: vk::uint32_t, + base_group_z: vk::uint32_t, + group_count_x: vk::uint32_t, + group_count_y: vk::uint32_t, + group_count_z: vk::uint32_t,) { + self.fp_v1_1().cmd_dispatch_base( + command_buffer, + base_group_x, + base_group_y, + base_group_z, + group_count_x, + group_count_y, + group_count_z, + ); + } + + unsafe fn get_image_memory_requirements2(&self, info: &vk::ImageMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + let mut image_memory_requirements = mem::uninitialized(); + self.fp_v1_1().get_image_memory_requirements2( + self.handle(), + info, + &mut image_memory_requirements, + ); + image_memory_requirements + } + + unsafe fn get_buffer_memory_requirements2(&self, info: &vk::BufferMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + let mut image_memory_requirements = mem::uninitialized(); + self.fp_v1_1().get_buffer_memory_requirements2( + self.handle(), + info, + &mut image_memory_requirements, + ); + image_memory_requirements + } + + unsafe fn get_image_sparse_memory_requirements2(&self, info: &vk::ImageSparseMemoryRequirementsInfo2) -> Vec { + let mut count = mem::uninitialized(); + self.fp_v1_1() + .get_image_sparse_memory_requirements2(self.handle(), info, &mut count, ptr::null_mut()); + let mut requirements = Vec::with_capacity(count as usize); + self.fp_v1_1().get_image_sparse_memory_requirements2( + self.handle(), + info, + &mut count, + requirements.as_mut_ptr(), + ); + requirements.set_len(count as usize); + requirements + } + + unsafe fn trim_command_pool(&self, command_pool: vk::CommandPool, flags: vk::CommandPoolTrimFlags) { + self.fp_v1_1().trim_command_pool( + self.handle(), + command_pool, + flags + ); + } + + unsafe fn create_sampler_ycbcr_conversion(&self, + create_info: &vk::SamplerYcbcrConversionCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + let mut ycbcr_conversion = mem::uninitialized(); + let err_code = self.fp_v1_1().create_sampler_ycbcr_conversion( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut ycbcr_conversion + ); + match err_code { + vk::Result::SUCCESS => Ok(ycbcr_conversion), + _ => Err(err_code) + } + } + + unsafe fn destroy_sampler_ycbcr_conversion(&self, + ycbcr_conversion: vk::SamplerYcbcrConversion, + allocation_callbacks: Option<&vk::AllocationCallbacks>) { + self.fp_v1_1().destroy_sampler_ycbcr_conversion(self.handle(), ycbcr_conversion, allocation_callbacks.as_raw_ptr()); + } + + unsafe fn create_descriptor_update_template(&self, + create_info: &vk::DescriptorUpdateTemplateCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + let mut descriptor_update_template = mem::uninitialized(); + let err_code = self.fp_v1_1().create_descriptor_update_template( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut descriptor_update_template + ); + match err_code { + vk::Result::SUCCESS => Ok(descriptor_update_template), + _ => Err(err_code) + } + } + + unsafe fn destroy_descriptor_update_template(&self, + descriptor_update_template: vk::DescriptorUpdateTemplate, + allocation_callbacks: Option<&vk::AllocationCallbacks>) { + self.fp_v1_1().destroy_descriptor_update_template(self.handle(), descriptor_update_template, allocation_callbacks.as_raw_ptr()); + } + + unsafe fn update_descriptor_set_with_template(&self, + descriptor_set: vk::DescriptorSet, + descriptor_update_template: vk::DescriptorUpdateTemplate, + data: *const vk::c_void) { + self.fp_v1_1().update_descriptor_set_with_template(self.handle(), descriptor_set, descriptor_update_template, data); + } + + unsafe fn get_descriptor_set_layout_support(&self, create_info: &vk::DescriptorSetLayoutCreateInfo) -> vk::DescriptorSetLayoutSupport { + let mut descriptor_set_layout_support = mem::uninitialized(); + self.fp_v1_1().get_descriptor_set_layout_support(self.handle(), create_info, &mut descriptor_set_layout_support); + descriptor_set_layout_support } } From 2256c431be7a6a2519b4ac3da0a401e11a63d1ed Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 12:34:14 +0200 Subject: [PATCH 062/122] Use repr(transparent) where possible and apply rustfmt to those files --- ash/src/vk.rs | 748 +++++++++++++++++++------------------------ generator/src/lib.rs | 96 +++--- 2 files changed, 370 insertions(+), 474 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index cba491d..f80ddb6 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -6,25 +6,25 @@ pub use self::extensions::*; pub use libc::*; #[macro_export] macro_rules! vk_make_version { - ($major:expr, $minor:expr, $patch:expr) => { + ( $ major : expr , $ minor : expr , $ patch : expr ) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ($major:expr) => { + ( $ major : expr ) => { ($major as uint32_t) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ($minor:expr) => { + ( $ minor : expr ) => { (($minor as uint32_t) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ($minor:expr) => { + ( $ minor : expr ) => { ($minor as uint32_t) & 0xfff }; } @@ -55,7 +55,7 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ($name:ident, $all:expr, $flag_type:ty) => { + ( $ name : ident , $ all : expr , $ flag_type : ty ) => { impl Default for $name { fn default() -> $name { $name(0) @@ -174,8 +174,8 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ($name:ident) => { - #[repr(C)] + ( $ name : ident ) => { + #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(uint64_t); impl $name { @@ -202,9 +202,9 @@ macro_rules! handle_nondispatchable { }; } macro_rules! define_handle { - ($name:ident) => { + ( $ name : ident ) => { #[derive(Clone, Copy, Debug)] - #[repr(C)] + #[repr(transparent)] pub struct $name { ptr: *mut u8, } @@ -444,18 +444,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: self - .get_physical_device_image_format_properties, + get_physical_device_image_format_properties: + self.get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: self - .get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: + self.get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: self - .get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: + self.get_physical_device_sparse_image_format_properties, } } } @@ -3922,19 +3922,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: self - .get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: self - .get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: + self.get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: + self.get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: self - .get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: self - .get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: self - .get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: self - .get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: + self.get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: + self.get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: + self.get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: + self.get_physical_device_external_semaphore_properties, } } } @@ -4633,187 +4633,187 @@ pub type SampleMask = uint32_t; pub type Bool32 = uint32_t; pub type Flags = uint32_t; pub type DeviceSize = uint64_t; -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct FramebufferCreateFlags(Flags); vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct QueryPoolCreateFlags(Flags); vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct RenderPassCreateFlags(Flags); vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SamplerCreateFlags(Flags); vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineLayoutCreateFlags(Flags); vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineCacheCreateFlags(Flags); vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineDepthStencilStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineDynamicStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineColorBlendStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineMultisampleStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineRasterizationStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineViewportStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineTessellationStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineInputAssemblyStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineVertexInputStateCreateFlags(Flags); vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineShaderStageCreateFlags(Flags); vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct BufferViewCreateFlags(Flags); vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct InstanceCreateFlags(Flags); vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DeviceCreateFlags(Flags); vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ImageViewCreateFlags(Flags); vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SemaphoreCreateFlags(Flags); vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ShaderModuleCreateFlags(Flags); vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct EventCreateFlags(Flags); vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct MemoryMapFlags(Flags); vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DescriptorPoolResetFlags(Flags); vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DescriptorUpdateTemplateCreateFlags(Flags); vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DisplayModeCreateFlagsKHR(Flags); vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DisplaySurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct AndroidSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct MirSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(MirSurfaceCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ViSurfaceCreateFlagsNN(Flags); vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct WaylandSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Win32SurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct XlibSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct XcbSurfaceCreateFlagsKHR(Flags); vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct IOSSurfaceCreateFlagsMVK(Flags); vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct MacOSSurfaceCreateFlagsMVK(Flags); vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CommandPoolTrimFlags(Flags); vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineViewportSwizzleStateCreateFlagsNV(Flags); vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineDiscardRectangleStateCreateFlagsEXT(Flags); vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineCoverageToColorStateCreateFlagsNV(Flags); vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineCoverageModulationStateCreateFlagsNV(Flags); vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ValidationCacheCreateFlagsEXT(Flags); vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DebugUtilsMessengerCreateFlagsEXT(Flags); vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DebugUtilsMessengerCallbackDataFlagsEXT(Flags); vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags); -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(Flags); vk_bitflags_wrapped!( @@ -5023,11 +5023,9 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }) - .field("pipeline_cache_uuid", &unsafe { + }).field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }) - .field("limits", &self.limits) + }).field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5058,8 +5056,7 @@ impl ::std::fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .finish() } } @@ -5084,13 +5081,11 @@ impl ::std::fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for LayerProperties { @@ -5147,8 +5142,7 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ) - .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5264,12 +5258,10 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }) - .field("memory_heap_count", &self.memory_heap_count) + }).field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5799,12 +5791,10 @@ impl ::std::fmt::Debug for ImageBlit { .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }) - .field("dst_subresource", &self.dst_subresource) + }).field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ImageBlit { @@ -6218,8 +6208,7 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6923,202 +6912,155 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ) - .field( + ).field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ) - .field("buffer_image_granularity", &self.buffer_image_granularity) + ).field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ) - .field( + ).field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ) - .field( + ).field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ) - .field( + ).field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ) - .field("max_per_stage_resources", &self.max_per_stage_resources) + ).field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ) - .field( + ).field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ) - .field( + ).field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ) - .field( + ).field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ) - .field( + ).field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ) - .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ) - .field( + ).field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ) - .field( + ).field( "max_vertex_output_components", &self.max_vertex_output_components, - ) - .field( + ).field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ) - .field( + ).field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ) - .field( + ).field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ) - .field( + ).field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ) - .field( + ).field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ) - .field( + ).field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ) - .field( + ).field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ) - .field( + ).field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ) - .field( + ).field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ) - .field( + ).field( "max_geometry_input_components", &self.max_geometry_input_components, - ) - .field( + ).field( "max_geometry_output_components", &self.max_geometry_output_components, - ) - .field( + ).field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ) - .field( + ).field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ) - .field( + ).field( "max_fragment_input_components", &self.max_fragment_input_components, - ) - .field( + ).field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ) - .field( + ).field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ) - .field( + ).field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ) - .field( + ).field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ) - .field("max_compute_work_group_count", &unsafe { + ).field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }) - .field( + }).field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ) - .field("max_compute_work_group_size", &unsafe { + ).field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }) - .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ) - .field("max_draw_indirect_count", &self.max_draw_indirect_count) + ).field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }) - .field("viewport_bounds_range", &unsafe { + }).field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }) - .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ) - .field( + ).field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ) - .field( + ).field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ) - .field("min_texel_offset", &self.min_texel_offset) + ).field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7127,79 +7069,63 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ) - .field("max_framebuffer_width", &self.max_framebuffer_width) + ).field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ) - .field( + ).field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ) - .field( + ).field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ) - .field( + ).field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ) - .field("max_color_attachments", &self.max_color_attachments) + ).field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ) - .field( + ).field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ) - .field( + ).field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ) - .field( + ).field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ) - .field( + ).field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ) - .field("max_sample_mask_words", &self.max_sample_mask_words) + ).field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ) - .field("timestamp_period", &self.timestamp_period) + ).field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ) - .field("discrete_queue_priorities", &self.discrete_queue_priorities) + ).field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }) - .field("line_width_range", &unsafe { + }).field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }) - .field("point_size_granularity", &self.point_size_granularity) + }).field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ) - .field( + ).field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ) - .field("non_coherent_atom_size", &self.non_coherent_atom_size) + ).field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7909,8 +7835,7 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8655,14 +8580,11 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }) - .field("driver_uuid", &unsafe { + }).field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }) - .field("device_luid", &unsafe { + }).field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }) - .field("device_node_mask", &self.device_node_mask) + }).field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -9432,8 +9354,7 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }) - .field("subset_allocation", &self.subset_allocation) + }).field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9671,8 +9592,7 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }) - .field("modes", &self.modes) + }).field("modes", &self.modes) .finish() } } @@ -10832,21 +10752,17 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ) - .field( + ).field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ) - .field("sample_location_coordinate_range", &unsafe { + ).field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }) - .field( + }).field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ) - .field("variable_sample_locations", &self.variable_sample_locations) + ).field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -11144,8 +11060,7 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -11237,8 +11152,7 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -11785,7 +11699,7 @@ impl ::std::default::Default for ExternalFormatANDROID { } } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ImageLayout(pub(crate) i32); impl ImageLayout { #[doc = "Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)"] @@ -11808,7 +11722,7 @@ impl ImageLayout { pub const PREINITIALIZED: Self = ImageLayout(8); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct AttachmentLoadOp(pub(crate) i32); impl AttachmentLoadOp { pub const LOAD: Self = AttachmentLoadOp(0); @@ -11816,14 +11730,14 @@ impl AttachmentLoadOp { pub const DONT_CARE: Self = AttachmentLoadOp(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct AttachmentStoreOp(pub(crate) i32); impl AttachmentStoreOp { pub const STORE: Self = AttachmentStoreOp(0); pub const DONT_CARE: Self = AttachmentStoreOp(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ImageType(pub(crate) i32); impl ImageType { pub const TYPE_1D: Self = ImageType(0); @@ -11831,14 +11745,14 @@ impl ImageType { pub const TYPE_3D: Self = ImageType(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ImageTiling(pub(crate) i32); impl ImageTiling { pub const OPTIMAL: Self = ImageTiling(0); pub const LINEAR: Self = ImageTiling(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ImageViewType(pub(crate) i32); impl ImageViewType { pub const TYPE_1D: Self = ImageViewType(0); @@ -11850,14 +11764,14 @@ impl ImageViewType { pub const CUBE_ARRAY: Self = ImageViewType(6); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct CommandBufferLevel(pub(crate) i32); impl CommandBufferLevel { pub const PRIMARY: Self = CommandBufferLevel(0); pub const SECONDARY: Self = CommandBufferLevel(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ComponentSwizzle(pub(crate) i32); impl ComponentSwizzle { pub const IDENTITY: Self = ComponentSwizzle(0); @@ -11869,7 +11783,7 @@ impl ComponentSwizzle { pub const A: Self = ComponentSwizzle(6); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DescriptorType(pub(crate) i32); impl DescriptorType { pub const SAMPLER: Self = DescriptorType(0); @@ -11885,7 +11799,7 @@ impl DescriptorType { pub const INPUT_ATTACHMENT: Self = DescriptorType(10); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct QueryType(pub(crate) i32); impl QueryType { pub const OCCLUSION: Self = QueryType(0); @@ -11894,7 +11808,7 @@ impl QueryType { pub const TIMESTAMP: Self = QueryType(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct BorderColor(pub(crate) i32); impl BorderColor { pub const FLOAT_TRANSPARENT_BLACK: Self = BorderColor(0); @@ -11905,20 +11819,20 @@ impl BorderColor { pub const INT_OPAQUE_WHITE: Self = BorderColor(5); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct PipelineBindPoint(pub(crate) i32); impl PipelineBindPoint { pub const GRAPHICS: Self = PipelineBindPoint(0); pub const COMPUTE: Self = PipelineBindPoint(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct PipelineCacheHeaderVersion(pub(crate) i32); impl PipelineCacheHeaderVersion { pub const ONE: Self = PipelineCacheHeaderVersion(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct PrimitiveTopology(pub(crate) i32); impl PrimitiveTopology { pub const POINT_LIST: Self = PrimitiveTopology(0); @@ -11934,28 +11848,28 @@ impl PrimitiveTopology { pub const PATCH_LIST: Self = PrimitiveTopology(10); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SharingMode(pub(crate) i32); impl SharingMode { pub const EXCLUSIVE: Self = SharingMode(0); pub const CONCURRENT: Self = SharingMode(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct IndexType(pub(crate) i32); impl IndexType { pub const UINT16: Self = IndexType(0); pub const UINT32: Self = IndexType(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct Filter(pub(crate) i32); impl Filter { pub const NEAREST: Self = Filter(0); pub const LINEAR: Self = Filter(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SamplerMipmapMode(pub(crate) i32); impl SamplerMipmapMode { #[doc = "Choose nearest mip level"] @@ -11964,7 +11878,7 @@ impl SamplerMipmapMode { pub const LINEAR: Self = SamplerMipmapMode(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SamplerAddressMode(pub(crate) i32); impl SamplerAddressMode { pub const REPEAT: Self = SamplerAddressMode(0); @@ -11973,7 +11887,7 @@ impl SamplerAddressMode { pub const CLAMP_TO_BORDER: Self = SamplerAddressMode(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct CompareOp(pub(crate) i32); impl CompareOp { pub const NEVER: Self = CompareOp(0); @@ -11986,7 +11900,7 @@ impl CompareOp { pub const ALWAYS: Self = CompareOp(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct PolygonMode(pub(crate) i32); impl PolygonMode { pub const FILL: Self = PolygonMode(0); @@ -11994,14 +11908,14 @@ impl PolygonMode { pub const POINT: Self = PolygonMode(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct FrontFace(pub(crate) i32); impl FrontFace { pub const COUNTER_CLOCKWISE: Self = FrontFace(0); pub const CLOCKWISE: Self = FrontFace(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct BlendFactor(pub(crate) i32); impl BlendFactor { pub const ZERO: Self = BlendFactor(0); @@ -12025,7 +11939,7 @@ impl BlendFactor { pub const ONE_MINUS_SRC1_ALPHA: Self = BlendFactor(18); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct BlendOp(pub(crate) i32); impl BlendOp { pub const ADD: Self = BlendOp(0); @@ -12035,7 +11949,7 @@ impl BlendOp { pub const MAX: Self = BlendOp(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct StencilOp(pub(crate) i32); impl StencilOp { pub const KEEP: Self = StencilOp(0); @@ -12048,7 +11962,7 @@ impl StencilOp { pub const DECREMENT_AND_WRAP: Self = StencilOp(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct LogicOp(pub(crate) i32); impl LogicOp { pub const CLEAR: Self = LogicOp(0); @@ -12069,13 +11983,13 @@ impl LogicOp { pub const SET: Self = LogicOp(15); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct InternalAllocationType(pub(crate) i32); impl InternalAllocationType { pub const EXECUTABLE: Self = InternalAllocationType(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SystemAllocationScope(pub(crate) i32); impl SystemAllocationScope { pub const COMMAND: Self = SystemAllocationScope(0); @@ -12085,7 +11999,7 @@ impl SystemAllocationScope { pub const INSTANCE: Self = SystemAllocationScope(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct PhysicalDeviceType(pub(crate) i32); impl PhysicalDeviceType { pub const OTHER: Self = PhysicalDeviceType(0); @@ -12095,14 +12009,14 @@ impl PhysicalDeviceType { pub const CPU: Self = PhysicalDeviceType(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct VertexInputRate(pub(crate) i32); impl VertexInputRate { pub const VERTEX: Self = VertexInputRate(0); pub const INSTANCE: Self = VertexInputRate(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct Format(pub(crate) i32); impl Format { pub const UNDEFINED: Self = Format(0); @@ -12292,7 +12206,7 @@ impl Format { pub const ASTC_12X12_SRGB_BLOCK: Self = Format(184); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct StructureType(pub(crate) i32); impl StructureType { pub const APPLICATION_INFO: Self = StructureType(0); @@ -12348,14 +12262,14 @@ impl StructureType { pub const LOADER_DEVICE_CREATE_INFO: Self = StructureType(48); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SubpassContents(pub(crate) i32); impl SubpassContents { pub const INLINE: Self = SubpassContents(0); pub const SECONDARY_COMMAND_BUFFERS: Self = SubpassContents(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct Result(pub(crate) i32); impl Result { #[doc = "Command completed successfully"] @@ -12449,7 +12363,7 @@ impl ::std::fmt::Display for Result { } } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DynamicState(pub(crate) i32); impl DynamicState { pub const VIEWPORT: Self = DynamicState(0); @@ -12463,14 +12377,14 @@ impl DynamicState { pub const STENCIL_REFERENCE: Self = DynamicState(8); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DescriptorUpdateTemplateType(pub(crate) i32); impl DescriptorUpdateTemplateType { #[doc = "Create descriptor update template for descriptor set updates"] pub const DESCRIPTOR_SET: Self = DescriptorUpdateTemplateType(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ObjectType(pub(crate) i32); impl ObjectType { pub const UNKNOWN: Self = ObjectType(0); @@ -12526,7 +12440,7 @@ impl ObjectType { pub const COMMAND_POOL: Self = ObjectType(25); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct PresentModeKHR(pub(crate) i32); impl PresentModeKHR { pub const IMMEDIATE: Self = PresentModeKHR(0); @@ -12535,13 +12449,13 @@ impl PresentModeKHR { pub const FIFO_RELAXED: Self = PresentModeKHR(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ColorSpaceKHR(pub(crate) i32); impl ColorSpaceKHR { pub const SRGB_NONLINEAR: Self = ColorSpaceKHR(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DebugReportObjectTypeEXT(pub(crate) i32); impl DebugReportObjectTypeEXT { pub const UNKNOWN: Self = DebugReportObjectTypeEXT(0); @@ -12580,21 +12494,21 @@ impl DebugReportObjectTypeEXT { pub const VALIDATION_CACHE: Self = DebugReportObjectTypeEXT(33); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct RasterizationOrderAMD(pub(crate) i32); impl RasterizationOrderAMD { pub const STRICT: Self = RasterizationOrderAMD(0); pub const RELAXED: Self = RasterizationOrderAMD(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ValidationCheckEXT(pub(crate) i32); impl ValidationCheckEXT { pub const ALL: Self = ValidationCheckEXT(0); pub const SHADERS: Self = ValidationCheckEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct IndirectCommandsTokenTypeNVX(pub(crate) i32); impl IndirectCommandsTokenTypeNVX { pub const PIPELINE: Self = IndirectCommandsTokenTypeNVX(0); @@ -12607,7 +12521,7 @@ impl IndirectCommandsTokenTypeNVX { pub const DISPATCH: Self = IndirectCommandsTokenTypeNVX(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ObjectEntryTypeNVX(pub(crate) i32); impl ObjectEntryTypeNVX { pub const DESCRIPTOR_SET: Self = ObjectEntryTypeNVX(0); @@ -12617,7 +12531,7 @@ impl ObjectEntryTypeNVX { pub const PUSH_CONSTANT: Self = ObjectEntryTypeNVX(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DisplayPowerStateEXT(pub(crate) i32); impl DisplayPowerStateEXT { pub const OFF: Self = DisplayPowerStateEXT(0); @@ -12625,19 +12539,19 @@ impl DisplayPowerStateEXT { pub const ON: Self = DisplayPowerStateEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DeviceEventTypeEXT(pub(crate) i32); impl DeviceEventTypeEXT { pub const DISPLAY_HOTPLUG: Self = DeviceEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DisplayEventTypeEXT(pub(crate) i32); impl DisplayEventTypeEXT { pub const FIRST_PIXEL_OUT: Self = DisplayEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); impl ViewportCoordinateSwizzleNV { pub const POSITIVE_X: Self = ViewportCoordinateSwizzleNV(0); @@ -12650,21 +12564,21 @@ impl ViewportCoordinateSwizzleNV { pub const NEGATIVE_W: Self = ViewportCoordinateSwizzleNV(7); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct DiscardRectangleModeEXT(pub(crate) i32); impl DiscardRectangleModeEXT { pub const INCLUSIVE: Self = DiscardRectangleModeEXT(0); pub const EXCLUSIVE: Self = DiscardRectangleModeEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct PointClippingBehavior(pub(crate) i32); impl PointClippingBehavior { pub const ALL_CLIP_PLANES: Self = PointClippingBehavior(0); pub const USER_CLIP_PLANES_ONLY: Self = PointClippingBehavior(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SamplerReductionModeEXT(pub(crate) i32); impl SamplerReductionModeEXT { pub const WEIGHTED_AVERAGE: Self = SamplerReductionModeEXT(0); @@ -12672,14 +12586,14 @@ impl SamplerReductionModeEXT { pub const MAX: Self = SamplerReductionModeEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct TessellationDomainOrigin(pub(crate) i32); impl TessellationDomainOrigin { pub const UPPER_LEFT: Self = TessellationDomainOrigin(0); pub const LOWER_LEFT: Self = TessellationDomainOrigin(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SamplerYcbcrModelConversion(pub(crate) i32); impl SamplerYcbcrModelConversion { pub const RGB_IDENTITY: Self = SamplerYcbcrModelConversion(0); @@ -12693,7 +12607,7 @@ impl SamplerYcbcrModelConversion { pub const YCBCR_2020: Self = SamplerYcbcrModelConversion(4); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct SamplerYcbcrRange(pub(crate) i32); impl SamplerYcbcrRange { #[doc = "Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)"] @@ -12702,14 +12616,14 @@ impl SamplerYcbcrRange { pub const ITU_NARROW: Self = SamplerYcbcrRange(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ChromaLocation(pub(crate) i32); impl ChromaLocation { pub const COSITED_EVEN: Self = ChromaLocation(0); pub const MIDPOINT: Self = ChromaLocation(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct BlendOverlapEXT(pub(crate) i32); impl BlendOverlapEXT { pub const UNCORRELATED: Self = BlendOverlapEXT(0); @@ -12717,7 +12631,7 @@ impl BlendOverlapEXT { pub const CONJOINT: Self = BlendOverlapEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct CoverageModulationModeNV(pub(crate) i32); impl CoverageModulationModeNV { pub const NONE: Self = CoverageModulationModeNV(0); @@ -12726,13 +12640,13 @@ impl CoverageModulationModeNV { pub const RGBA: Self = CoverageModulationModeNV(3); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); impl ValidationCacheHeaderVersionEXT { pub const ONE: Self = ValidationCacheHeaderVersionEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ShaderInfoTypeAMD(pub(crate) i32); impl ShaderInfoTypeAMD { pub const STATISTICS: Self = ShaderInfoTypeAMD(0); @@ -12740,7 +12654,7 @@ impl ShaderInfoTypeAMD { pub const DISASSEMBLY: Self = ShaderInfoTypeAMD(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct QueueGlobalPriorityEXT(pub(crate) i32); impl QueueGlobalPriorityEXT { pub const LOW: Self = QueueGlobalPriorityEXT(128); @@ -12749,7 +12663,7 @@ impl QueueGlobalPriorityEXT { pub const REALTIME: Self = QueueGlobalPriorityEXT(1024); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct ConservativeRasterizationModeEXT(pub(crate) i32); impl ConservativeRasterizationModeEXT { pub const DISABLED: Self = ConservativeRasterizationModeEXT(0); @@ -12757,7 +12671,7 @@ impl ConservativeRasterizationModeEXT { pub const UNDERESTIMATE: Self = ConservativeRasterizationModeEXT(2); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(C)] +#[repr(transparent)] pub struct VendorId(pub(crate) i32); impl VendorId { #[doc = "Vivante vendor ID"] @@ -12769,7 +12683,7 @@ impl VendorId { } pub mod bitflags { use super::*; - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CullModeFlags(pub(crate) Flags); vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); @@ -12779,7 +12693,7 @@ pub mod bitflags { pub const BACK: Self = CullModeFlags(0b10); pub const FRONT_AND_BACK: Self = CullModeFlags(0x00000003); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct QueueFlags(pub(crate) Flags); vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); @@ -12793,12 +12707,12 @@ pub mod bitflags { #[doc = "Queue supports sparse resource memory management operations"] pub const SPARSE_BINDING: Self = QueueFlags(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DeviceQueueCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); impl DeviceQueueCreateFlags {} - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct MemoryPropertyFlags(pub(crate) Flags); vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); @@ -12814,7 +12728,7 @@ pub mod bitflags { #[doc = "Memory may be allocated by the driver when it is required"] pub const LAZILY_ALLOCATED: Self = MemoryPropertyFlags(0b10000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct MemoryHeapFlags(pub(crate) Flags); vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); @@ -12822,7 +12736,7 @@ pub mod bitflags { #[doc = "If set, heap represents device memory"] pub const DEVICE_LOCAL: Self = MemoryHeapFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct AccessFlags(pub(crate) Flags); vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); @@ -12862,7 +12776,7 @@ pub mod bitflags { #[doc = "Controls coherency of memory writes"] pub const MEMORY_WRITE: Self = AccessFlags(0b10000000000000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct BufferUsageFlags(pub(crate) Flags); vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); @@ -12886,7 +12800,7 @@ pub mod bitflags { #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"] pub const INDIRECT_BUFFER: Self = BufferUsageFlags(0b100000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct BufferCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); @@ -12898,7 +12812,7 @@ pub mod bitflags { #[doc = "Buffer should support constent data access to physical memory ranges mapped into multiple locations of sparse buffers"] pub const SPARSE_ALIASED: Self = BufferCreateFlags(0b100); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ShaderStageFlags(pub(crate) Flags); vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); @@ -12912,7 +12826,7 @@ pub mod bitflags { pub const ALL_GRAPHICS: Self = ShaderStageFlags(0x0000001F); pub const ALL: Self = ShaderStageFlags(0x7FFFFFFF); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ImageUsageFlags(pub(crate) Flags); vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); @@ -12934,7 +12848,7 @@ pub mod bitflags { #[doc = "Can be used as framebuffer input attachment"] pub const INPUT_ATTACHMENT: Self = ImageUsageFlags(0b10000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ImageCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); @@ -12950,7 +12864,7 @@ pub mod bitflags { #[doc = "Allows creating image views with cube type from the created image"] pub const CUBE_COMPATIBLE: Self = ImageCreateFlags(0b10000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); @@ -12959,7 +12873,7 @@ pub mod bitflags { pub const ALLOW_DERIVATIVES: Self = PipelineCreateFlags(0b10); pub const DERIVATIVE: Self = PipelineCreateFlags(0b100); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ColorComponentFlags(pub(crate) Flags); vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); @@ -12969,14 +12883,14 @@ pub mod bitflags { pub const B: Self = ColorComponentFlags(0b100); pub const A: Self = ColorComponentFlags(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct FenceCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); impl FenceCreateFlags { pub const SIGNALED: Self = FenceCreateFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct FormatFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); @@ -13008,7 +12922,7 @@ pub mod bitflags { #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = FormatFeatureFlags(0b1000000000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct QueryControlFlags(pub(crate) Flags); vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); @@ -13016,7 +12930,7 @@ pub mod bitflags { #[doc = "Require precise results to be collected by the query"] pub const PRECISE: Self = QueryControlFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct QueryResultFlags(pub(crate) Flags); vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); @@ -13030,7 +12944,7 @@ pub mod bitflags { #[doc = "Copy the partial results of the query even if the final results are not available"] pub const PARTIAL: Self = QueryResultFlags(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CommandBufferUsageFlags(pub(crate) Flags); vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); @@ -13040,7 +12954,7 @@ pub mod bitflags { #[doc = "Command buffer may be submitted/executed more than once simultaneously"] pub const SIMULTANEOUS_USE: Self = CommandBufferUsageFlags(0b100); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct QueryPipelineStatisticFlags(pub(crate) Flags); vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); @@ -13070,7 +12984,7 @@ pub mod bitflags { #[doc = "Optional"] pub const COMPUTE_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10000000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ImageAspectFlags(pub(crate) Flags); vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); @@ -13080,7 +12994,7 @@ pub mod bitflags { pub const STENCIL: Self = ImageAspectFlags(0b100); pub const METADATA: Self = ImageAspectFlags(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SparseImageFormatFlags(pub(crate) Flags); vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); @@ -13092,7 +13006,7 @@ pub mod bitflags { #[doc = "Image uses a non-standard sparse image block dimensions"] pub const NONSTANDARD_BLOCK_SIZE: Self = SparseImageFormatFlags(0b100); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SparseMemoryBindFlags(pub(crate) Flags); vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); @@ -13100,7 +13014,7 @@ pub mod bitflags { #[doc = "Operation binds resource metadata to memory"] pub const METADATA: Self = SparseMemoryBindFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PipelineStageFlags(pub(crate) Flags); vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); @@ -13140,7 +13054,7 @@ pub mod bitflags { #[doc = "All stages supported on the queue"] pub const ALL_COMMANDS: Self = PipelineStageFlags(0b10000000000000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CommandPoolCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); @@ -13150,7 +13064,7 @@ pub mod bitflags { #[doc = "Command buffers may release their memory individually"] pub const RESET_COMMAND_BUFFER: Self = CommandPoolCreateFlags(0b10); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CommandPoolResetFlags(pub(crate) Flags); vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); @@ -13158,7 +13072,7 @@ pub mod bitflags { #[doc = "Release resources owned by the pool"] pub const RELEASE_RESOURCES: Self = CommandPoolResetFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CommandBufferResetFlags(pub(crate) Flags); vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); @@ -13166,7 +13080,7 @@ pub mod bitflags { #[doc = "Release resources owned by the buffer"] pub const RELEASE_RESOURCES: Self = CommandBufferResetFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SampleCountFlags(pub(crate) Flags); vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); @@ -13186,7 +13100,7 @@ pub mod bitflags { #[doc = "Sample count 64 supported"] pub const TYPE_64: Self = SampleCountFlags(0b1000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct AttachmentDescriptionFlags(pub(crate) Flags); vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); @@ -13194,7 +13108,7 @@ pub mod bitflags { #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] pub const MAY_ALIAS: Self = AttachmentDescriptionFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct StencilFaceFlags(pub(crate) Flags); vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); @@ -13206,7 +13120,7 @@ pub mod bitflags { #[doc = "Front and back faces"] pub const STENCIL_FRONT_AND_BACK: Self = StencilFaceFlags(0x00000003); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DescriptorPoolCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); @@ -13214,7 +13128,7 @@ pub mod bitflags { #[doc = "Descriptor sets may be freed individually"] pub const FREE_DESCRIPTOR_SET: Self = DescriptorPoolCreateFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DependencyFlags(pub(crate) Flags); vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); @@ -13222,7 +13136,7 @@ pub mod bitflags { #[doc = "Dependency is per pixel region "] pub const BY_REGION: Self = DependencyFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); @@ -13232,7 +13146,7 @@ pub mod bitflags { pub const PER_PIXEL: Self = DisplayPlaneAlphaFlagsKHR(0b100); pub const PER_PIXEL_PREMULTIPLIED: Self = DisplayPlaneAlphaFlagsKHR(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); @@ -13242,7 +13156,7 @@ pub mod bitflags { pub const POST_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b100); pub const INHERIT: Self = CompositeAlphaFlagsKHR(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); @@ -13257,7 +13171,7 @@ pub mod bitflags { pub const HORIZONTAL_MIRROR_ROTATE_270: Self = SurfaceTransformFlagsKHR(0b10000000); pub const INHERIT: Self = SurfaceTransformFlagsKHR(0b100000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DebugReportFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); @@ -13268,7 +13182,7 @@ pub mod bitflags { pub const ERROR: Self = DebugReportFlagsEXT(0b1000); pub const DEBUG: Self = DebugReportFlagsEXT(0b10000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); @@ -13282,7 +13196,7 @@ pub mod bitflags { pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV: Self = ExternalMemoryHandleTypeFlagsNV(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); @@ -13292,7 +13206,7 @@ pub mod bitflags { pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10); pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SubgroupFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); @@ -13314,7 +13228,7 @@ pub mod bitflags { #[doc = "Quad subgroup operations"] pub const QUAD: Self = SubgroupFeatureFlags(0b10000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct IndirectCommandsLayoutUsageFlagsNVX(pub(crate) Flags); vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); @@ -13324,7 +13238,7 @@ pub mod bitflags { pub const EMPTY_EXECUTIONS: Self = IndirectCommandsLayoutUsageFlagsNVX(0b100); pub const INDEXED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ObjectEntryUsageFlagsNVX(pub(crate) Flags); vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); @@ -13332,12 +13246,12 @@ pub mod bitflags { pub const GRAPHICS: Self = ObjectEntryUsageFlagsNVX(0b1); pub const COMPUTE: Self = ObjectEntryUsageFlagsNVX(0b10); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); impl DescriptorSetLayoutCreateFlags {} - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); @@ -13356,7 +13270,7 @@ pub mod bitflags { pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: Self = ExternalMemoryHandleTypeFlags(0b1000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); @@ -13365,7 +13279,7 @@ pub mod bitflags { pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10); pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); @@ -13381,7 +13295,7 @@ pub mod bitflags { pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: Self = ExternalSemaphoreHandleTypeFlags(0b10000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); @@ -13389,14 +13303,14 @@ pub mod bitflags { pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1); pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SemaphoreImportFlags(pub(crate) Flags); vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); impl SemaphoreImportFlags { pub const TEMPORARY: Self = SemaphoreImportFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); @@ -13408,7 +13322,7 @@ pub mod bitflags { ExternalFenceHandleTypeFlags(0b100); pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ExternalFenceFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); @@ -13416,21 +13330,21 @@ pub mod bitflags { pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1); pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct FenceImportFlags(pub(crate) Flags); vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); impl FenceImportFlags { pub const TEMPORARY: Self = FenceImportFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); impl SurfaceCounterFlagsEXT { pub const VBLANK: Self = SurfaceCounterFlagsEXT(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct PeerMemoryFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); @@ -13444,7 +13358,7 @@ pub mod bitflags { #[doc = "Can write with and access type/command"] pub const GENERIC_DST: Self = PeerMemoryFeatureFlags(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct MemoryAllocateFlags(pub(crate) Flags); vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); @@ -13452,7 +13366,7 @@ pub mod bitflags { #[doc = "Force allocation on specific devices"] pub const DEVICE_MASK: Self = MemoryAllocateFlags(0b1); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); @@ -13466,17 +13380,17 @@ pub mod bitflags { #[doc = "Each physical device presents from local memory"] pub const LOCAL_MULTI_DEVICE: Self = DeviceGroupPresentModeFlagsKHR(0b1000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); impl SwapchainCreateFlagsKHR {} - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SubpassDescriptionFlags(pub(crate) Flags); vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); impl SubpassDescriptionFlags {} - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); @@ -13486,7 +13400,7 @@ pub mod bitflags { pub const WARNING: Self = DebugUtilsMessageSeverityFlagsEXT(0b100000000); pub const ERROR: Self = DebugUtilsMessageSeverityFlagsEXT(0b1000000000000); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); @@ -13495,7 +13409,7 @@ pub mod bitflags { pub const VALIDATION: Self = DebugUtilsMessageTypeFlagsEXT(0b10); pub const PERFORMANCE: Self = DebugUtilsMessageTypeFlagsEXT(0b100); } - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DescriptorBindingFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); @@ -13569,12 +13483,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: self - .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: + self.get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: self - .get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: + self.get_physical_device_surface_present_modes_khr, } } } @@ -13723,12 +13637,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -14035,10 +13949,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: self - .get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: self - .get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: + self.get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: + self.get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14321,8 +14235,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: self - .get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: + self.get_physical_device_xlib_presentation_support_khr, } } } @@ -14407,8 +14321,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: self - .get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: + self.get_physical_device_xcb_presentation_support_khr, } } } @@ -14493,8 +14407,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: self - .get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: + self.get_physical_device_wayland_presentation_support_khr, } } } @@ -14576,8 +14490,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: self - .get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: + self.get_physical_device_mir_presentation_support_khr, } } } @@ -14712,8 +14626,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: self - .get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: + self.get_physical_device_win32_presentation_support_khr, } } } @@ -16279,8 +16193,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: self - .get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: + self.get_physical_device_external_image_format_properties_nv, } } } @@ -16473,12 +16387,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17290,8 +17204,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17477,8 +17391,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17592,8 +17506,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: self - .get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: + self.get_physical_device_generated_commands_properties_nvx, } } } @@ -18033,8 +17947,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: self - .get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: + self.get_physical_device_surface_capabilities2_ext, } } } @@ -19185,8 +19099,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: self - .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: + self.get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19317,10 +19231,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: self - .get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: self - .get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: + self.get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: + self.get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -19956,10 +19870,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: self - .get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: self - .get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: + self.get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: + self.get_memory_android_hardware_buffer_android, } } } @@ -20360,8 +20274,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: self - .get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: + self.get_physical_device_multisample_properties_ext, } } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index a071bf9..4e37ab2 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -38,7 +38,7 @@ impl CType { } } -named!(ctype<&str, CType>, +named!(ctype<&str, CType>, alt!( tag!("ULL") => { |_| CType::U64 } | tag!("U") => { |_| CType::U32 } @@ -55,12 +55,12 @@ named!(inverse_number<&str, (CType, String)>, do_parse!( tag!("(")>> tag!("~") >> - s: take_while1!(|c: char| c.is_digit(10)) >> + s: take_while1!(|c: char| c.is_digit(10)) >> ctype: ctype >> minus_num: opt!( do_parse!( tag!("-") >> - n: take_while1!(|c: char| c.is_digit(10)) >> + n: take_while1!(|c: char| c.is_digit(10)) >> (n) ) ) >> @@ -88,7 +88,7 @@ pub fn define_handle_macro() -> Tokens { macro_rules! define_handle{ ($name: ident) => { #[derive(Clone, Copy, Debug)] - #[repr(C)] + #[repr(transparent)] pub struct $name{ ptr: *mut u8 } @@ -117,7 +117,7 @@ pub fn handle_nondispatchable_macro() -> Tokens { quote!{ macro_rules! handle_nondispatchable { ($name: ident) => { - #[repr(C)] + #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name (uint64_t); @@ -525,8 +525,7 @@ impl CommandExt for vkxml::Command { .map(|field| match field.basetype.as_str() { "VkDevice" | "VkCommandBuffer" | "VkQueue" => true, _ => false, - }) - .unwrap_or(false); + }).unwrap_or(false); match self.name.as_str() { "vkGetInstanceProcAddr" => FunctionType::Static, "vkCreateInstance" @@ -637,7 +636,7 @@ impl FieldExt for vkxml::Field { .as_ref() .or_else(|| self.size_enumref.as_ref()) .expect("Should have size"); - // Make sure we also rename the constant, that is + // Make sure we also rename the constant, that is // used inside the static array let size = constant_name(size); let size = Term::intern(&size); @@ -674,11 +673,9 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo let name = field.param_ident(); let ty = field.type_tokens(); (name, ty) - }) - .collect(); + }).collect(); params - }) - .collect(); + }).collect(); let params_names: Vec> = params .iter() @@ -687,8 +684,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo .iter() .map(|&(param_name, _)| param_name) .collect() - }) - .collect(); + }).collect(); let param_names_ref = ¶ms_names; let expanded_params: Vec<_> = params .iter() @@ -699,8 +695,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo quote!{ #(#inner_params_iter,)* } - }) - .collect(); + }).collect(); let expanded_params_ref = &expanded_params; let return_types: Vec<_> = commands @@ -787,8 +782,7 @@ pub fn generate_extension_constants<'a>( .filter_map(|item| match item { vk_parse::ExtensionItem::Require { items, .. } => Some(items.iter()), _ => None, - }) - .flat_map(|iter| iter); + }).flat_map(|iter| iter); let enum_tokens = items.filter_map(|item| match item { vk_parse::InterfaceItem::Enum(_enum) => { use vk_parse::EnumSpec; @@ -853,8 +847,7 @@ pub fn generate_extension_commands( })) } _ => None, - }) - .flat_map(|iter| iter) + }).flat_map(|iter| iter) .collect_vec(); let name = format!("{}Fn", extension_name.to_camel_case()); let ident = Ident::from(&name[2..]); @@ -904,7 +897,7 @@ pub fn generate_bitmask(bitmask: &vkxml::Bitmask) -> Option { let name = &bitmask.name[2..]; let ident = Ident::from(name); Some(quote!{ - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct #ident(Flags); vk_bitflags_wrapped!(#ident, 0b0, Flags); @@ -958,8 +951,7 @@ pub fn bitflags_impl_block( let variant_ident = constant.variant_ident(enum_name); let tokens = constant.to_tokens(); (variant_ident, tokens) - }) - .collect_vec(); + }).collect_vec(); let notations = constants.iter().map(|constant| { constant.notation().map(|n| { @@ -969,14 +961,16 @@ pub fn bitflags_impl_block( }) }); - let variants = variants.iter().zip(notations.clone()).map( - |((variant_ident, value), ref notation)| { - quote!{ - #notation - pub const #variant_ident: Self = #ident(#value); - } - }, - ); + let variants = + variants + .iter() + .zip(notations.clone()) + .map(|((variant_ident, value), ref notation)| { + quote!{ + #notation + pub const #variant_ident: Self = #ident(#value); + } + }); quote!{ impl #ident { #(#variants)* @@ -997,8 +991,7 @@ pub fn generate_enum<'a>( .filter_map(|elem| match *elem { vkxml::EnumerationElement::Enum(ref constant) => Some(constant), _ => None, - }) - .collect_vec(); + }).collect_vec(); for constant in &constants { const_cache.insert(constant.name.as_str()); } @@ -1013,7 +1006,7 @@ pub fn generate_enum<'a>( let impl_bitflags = bitflags_impl_block(ident, &_enum.name, &constants); let q = quote!{ - #[repr(C)] + #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct #ident(pub(crate) Flags); vk_bitflags_wrapped!(#ident, #all_bits_term, Flags); @@ -1024,7 +1017,7 @@ pub fn generate_enum<'a>( let impl_block = bitflags_impl_block(ident, &_enum.name, &constants); let enum_quote = quote!{ #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] - #[repr(C)] + #[repr(transparent)] pub struct #ident(pub(crate) i32); #impl_block }; @@ -1087,8 +1080,7 @@ fn is_static_array(field: &vkxml::Field) -> bool { .map(|ty| match ty { vkxml::ArrayType::Static => true, _ => false, - }) - .unwrap_or(false) + }).unwrap_or(false) } pub fn derive_default(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Option { let name = name_to_tokens(&_struct.name); @@ -1344,13 +1336,11 @@ pub fn generate_feature(feature: &vkxml::Feature, commands: &CommandMap) -> quot } else { None } - }) - .collect() + }).collect() } else { vec![] } - }) - .filter_map(|cmd_ref| commands.get(&cmd_ref.name)) + }).filter_map(|cmd_ref| commands.get(&cmd_ref.name)) .fold( (Vec::new(), Vec::new(), Vec::new(), Vec::new()), |mut acc, &cmd_ref| { @@ -1440,8 +1430,7 @@ pub fn write_source_code(path: &Path) { .filter_map(|item| match item { vk_parse::RegistryItem::Extensions { items: ext, .. } => Some(ext), _ => None, - }) - .nth(0) + }).nth(0) .expect("extension"); let spec = vk_parse::parse_file_as_vkxml(path); @@ -1451,8 +1440,7 @@ pub fn write_source_code(path: &Path) { .filter_map(|elem| match elem { vkxml::RegistryElement::Commands(ref cmds) => Some(cmds), _ => None, - }) - .flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) + }).flat_map(|cmds| cmds.elements.iter().map(|cmd| (cmd.name.clone(), cmd))) .collect(); let features: Vec<&vkxml::Feature> = spec @@ -1461,8 +1449,7 @@ pub fn write_source_code(path: &Path) { .filter_map(|elem| match elem { vkxml::RegistryElement::Features(ref features) => Some(features), _ => None, - }) - .flat_map(|features| features.elements.iter()) + }).flat_map(|features| features.elements.iter()) .collect(); let definitions: Vec<&vkxml::DefinitionsElement> = spec @@ -1471,8 +1458,7 @@ pub fn write_source_code(path: &Path) { .filter_map(|elem| match elem { vkxml::RegistryElement::Definitions(ref definitions) => Some(definitions), _ => None, - }) - .flat_map(|definitions| definitions.elements.iter()) + }).flat_map(|definitions| definitions.elements.iter()) .collect(); let enums: Vec<&vkxml::Enumeration> = spec @@ -1481,14 +1467,12 @@ pub fn write_source_code(path: &Path) { .filter_map(|elem| match elem { vkxml::RegistryElement::Enums(ref enums) => Some(enums), _ => None, - }) - .flat_map(|enums| { + }).flat_map(|enums| { enums.elements.iter().filter_map(|_enum| match *_enum { vkxml::EnumsElement::Enumeration(ref e) => Some(e), _ => None, }) - }) - .collect(); + }).collect(); let constants: Vec<&vkxml::Constant> = spec .elements @@ -1496,8 +1480,7 @@ pub fn write_source_code(path: &Path) { .filter_map(|elem| match elem { vkxml::RegistryElement::Constants(ref constants) => Some(constants), _ => None, - }) - .flat_map(|constants| constants.elements.iter()) + }).flat_map(|constants| constants.elements.iter()) .collect(); let mut const_cache = HashSet::new(); @@ -1525,8 +1508,7 @@ pub fn write_source_code(path: &Path) { .filter_map(|def| match def { vkxml::DefinitionsElement::Union(ref union) => Some(union.name.as_str()), _ => None, - }) - .collect::>(); + }).collect::>(); let definition_code: Vec<_> = definitions .into_iter() From 59d49b2159ea14e1e5e8b10a2c0729d8261c8ab0 Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 12:37:28 +0200 Subject: [PATCH 063/122] Apply rustfmt --- ash/src/device.rs | 158 +++++++++++++++++++++++++++++--------------- ash/src/instance.rs | 71 +++++++++++--------- 2 files changed, 144 insertions(+), 85 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index 03d4411..cd2b69b 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -18,7 +18,7 @@ pub trait DeviceV1_1: DeviceV1_0 { ); match err_code { vk::Result::SUCCESS => Ok(()), - _ => Err(err_code) + _ => Err(err_code), } } @@ -30,13 +30,16 @@ pub trait DeviceV1_1: DeviceV1_0 { ); match err_code { vk::Result::SUCCESS => Ok(()), - _ => Err(err_code) + _ => Err(err_code), } } - fn get_device_group_peer_memory_features(&self, heap_index: vk::uint32_t, - local_device_index: vk::uint32_t, - remote_device_index: vk::uint32_t) -> vk::PeerMemoryFeatureFlags { + fn get_device_group_peer_memory_features( + &self, + heap_index: vk::uint32_t, + local_device_index: vk::uint32_t, + remote_device_index: vk::uint32_t, + ) -> vk::PeerMemoryFeatureFlags { unsafe { let mut peer_memory_features = mem::uninitialized(); self.fp_v1_1().get_device_group_peer_memory_features( @@ -50,20 +53,25 @@ pub trait DeviceV1_1: DeviceV1_0 { } } - unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: vk::uint32_t) { - self.fp_v1_1().cmd_set_device_mask( - command_buffer, - device_mask - ); + unsafe fn cmd_set_device_mask( + &self, + command_buffer: vk::CommandBuffer, + device_mask: vk::uint32_t, + ) { + self.fp_v1_1() + .cmd_set_device_mask(command_buffer, device_mask); } - unsafe fn cmd_dispatch_base(&self, command_buffer: vk::CommandBuffer, - base_group_x: vk::uint32_t, - base_group_y: vk::uint32_t, - base_group_z: vk::uint32_t, - group_count_x: vk::uint32_t, - group_count_y: vk::uint32_t, - group_count_z: vk::uint32_t,) { + unsafe fn cmd_dispatch_base( + &self, + command_buffer: vk::CommandBuffer, + base_group_x: vk::uint32_t, + base_group_y: vk::uint32_t, + base_group_z: vk::uint32_t, + group_count_x: vk::uint32_t, + group_count_y: vk::uint32_t, + group_count_z: vk::uint32_t, + ) { self.fp_v1_1().cmd_dispatch_base( command_buffer, base_group_x, @@ -75,7 +83,10 @@ pub trait DeviceV1_1: DeviceV1_0 { ); } - unsafe fn get_image_memory_requirements2(&self, info: &vk::ImageMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + unsafe fn get_image_memory_requirements2( + &self, + info: &vk::ImageMemoryRequirementsInfo2, + ) -> vk::MemoryRequirements2 { let mut image_memory_requirements = mem::uninitialized(); self.fp_v1_1().get_image_memory_requirements2( self.handle(), @@ -85,7 +96,10 @@ pub trait DeviceV1_1: DeviceV1_0 { image_memory_requirements } - unsafe fn get_buffer_memory_requirements2(&self, info: &vk::BufferMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + unsafe fn get_buffer_memory_requirements2( + &self, + info: &vk::BufferMemoryRequirementsInfo2, + ) -> vk::MemoryRequirements2 { let mut image_memory_requirements = mem::uninitialized(); self.fp_v1_1().get_buffer_memory_requirements2( self.handle(), @@ -95,10 +109,17 @@ pub trait DeviceV1_1: DeviceV1_0 { image_memory_requirements } - unsafe fn get_image_sparse_memory_requirements2(&self, info: &vk::ImageSparseMemoryRequirementsInfo2) -> Vec { + unsafe fn get_image_sparse_memory_requirements2( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2, + ) -> Vec { let mut count = mem::uninitialized(); - self.fp_v1_1() - .get_image_sparse_memory_requirements2(self.handle(), info, &mut count, ptr::null_mut()); + self.fp_v1_1().get_image_sparse_memory_requirements2( + self.handle(), + info, + &mut count, + ptr::null_mut(), + ); let mut requirements = Vec::with_capacity(count as usize); self.fp_v1_1().get_image_sparse_memory_requirements2( self.handle(), @@ -110,68 +131,99 @@ pub trait DeviceV1_1: DeviceV1_0 { requirements } - unsafe fn trim_command_pool(&self, command_pool: vk::CommandPool, flags: vk::CommandPoolTrimFlags) { - self.fp_v1_1().trim_command_pool( - self.handle(), - command_pool, - flags - ); + unsafe fn trim_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolTrimFlags, + ) { + self.fp_v1_1() + .trim_command_pool(self.handle(), command_pool, flags); } - unsafe fn create_sampler_ycbcr_conversion(&self, - create_info: &vk::SamplerYcbcrConversionCreateInfo, - allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + unsafe fn create_sampler_ycbcr_conversion( + &self, + create_info: &vk::SamplerYcbcrConversionCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { let mut ycbcr_conversion = mem::uninitialized(); let err_code = self.fp_v1_1().create_sampler_ycbcr_conversion( self.handle(), create_info, allocation_callbacks.as_raw_ptr(), - &mut ycbcr_conversion + &mut ycbcr_conversion, ); match err_code { vk::Result::SUCCESS => Ok(ycbcr_conversion), - _ => Err(err_code) + _ => Err(err_code), } } - unsafe fn destroy_sampler_ycbcr_conversion(&self, - ycbcr_conversion: vk::SamplerYcbcrConversion, - allocation_callbacks: Option<&vk::AllocationCallbacks>) { - self.fp_v1_1().destroy_sampler_ycbcr_conversion(self.handle(), ycbcr_conversion, allocation_callbacks.as_raw_ptr()); + unsafe fn destroy_sampler_ycbcr_conversion( + &self, + ycbcr_conversion: vk::SamplerYcbcrConversion, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + self.fp_v1_1().destroy_sampler_ycbcr_conversion( + self.handle(), + ycbcr_conversion, + allocation_callbacks.as_raw_ptr(), + ); } - unsafe fn create_descriptor_update_template(&self, - create_info: &vk::DescriptorUpdateTemplateCreateInfo, - allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + unsafe fn create_descriptor_update_template( + &self, + create_info: &vk::DescriptorUpdateTemplateCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { let mut descriptor_update_template = mem::uninitialized(); let err_code = self.fp_v1_1().create_descriptor_update_template( self.handle(), create_info, allocation_callbacks.as_raw_ptr(), - &mut descriptor_update_template + &mut descriptor_update_template, ); match err_code { vk::Result::SUCCESS => Ok(descriptor_update_template), - _ => Err(err_code) + _ => Err(err_code), } } - unsafe fn destroy_descriptor_update_template(&self, - descriptor_update_template: vk::DescriptorUpdateTemplate, - allocation_callbacks: Option<&vk::AllocationCallbacks>) { - self.fp_v1_1().destroy_descriptor_update_template(self.handle(), descriptor_update_template, allocation_callbacks.as_raw_ptr()); + unsafe fn destroy_descriptor_update_template( + &self, + descriptor_update_template: vk::DescriptorUpdateTemplate, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + self.fp_v1_1().destroy_descriptor_update_template( + self.handle(), + descriptor_update_template, + allocation_callbacks.as_raw_ptr(), + ); } - unsafe fn update_descriptor_set_with_template(&self, - descriptor_set: vk::DescriptorSet, - descriptor_update_template: vk::DescriptorUpdateTemplate, - data: *const vk::c_void) { - self.fp_v1_1().update_descriptor_set_with_template(self.handle(), descriptor_set, descriptor_update_template, data); + unsafe fn update_descriptor_set_with_template( + &self, + descriptor_set: vk::DescriptorSet, + descriptor_update_template: vk::DescriptorUpdateTemplate, + data: *const vk::c_void, + ) { + self.fp_v1_1().update_descriptor_set_with_template( + self.handle(), + descriptor_set, + descriptor_update_template, + data, + ); } - unsafe fn get_descriptor_set_layout_support(&self, create_info: &vk::DescriptorSetLayoutCreateInfo) -> vk::DescriptorSetLayoutSupport { + unsafe fn get_descriptor_set_layout_support( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + ) -> vk::DescriptorSetLayoutSupport { let mut descriptor_set_layout_support = mem::uninitialized(); - self.fp_v1_1().get_descriptor_set_layout_support(self.handle(), create_info, &mut descriptor_set_layout_support); + self.fp_v1_1().get_descriptor_set_layout_support( + self.handle(), + create_info, + &mut descriptor_set_layout_support, + ); descriptor_set_layout_support } } diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 97565dd..5d1c811 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -88,19 +88,21 @@ pub trait InstanceV1_1: InstanceV1_0 { unsafe fn enumerate_instance_version(&self) -> VkResult { let mut api_version = mem::uninitialized(); - let err_code = self.fp_v1_1() - .enumerate_instance_version(&mut api_version); + let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version); match err_code { vk::Result::SUCCESS => Ok(api_version), - _ => Err(err_code) + _ => Err(err_code), } } fn enumerate_physical_device_groups(&self) -> VkResult> { unsafe { let mut group_count = mem::uninitialized(); - self.fp_v1_1() - .enumerate_physical_device_groups(self.handle(), &mut group_count, ptr::null_mut()); + self.fp_v1_1().enumerate_physical_device_groups( + self.handle(), + &mut group_count, + ptr::null_mut(), + ); let mut physical_device_groups = Vec::with_capacity(group_count as usize); let err_code = self.fp_v1_1().enumerate_physical_device_groups( self.handle(), @@ -204,19 +206,21 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> Vec { unsafe { let mut format_count = 0; - self.fp_v1_1().get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - ptr::null_mut(), - ); + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); let mut format_prop = Vec::with_capacity(format_count as usize); - self.fp_v1_1().get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - format_prop.as_mut_ptr(), - ); + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + format_prop.as_mut_ptr(), + ); format_prop.set_len(format_count as usize); format_prop } @@ -229,11 +233,12 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> vk::ExternalBufferProperties { unsafe { let mut image_format_prop = mem::uninitialized(); - self.fp_v1_1().get_physical_device_external_buffer_properties( - physical_device, - external_buffer_info, - &mut image_format_prop, - ); + self.fp_v1_1() + .get_physical_device_external_buffer_properties( + physical_device, + external_buffer_info, + &mut image_format_prop, + ); image_format_prop } } @@ -245,11 +250,12 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> vk::ExternalFenceProperties { unsafe { let mut fence_prop = mem::uninitialized(); - self.fp_v1_1().get_physical_device_external_fence_properties( - physical_device, - external_fence_info, - &mut fence_prop, - ); + self.fp_v1_1() + .get_physical_device_external_fence_properties( + physical_device, + external_fence_info, + &mut fence_prop, + ); fence_prop } } @@ -261,11 +267,12 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> vk::ExternalSemaphoreProperties { unsafe { let mut semaphore_prop = mem::uninitialized(); - self.fp_v1_1().get_physical_device_external_semaphore_properties( - physical_device, - external_semaphore_info, - &mut semaphore_prop, - ); + self.fp_v1_1() + .get_physical_device_external_semaphore_properties( + physical_device, + external_semaphore_info, + &mut semaphore_prop, + ); semaphore_prop } } From cda39148e98a14c369130f99e4e5dc022a072af1 Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 12:51:03 +0200 Subject: [PATCH 064/122] Mark some more functions as unsafe --- ash/src/device.rs | 22 ++++---- ash/src/instance.rs | 124 ++++++++++++++++++++------------------------ 2 files changed, 67 insertions(+), 79 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index cd2b69b..960fe20 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -34,23 +34,21 @@ pub trait DeviceV1_1: DeviceV1_0 { } } - fn get_device_group_peer_memory_features( + unsafe fn get_device_group_peer_memory_features( &self, heap_index: vk::uint32_t, local_device_index: vk::uint32_t, remote_device_index: vk::uint32_t, ) -> vk::PeerMemoryFeatureFlags { - unsafe { - let mut peer_memory_features = mem::uninitialized(); - self.fp_v1_1().get_device_group_peer_memory_features( - self.handle(), - heap_index, - local_device_index, - remote_device_index, - &mut peer_memory_features, - ); - peer_memory_features - } + let mut peer_memory_features = mem::uninitialized(); + self.fp_v1_1().get_device_group_peer_memory_features( + self.handle(), + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features } unsafe fn cmd_set_device_mask( diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 5d1c811..151b6c5 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -145,23 +145,21 @@ pub trait InstanceV1_1: InstanceV1_0 { } } - fn get_physical_device_image_format_properties2( + unsafe fn get_physical_device_image_format_properties2( &self, physical_device: vk::PhysicalDevice, format_info: &vk::PhysicalDeviceImageFormatInfo2, ) -> VkResult { - unsafe { - let mut image_format_prop = mem::uninitialized(); - let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( - physical_device, - format_info, - &mut image_format_prop, - ); - if err_code == vk::Result::SUCCESS { - Ok(image_format_prop) - } else { - Err(err_code) - } + let mut image_format_prop = mem::uninitialized(); + let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( + physical_device, + format_info, + &mut image_format_prop, + ); + if err_code == vk::Result::SUCCESS { + Ok(image_format_prop) + } else { + Err(err_code) } } @@ -199,82 +197,74 @@ pub trait InstanceV1_1: InstanceV1_0 { } } - fn get_physical_device_sparse_image_format_properties2( + unsafe fn get_physical_device_sparse_image_format_properties2( &self, physical_device: vk::PhysicalDevice, format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, ) -> Vec { - unsafe { - let mut format_count = 0; - self.fp_v1_1() - .get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - ptr::null_mut(), - ); - let mut format_prop = Vec::with_capacity(format_count as usize); - self.fp_v1_1() - .get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - format_prop.as_mut_ptr(), - ); - format_prop.set_len(format_count as usize); - format_prop - } + let mut format_count = 0; + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); + let mut format_prop = Vec::with_capacity(format_count as usize); + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + format_prop.as_mut_ptr(), + ); + format_prop.set_len(format_count as usize); + format_prop } - fn get_physical_device_external_buffer_properties( + unsafe fn get_physical_device_external_buffer_properties( &self, physical_device: vk::PhysicalDevice, external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo, ) -> vk::ExternalBufferProperties { - unsafe { - let mut image_format_prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_external_buffer_properties( - physical_device, - external_buffer_info, - &mut image_format_prop, - ); - image_format_prop - } + let mut image_format_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_external_buffer_properties( + physical_device, + external_buffer_info, + &mut image_format_prop, + ); + image_format_prop } - fn get_physical_device_external_fence_properties( + unsafe fn get_physical_device_external_fence_properties( &self, physical_device: vk::PhysicalDevice, external_fence_info: &vk::PhysicalDeviceExternalFenceInfo, ) -> vk::ExternalFenceProperties { - unsafe { - let mut fence_prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_external_fence_properties( - physical_device, - external_fence_info, - &mut fence_prop, - ); - fence_prop - } + let mut fence_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_external_fence_properties( + physical_device, + external_fence_info, + &mut fence_prop, + ); + fence_prop } - fn get_physical_device_external_semaphore_properties( + unsafe fn get_physical_device_external_semaphore_properties( &self, physical_device: vk::PhysicalDevice, external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo, ) -> vk::ExternalSemaphoreProperties { - unsafe { - let mut semaphore_prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_external_semaphore_properties( - physical_device, - external_semaphore_info, - &mut semaphore_prop, - ); - semaphore_prop - } + let mut semaphore_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_external_semaphore_properties( + physical_device, + external_semaphore_info, + &mut semaphore_prop, + ); + semaphore_prop } } From 92d0541170f4bce65d47ffbae133292685129bf1 Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 15:39:25 +0200 Subject: [PATCH 065/122] Change type of `TRUE` and `FALSE` to `Bool32` --- ash/src/vk.rs | 4 ++-- generator/src/lib.rs | 9 ++++++++- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index f80ddb6..ab4b2e0 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -13432,8 +13432,8 @@ pub const REMAINING_MIP_LEVELS: u32 = !0; pub const REMAINING_ARRAY_LAYERS: u32 = !0; pub const WHOLE_SIZE: u64 = !0; pub const ATTACHMENT_UNUSED: u32 = !0; -pub const TRUE: usize = 1; -pub const FALSE: usize = 0; +pub const TRUE: Bool32 = 1; +pub const FALSE: Bool32 = 0; pub const QUEUE_FAMILY_IGNORED: u32 = !0; pub const QUEUE_FAMILY_EXTERNAL: u32 = !0 - 1; pub const QUEUE_FAMILY_FOREIGN_EXT: u32 = !0 - 2; diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 4e37ab2..63b9438 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -24,6 +24,7 @@ pub enum CType { U32, U64, Float, + Bool32, } impl CType { @@ -33,6 +34,7 @@ impl CType { CType::U32 => Term::intern("u32"), CType::U64 => Term::intern("u64"), CType::Float => Term::intern("f32"), + CType::Bool32 => Term::intern("Bool32"), }; quote!{#term} } @@ -1399,7 +1401,12 @@ pub fn generate_constant<'a>( let name = constant_name(&constant.name); let ident = Ident::from(name.as_str()); let value = c.to_tokens(); - let ty = c.ty().to_tokens(); + let ty = if name == "TRUE" || name == "FALSE" { + CType::Bool32 + } else { + c.ty() + }; + let ty = ty.to_tokens(); quote!{ pub const #ident: #ty = #value; } From 6e54dd346e4b9b001ffe8b065ddd216c46ca49d0 Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Wed, 1 Aug 2018 17:32:16 -0700 Subject: [PATCH 066/122] Introduce Handle trait --- ash/src/vk.rs | 517 ++++++++++++++++++++++++++----------------- generator/src/lib.rs | 43 ++-- 2 files changed, 341 insertions(+), 219 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index ab4b2e0..fd6c575 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -4,27 +4,32 @@ pub use self::bitflags::*; pub use self::extensions::*; #[doc(hidden)] pub use libc::*; +pub trait Handle { + const TYPE: ObjectType; + fn as_raw(self) -> u64; + fn from_raw(u64) -> Self; +} #[macro_export] macro_rules! vk_make_version { - ( $ major : expr , $ minor : expr , $ patch : expr ) => { + ($major:expr, $minor:expr, $patch:expr) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ( $ major : expr ) => { + ($major:expr) => { ($major as uint32_t) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ( $ minor : expr ) => { + ($minor:expr) => { (($minor as uint32_t) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ( $ minor : expr ) => { + ($minor:expr) => { ($minor as uint32_t) & 0xfff }; } @@ -55,7 +60,7 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ( $ name : ident , $ all : expr , $ flag_type : ty ) => { + ($name:ident, $all:expr, $flag_type:ty) => { impl Default for $name { fn default() -> $name { $name(0) @@ -174,10 +179,19 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ( $ name : ident ) => { + ($name:ident, $ty:ident) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(uint64_t); + impl Handle for $name { + const TYPE: ObjectType = ObjectType::$ty; + fn as_raw(self) -> u64 { + self.0 as u64 + } + fn from_raw(x: u64) -> Self { + $name(x as _) + } + } impl $name { pub fn null() -> $name { $name(0) @@ -202,24 +216,29 @@ macro_rules! handle_nondispatchable { }; } macro_rules! define_handle { - ( $ name : ident ) => { - #[derive(Clone, Copy, Debug)] + ($name:ident, $ty:ident) => { #[repr(transparent)] - pub struct $name { - ptr: *mut u8, - } + #[derive(Clone, Copy, Debug)] + pub struct $name(*mut u8); impl Default for $name { fn default() -> $name { $name::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 { + $name(x as _) + } + } unsafe impl Send for $name {} unsafe impl Sync for $name {} impl $name { pub fn null() -> Self { - $name { - ptr: ::std::ptr::null_mut(), - } + $name(::std::ptr::null_mut()) } } }; @@ -444,18 +463,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: - self.get_physical_device_image_format_properties, + get_physical_device_image_format_properties: self + .get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: - self.get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: self + .get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: - self.get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: self + .get_physical_device_sparse_image_format_properties, } } } @@ -3922,19 +3941,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: - self.get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: - self.get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: self + .get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: self + .get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: - self.get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: - self.get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: - self.get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: - self.get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: self + .get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: self + .get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: self + .get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: self + .get_physical_device_external_semaphore_properties, } } } @@ -4821,42 +4840,42 @@ vk_bitflags_wrapped!( 0b0, Flags ); -define_handle!(Instance); -define_handle!(PhysicalDevice); -define_handle!(Device); -define_handle!(Queue); -define_handle!(CommandBuffer); -handle_nondispatchable!(DeviceMemory); -handle_nondispatchable!(CommandPool); -handle_nondispatchable!(Buffer); -handle_nondispatchable!(BufferView); -handle_nondispatchable!(Image); -handle_nondispatchable!(ImageView); -handle_nondispatchable!(ShaderModule); -handle_nondispatchable!(Pipeline); -handle_nondispatchable!(PipelineLayout); -handle_nondispatchable!(Sampler); -handle_nondispatchable!(DescriptorSet); -handle_nondispatchable!(DescriptorSetLayout); -handle_nondispatchable!(DescriptorPool); -handle_nondispatchable!(Fence); -handle_nondispatchable!(Semaphore); -handle_nondispatchable!(Event); -handle_nondispatchable!(QueryPool); -handle_nondispatchable!(Framebuffer); -handle_nondispatchable!(RenderPass); -handle_nondispatchable!(PipelineCache); -handle_nondispatchable!(ObjectTableNVX); -handle_nondispatchable!(IndirectCommandsLayoutNVX); -handle_nondispatchable!(DescriptorUpdateTemplate); -handle_nondispatchable!(SamplerYcbcrConversion); -handle_nondispatchable!(ValidationCacheEXT); -handle_nondispatchable!(DisplayKHR); -handle_nondispatchable!(DisplayModeKHR); -handle_nondispatchable!(SurfaceKHR); -handle_nondispatchable!(SwapchainKHR); -handle_nondispatchable!(DebugReportCallbackEXT); -handle_nondispatchable!(DebugUtilsMessengerEXT); +define_handle!(Instance, INSTANCE); +define_handle!(PhysicalDevice, PHYSICAL_DEVICE); +define_handle!(Device, DEVICE); +define_handle!(Queue, QUEUE); +define_handle!(CommandBuffer, COMMAND_BUFFER); +handle_nondispatchable!(DeviceMemory, DEVICE_MEMORY); +handle_nondispatchable!(CommandPool, COMMAND_POOL); +handle_nondispatchable!(Buffer, BUFFER); +handle_nondispatchable!(BufferView, BUFFER_VIEW); +handle_nondispatchable!(Image, IMAGE); +handle_nondispatchable!(ImageView, IMAGE_VIEW); +handle_nondispatchable!(ShaderModule, SHADER_MODULE); +handle_nondispatchable!(Pipeline, PIPELINE); +handle_nondispatchable!(PipelineLayout, PIPELINE_LAYOUT); +handle_nondispatchable!(Sampler, SAMPLER); +handle_nondispatchable!(DescriptorSet, DESCRIPTOR_SET); +handle_nondispatchable!(DescriptorSetLayout, DESCRIPTOR_SET_LAYOUT); +handle_nondispatchable!(DescriptorPool, DESCRIPTOR_POOL); +handle_nondispatchable!(Fence, FENCE); +handle_nondispatchable!(Semaphore, SEMAPHORE); +handle_nondispatchable!(Event, EVENT); +handle_nondispatchable!(QueryPool, QUERY_POOL); +handle_nondispatchable!(Framebuffer, FRAMEBUFFER); +handle_nondispatchable!(RenderPass, RENDER_PASS); +handle_nondispatchable!(PipelineCache, PIPELINE_CACHE); +handle_nondispatchable!(ObjectTableNVX, OBJECT_TABLE_NVX); +handle_nondispatchable!(IndirectCommandsLayoutNVX, INDIRECT_COMMANDS_LAYOUT_NVX); +handle_nondispatchable!(DescriptorUpdateTemplate, DESCRIPTOR_UPDATE_TEMPLATE); +handle_nondispatchable!(SamplerYcbcrConversion, SAMPLER_YCBCR_CONVERSION); +handle_nondispatchable!(ValidationCacheEXT, VALIDATION_CACHE_EXT); +handle_nondispatchable!(DisplayKHR, DISPLAY_KHR); +handle_nondispatchable!(DisplayModeKHR, DISPLAY_MODE_KHR); +handle_nondispatchable!(SurfaceKHR, SURFACE_KHR); +handle_nondispatchable!(SwapchainKHR, SWAPCHAIN_KHR); +handle_nondispatchable!(DebugReportCallbackEXT, DEBUG_REPORT_CALLBACK_EXT); +handle_nondispatchable!(DebugUtilsMessengerEXT, DEBUG_UTILS_MESSENGER_EXT); #[allow(non_camel_case_types)] pub type PFN_vkInternalAllocationNotification = unsafe extern "system" fn( @@ -5023,9 +5042,11 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }).field("pipeline_cache_uuid", &unsafe { + }) + .field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }).field("limits", &self.limits) + }) + .field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5056,7 +5077,8 @@ impl ::std::fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .finish() } } @@ -5081,11 +5103,13 @@ impl ::std::fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for LayerProperties { @@ -5142,7 +5166,8 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ) + .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5258,10 +5283,12 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }).field("memory_heap_count", &self.memory_heap_count) + }) + .field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5791,10 +5818,12 @@ impl ::std::fmt::Debug for ImageBlit { .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }).field("dst_subresource", &self.dst_subresource) + }) + .field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for ImageBlit { @@ -6208,7 +6237,8 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6912,155 +6942,202 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ).field( + ) + .field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ).field("buffer_image_granularity", &self.buffer_image_granularity) + ) + .field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ).field( + ) + .field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ).field( + ) + .field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ).field( + ) + .field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ).field( + ) + .field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ).field( + ) + .field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ).field("max_per_stage_resources", &self.max_per_stage_resources) + ) + .field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ).field( + ) + .field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ).field( + ) + .field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ).field( + ) + .field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ).field( + ) + .field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ).field( + ) + .field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ).field( + ) + .field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ).field( + ) + .field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ).field( + ) + .field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ) + .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ).field( + ) + .field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ).field( + ) + .field( "max_vertex_output_components", &self.max_vertex_output_components, - ).field( + ) + .field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ).field( + ) + .field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ).field( + ) + .field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ).field( + ) + .field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ).field( + ) + .field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ).field( + ) + .field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ).field( + ) + .field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ).field( + ) + .field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ).field( + ) + .field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ).field( + ) + .field( "max_geometry_input_components", &self.max_geometry_input_components, - ).field( + ) + .field( "max_geometry_output_components", &self.max_geometry_output_components, - ).field( + ) + .field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ).field( + ) + .field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ).field( + ) + .field( "max_fragment_input_components", &self.max_fragment_input_components, - ).field( + ) + .field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ).field( + ) + .field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ).field( + ) + .field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ).field( + ) + .field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ).field("max_compute_work_group_count", &unsafe { + ) + .field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }).field( + }) + .field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ).field("max_compute_work_group_size", &unsafe { + ) + .field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }) + .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ).field("max_draw_indirect_count", &self.max_draw_indirect_count) + ) + .field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }).field("viewport_bounds_range", &unsafe { + }) + .field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }) + .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ).field( + ) + .field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ).field( + ) + .field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ).field("min_texel_offset", &self.min_texel_offset) + ) + .field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7069,63 +7146,79 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ).field("max_framebuffer_width", &self.max_framebuffer_width) + ) + .field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ).field( + ) + .field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ).field( + ) + .field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ).field( + ) + .field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ).field("max_color_attachments", &self.max_color_attachments) + ) + .field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ).field( + ) + .field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ).field( + ) + .field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ).field( + ) + .field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ).field( + ) + .field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ).field("max_sample_mask_words", &self.max_sample_mask_words) + ) + .field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ).field("timestamp_period", &self.timestamp_period) + ) + .field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ).field("discrete_queue_priorities", &self.discrete_queue_priorities) + ) + .field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }).field("line_width_range", &unsafe { + }) + .field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }).field("point_size_granularity", &self.point_size_granularity) + }) + .field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ).field( + ) + .field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ).field("non_coherent_atom_size", &self.non_coherent_atom_size) + ) + .field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7835,7 +7928,8 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8580,11 +8674,14 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }).field("driver_uuid", &unsafe { + }) + .field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }).field("device_luid", &unsafe { + }) + .field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }).field("device_node_mask", &self.device_node_mask) + }) + .field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -9354,7 +9451,8 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }).field("subset_allocation", &self.subset_allocation) + }) + .field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9592,7 +9690,8 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }).field("modes", &self.modes) + }) + .field("modes", &self.modes) .finish() } } @@ -10752,17 +10851,21 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ).field( + ) + .field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ).field("sample_location_coordinate_range", &unsafe { + ) + .field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }).field( + }) + .field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ).field("variable_sample_locations", &self.variable_sample_locations) + ) + .field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -11060,7 +11163,8 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -11152,7 +11256,8 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -13483,12 +13588,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: - self.get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: self + .get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: - self.get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: self + .get_physical_device_surface_present_modes_khr, } } } @@ -13637,12 +13742,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -13949,10 +14054,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: - self.get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: - self.get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: self + .get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: self + .get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14235,8 +14340,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: - self.get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: self + .get_physical_device_xlib_presentation_support_khr, } } } @@ -14321,8 +14426,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: - self.get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: self + .get_physical_device_xcb_presentation_support_khr, } } } @@ -14407,8 +14512,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: - self.get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: self + .get_physical_device_wayland_presentation_support_khr, } } } @@ -14490,8 +14595,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: - self.get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: self + .get_physical_device_mir_presentation_support_khr, } } } @@ -14626,8 +14731,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: - self.get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: self + .get_physical_device_win32_presentation_support_khr, } } } @@ -16193,8 +16298,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: - self.get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: self + .get_physical_device_external_image_format_properties_nv, } } } @@ -16387,12 +16492,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17204,8 +17309,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17391,8 +17496,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17506,8 +17611,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: - self.get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: self + .get_physical_device_generated_commands_properties_nvx, } } } @@ -17947,8 +18052,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: - self.get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: self + .get_physical_device_surface_capabilities2_ext, } } } @@ -19099,8 +19204,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: - self.get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: self + .get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19231,10 +19336,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: - self.get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: - self.get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: self + .get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: self + .get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -19870,10 +19975,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: - self.get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: - self.get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: self + .get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: self + .get_memory_android_hardware_buffer_android, } } } @@ -20274,8 +20379,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: - self.get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: self + .get_physical_device_multisample_properties_ext, } } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 63b9438..6e0af14 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -88,26 +88,28 @@ named!(cfloat<&str, f32>, pub fn define_handle_macro() -> Tokens { quote! { macro_rules! define_handle{ - ($name: ident) => { - #[derive(Clone, Copy, Debug)] + ($name: ident, $ty: ident) => { #[repr(transparent)] - pub struct $name{ - ptr: *mut u8 - } - impl Default for $name{ + #[derive(Clone, Copy, Debug)] + pub struct $name(*mut u8); + impl Default for $name { fn default() -> $name { $name::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 { $name(x as _) } + } + unsafe impl Send for $name {} unsafe impl Sync for $name {} impl $name{ pub fn null() -> Self{ - $name{ - ptr: ::std::ptr::null_mut() - } + $name(::std::ptr::null_mut()) } } } @@ -118,10 +120,16 @@ pub fn define_handle_macro() -> Tokens { pub fn handle_nondispatchable_macro() -> Tokens { quote!{ macro_rules! handle_nondispatchable { - ($name: ident) => { + ($name: ident, $ty: ident) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] - pub struct $name (uint64_t); + pub struct $name(uint64_t); + + impl Handle for $name { + const TYPE: ObjectType = ObjectType::$ty; + fn as_raw(self) -> u64 { self.0 as u64 } + fn from_raw(x: u64) -> Self { $name(x as _) } + } impl $name{ pub fn null() -> $name{ @@ -1254,16 +1262,18 @@ pub fn generate_handle(handle: &vkxml::Handle) -> Option { let tokens = match handle.ty { vkxml::HandleType::Dispatch => { let name = &handle.name[2..]; + let ty = Ident::from(name.to_shouty_snake_case()); let name = Ident::from(name); quote! { - define_handle!(#name); + define_handle!(#name, #ty); } } vkxml::HandleType::NoDispatch => { let name = &handle.name[2..]; + let ty = Ident::from(name.to_shouty_snake_case()); let name = Ident::from(name); quote! { - handle_nondispatchable!(#name); + handle_nondispatchable!(#name, #ty); } } }; @@ -1541,6 +1551,13 @@ pub fn write_source_code(path: &Path) { pub use self::extensions::*; #[doc(hidden)] pub use self::bitflags::*; + + pub trait Handle { + const TYPE: ObjectType; + fn as_raw(self) -> u64; + fn from_raw(u64) -> Self; + } + #version_macros #platform_specific_types #bitflags_macro From e65a24ddcd423843a6f7675912f322f0567d1223 Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Wed, 1 Aug 2018 17:32:23 -0700 Subject: [PATCH 067/122] Wrap VK_EXT_debug_utils --- ash/src/extensions/debug_utils.rs | 145 ++++++++++++++++++++++++++++++ ash/src/extensions/mod.rs | 1 + 2 files changed, 146 insertions(+) create mode 100644 ash/src/extensions/debug_utils.rs diff --git a/ash/src/extensions/debug_utils.rs b/ash/src/extensions/debug_utils.rs new file mode 100644 index 0000000..dd8d2ea --- /dev/null +++ b/ash/src/extensions/debug_utils.rs @@ -0,0 +1,145 @@ +#![allow(dead_code)] +use prelude::*; +use std::ffi::CStr; +use std::mem; +use version::{DeviceV1_0, InstanceV1_0}; +use {vk, RawPtr}; + +#[derive(Clone)] +pub struct DebugUtils { + debug_utils_fn: vk::ExtDebugUtilsFn, +} + +impl DebugUtils { + pub fn new( + instance: &I, + device: &D, + ) -> Result> { + let debug_utils_fn = vk::ExtDebugUtilsFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + })?; + Ok(DebugUtils { + debug_utils_fn: debug_utils_fn, + }) + } + + pub fn name() -> &'static CStr { + CStr::from_bytes_with_nul(b"VK_EXT_debug_utils\0").expect("Wrong extension string") + } + + pub unsafe fn debug_utils_set_object_name_ext( + &self, + device: vk::Device, + name_info: &vk::DebugUtilsObjectNameInfoEXT, + ) -> VkResult<()> { + let err_code = self.debug_utils_fn.set_debug_utils_object_name_ext(device, name_info); + match err_code { + vk::Result::SUCCESS => Ok(()), + _ => Err(err_code), + } + } + + pub unsafe fn debug_utils_set_object_tag_ext( + &self, + device: vk::Device, + tag_info: &vk::DebugUtilsObjectTagInfoEXT, + ) -> VkResult<()> { + let err_code = self.debug_utils_fn.set_debug_utils_object_tag_ext(device, tag_info); + match err_code { + vk::Result::SUCCESS => Ok(()), + _ => Err(err_code), + } + } + + pub unsafe fn cmd_begin_debug_utils_label_ext( + &self, + command_buffer: vk::CommandBuffer, + label: &vk::DebugUtilsLabelEXT, + ) { + self.debug_utils_fn + .cmd_begin_debug_utils_label_ext(command_buffer, label); + } + + pub unsafe fn cmd_end_debug_utils_label_ext(&self, command_buffer: vk::CommandBuffer) { + self.debug_utils_fn + .cmd_end_debug_utils_label_ext(command_buffer); + } + + pub unsafe fn cmd_insert_debug_utils_label_ext( + &self, + command_buffer: vk::CommandBuffer, + label: &vk::DebugUtilsLabelEXT, + ) { + self.debug_utils_fn + .cmd_insert_debug_utils_label_ext(command_buffer, label); + } + + pub unsafe fn queue_begin_debug_utils_label_ext( + &self, + queue: vk::Queue, + label: &vk::DebugUtilsLabelEXT, + ) { + self.debug_utils_fn + .queue_begin_debug_utils_label_ext(queue, label); + } + + pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: vk::Queue) { + self.debug_utils_fn.queue_end_debug_utils_label_ext(queue); + } + + pub unsafe fn queue_insert_debug_utils_label_ext( + &self, + queue: vk::Queue, + label: &vk::DebugUtilsLabelEXT, + ) { + self.debug_utils_fn + .queue_insert_debug_utils_label_ext(queue, label); + } + + pub unsafe fn create_debug_utils_messenger_ext( + &self, + instance: vk::Instance, + create_info: &vk::DebugUtilsMessengerCreateInfoEXT, + allocator: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut messenger = mem::uninitialized(); + let err_code = self.debug_utils_fn.create_debug_utils_messenger_ext( + instance, + create_info, + allocator.as_raw_ptr(), + &mut messenger, + ); + match err_code { + vk::Result::SUCCESS => Ok(messenger), + _ => Err(err_code), + } + } + + pub unsafe fn destroy_debug_utils_messenger_ext( + &self, + instance: vk::Instance, + messenger: vk::DebugUtilsMessengerEXT, + allocator: Option<&vk::AllocationCallbacks>, + ) { + self.debug_utils_fn.destroy_debug_utils_messenger_ext( + instance, + messenger, + allocator.as_raw_ptr(), + ); + } + + pub unsafe fn submit_debug_utils_message_ext( + &self, + instance: vk::Instance, + message_severity: vk::DebugUtilsMessageSeverityFlagsEXT, + message_types: vk::DebugUtilsMessageTypeFlagsEXT, + callback_data: &vk::DebugUtilsMessengerCallbackDataEXT, + ) { + self.debug_utils_fn.submit_debug_utils_message_ext( + instance, + message_severity, + message_types, + callback_data, + ); + } +} diff --git a/ash/src/extensions/mod.rs b/ash/src/extensions/mod.rs index cab1e06..bf9b023 100644 --- a/ash/src/extensions/mod.rs +++ b/ash/src/extensions/mod.rs @@ -25,3 +25,4 @@ mod wayland_surface; mod win32_surface; mod xcb_surface; mod xlib_surface; +mod debug_utils; From 21a4eef1f8c795182b43537173ec1ef1b80a5139 Mon Sep 17 00:00:00 2001 From: Brian Merchant Date: Fri, 17 Aug 2018 12:26:32 -0700 Subject: [PATCH 068/122] pin vk-parse to crates.io --- .gitignore | 1 + generator/Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 2a3817b..3da1c93 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ target Cargo.lock !examples/Cargo.lock +.idea \ No newline at end of file diff --git a/generator/Cargo.toml b/generator/Cargo.toml index 1b3acb4..04cbe30 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" authors = ["Maik Klein "] [dependencies] -vk-parse = {git = "https://github.com/krolli/vk-parse"} +vk-parse = "0.1" vkxml = {git = "https://github.com/terrybrashaw/vkxml"} #vkxml = {git = "https://github.com/maikklein/vkxml"} nom = "4.0" From c4e4ab8fc2b09ca7c61a9f0cb3925c2427278993 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 19 Aug 2018 10:10:11 +0200 Subject: [PATCH 069/122] Temporary implement Hash and PartialEq for certain types that only contain primtive types --- ash/src/vk.rs | 608 ++++++++++++------------------------------- generator/Cargo.toml | 3 +- generator/src/lib.rs | 28 +- 3 files changed, 194 insertions(+), 445 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index fd6c575..ae6f425 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -11,25 +11,25 @@ pub trait Handle { } #[macro_export] macro_rules! vk_make_version { - ($major:expr, $minor:expr, $patch:expr) => { + ( $ major : expr , $ minor : expr , $ patch : expr ) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ($major:expr) => { + ( $ major : expr ) => { ($major as uint32_t) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ($minor:expr) => { + ( $ minor : expr ) => { (($minor as uint32_t) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ($minor:expr) => { + ( $ minor : expr ) => { ($minor as uint32_t) & 0xfff }; } @@ -60,7 +60,7 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ($name:ident, $all:expr, $flag_type:ty) => { + ( $ name : ident , $ all : expr , $ flag_type : ty ) => { impl Default for $name { fn default() -> $name { $name(0) @@ -179,7 +179,7 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(uint64_t); @@ -216,7 +216,7 @@ macro_rules! handle_nondispatchable { }; } macro_rules! define_handle { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] #[derive(Clone, Copy, Debug)] pub struct $name(*mut u8); @@ -463,18 +463,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: self - .get_physical_device_image_format_properties, + get_physical_device_image_format_properties: + self.get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: self - .get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: + self.get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: self - .get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: + self.get_physical_device_sparse_image_format_properties, } } } @@ -3941,19 +3941,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: self - .get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: self - .get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: + self.get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: + self.get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: self - .get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: self - .get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: self - .get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: self - .get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: + self.get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: + self.get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: + self.get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: + self.get_physical_device_external_semaphore_properties, } } } @@ -4976,13 +4976,13 @@ pub struct Offset3D { pub z: int32_t, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] +#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] pub struct Extent2D { pub width: uint32_t, pub height: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] +#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] pub struct Extent3D { pub width: uint32_t, pub height: uint32_t, @@ -5042,11 +5042,9 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }) - .field("pipeline_cache_uuid", &unsafe { + }).field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }) - .field("limits", &self.limits) + }).field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5077,8 +5075,7 @@ impl ::std::fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .finish() } } @@ -5103,13 +5100,11 @@ impl ::std::fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for LayerProperties { @@ -5166,8 +5161,7 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ) - .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5283,12 +5277,10 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }) - .field("memory_heap_count", &self.memory_heap_count) + }).field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5818,12 +5810,10 @@ impl ::std::fmt::Debug for ImageBlit { .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }) - .field("dst_subresource", &self.dst_subresource) + }).field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ImageBlit { @@ -6237,8 +6227,7 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6942,202 +6931,155 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ) - .field( + ).field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ) - .field("buffer_image_granularity", &self.buffer_image_granularity) + ).field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ) - .field( + ).field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ) - .field( + ).field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ) - .field( + ).field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ) - .field("max_per_stage_resources", &self.max_per_stage_resources) + ).field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ) - .field( + ).field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ) - .field( + ).field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ) - .field( + ).field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ) - .field( + ).field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ) - .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ) - .field( + ).field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ) - .field( + ).field( "max_vertex_output_components", &self.max_vertex_output_components, - ) - .field( + ).field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ) - .field( + ).field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ) - .field( + ).field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ) - .field( + ).field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ) - .field( + ).field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ) - .field( + ).field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ) - .field( + ).field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ) - .field( + ).field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ) - .field( + ).field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ) - .field( + ).field( "max_geometry_input_components", &self.max_geometry_input_components, - ) - .field( + ).field( "max_geometry_output_components", &self.max_geometry_output_components, - ) - .field( + ).field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ) - .field( + ).field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ) - .field( + ).field( "max_fragment_input_components", &self.max_fragment_input_components, - ) - .field( + ).field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ) - .field( + ).field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ) - .field( + ).field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ) - .field( + ).field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ) - .field("max_compute_work_group_count", &unsafe { + ).field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }) - .field( + }).field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ) - .field("max_compute_work_group_size", &unsafe { + ).field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }) - .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ) - .field("max_draw_indirect_count", &self.max_draw_indirect_count) + ).field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }) - .field("viewport_bounds_range", &unsafe { + }).field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }) - .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ) - .field( + ).field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ) - .field( + ).field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ) - .field("min_texel_offset", &self.min_texel_offset) + ).field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7146,79 +7088,63 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ) - .field("max_framebuffer_width", &self.max_framebuffer_width) + ).field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ) - .field( + ).field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ) - .field( + ).field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ) - .field( + ).field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ) - .field("max_color_attachments", &self.max_color_attachments) + ).field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ) - .field( + ).field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ) - .field( + ).field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ) - .field( + ).field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ) - .field( + ).field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ) - .field("max_sample_mask_words", &self.max_sample_mask_words) + ).field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ) - .field("timestamp_period", &self.timestamp_period) + ).field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ) - .field("discrete_queue_priorities", &self.discrete_queue_priorities) + ).field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }) - .field("line_width_range", &unsafe { + }).field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }) - .field("point_size_granularity", &self.point_size_granularity) + }).field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ) - .field( + ).field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ) - .field("non_coherent_atom_size", &self.non_coherent_atom_size) + ).field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7401,7 +7327,7 @@ impl ::std::default::Default for FramebufferCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] +#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] pub struct DrawIndirectCommand { pub vertex_count: uint32_t, pub instance_count: uint32_t, @@ -7418,7 +7344,7 @@ pub struct DrawIndexedIndirectCommand { pub first_instance: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] +#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] pub struct DispatchIndirectCommand { pub x: uint32_t, pub y: uint32_t, @@ -7928,8 +7854,7 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8320,9 +8245,6 @@ impl ::std::default::Default for PhysicalDeviceFeatures2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceFeatures2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProperties2 { pub s_type: StructureType, @@ -8339,9 +8261,6 @@ impl ::std::default::Default for PhysicalDeviceProperties2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceProperties2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FormatProperties2 { pub s_type: StructureType, @@ -8358,9 +8277,6 @@ impl ::std::default::Default for FormatProperties2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct FormatProperties2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageFormatProperties2 { pub s_type: StructureType, @@ -8377,9 +8293,6 @@ impl ::std::default::Default for ImageFormatProperties2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ImageFormatProperties2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceImageFormatInfo2 { pub s_type: StructureType, @@ -8404,9 +8317,6 @@ impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceImageFormatInfo2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct QueueFamilyProperties2 { pub s_type: StructureType, @@ -8423,9 +8333,6 @@ impl ::std::default::Default for QueueFamilyProperties2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct QueueFamilyProperties2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMemoryProperties2 { pub s_type: StructureType, @@ -8442,9 +8349,6 @@ impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceMemoryProperties2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageFormatProperties2 { pub s_type: StructureType, @@ -8461,9 +8365,6 @@ impl ::std::default::Default for SparseImageFormatProperties2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct SparseImageFormatProperties2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSparseImageFormatInfo2 { pub s_type: StructureType, @@ -8488,9 +8389,6 @@ impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceSparseImageFormatInfo2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePushDescriptorPropertiesKHR { pub s_type: StructureType, @@ -8565,18 +8463,12 @@ impl ::std::default::Default for PhysicalDeviceVariablePointerFeatures { } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceVariablePointerFeaturesKHR {} -#[repr(C)] -#[derive(Copy, Clone, Default, Debug)] pub struct ExternalMemoryProperties { pub external_memory_features: ExternalMemoryFeatureFlags, pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, pub compatible_handle_types: ExternalMemoryHandleTypeFlags, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExternalMemoryPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalImageFormatInfo { pub s_type: StructureType, @@ -8593,9 +8485,6 @@ impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceExternalImageFormatInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalImageFormatProperties { pub s_type: StructureType, @@ -8612,9 +8501,6 @@ impl ::std::default::Default for ExternalImageFormatProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExternalImageFormatPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalBufferInfo { pub s_type: StructureType, @@ -8635,9 +8521,6 @@ impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceExternalBufferInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalBufferProperties { pub s_type: StructureType, @@ -8654,9 +8537,6 @@ impl ::std::default::Default for ExternalBufferProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExternalBufferPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone)] pub struct PhysicalDeviceIDProperties { pub s_type: StructureType, @@ -8674,14 +8554,11 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }) - .field("driver_uuid", &unsafe { + }).field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }) - .field("device_luid", &unsafe { + }).field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }) - .field("device_node_mask", &self.device_node_mask) + }).field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -8700,9 +8577,6 @@ impl ::std::default::Default for PhysicalDeviceIDProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceIDPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalMemoryImageCreateInfo { pub s_type: StructureType, @@ -8719,9 +8593,6 @@ impl ::std::default::Default for ExternalMemoryImageCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExternalMemoryImageCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalMemoryBufferCreateInfo { pub s_type: StructureType, @@ -8738,9 +8609,6 @@ impl ::std::default::Default for ExternalMemoryBufferCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExternalMemoryBufferCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryAllocateInfo { pub s_type: StructureType, @@ -8757,9 +8625,6 @@ impl ::std::default::Default for ExportMemoryAllocateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExportMemoryAllocateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryWin32HandleInfoKHR { pub s_type: StructureType, @@ -8930,9 +8795,6 @@ impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceExternalSemaphoreInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalSemaphoreProperties { pub s_type: StructureType, @@ -8953,9 +8815,6 @@ impl ::std::default::Default for ExternalSemaphoreProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExternalSemaphorePropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportSemaphoreCreateInfo { pub s_type: StructureType, @@ -8972,9 +8831,6 @@ impl ::std::default::Default for ExportSemaphoreCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExportSemaphoreCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportSemaphoreWin32HandleInfoKHR { pub s_type: StructureType, @@ -9115,9 +8971,6 @@ impl ::std::default::Default for PhysicalDeviceExternalFenceInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceExternalFenceInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalFenceProperties { pub s_type: StructureType, @@ -9138,9 +8991,6 @@ impl ::std::default::Default for ExternalFenceProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExternalFencePropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportFenceCreateInfo { pub s_type: StructureType, @@ -9157,9 +9007,6 @@ impl ::std::default::Default for ExportFenceCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ExportFenceCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportFenceWin32HandleInfoKHR { pub s_type: StructureType, @@ -9282,9 +9129,6 @@ impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceMultiviewFeaturesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewProperties { pub s_type: StructureType, @@ -9303,9 +9147,6 @@ impl ::std::default::Default for PhysicalDeviceMultiviewProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceMultiviewPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct RenderPassMultiviewCreateInfo { pub s_type: StructureType, @@ -9332,9 +9173,6 @@ impl ::std::default::Default for RenderPassMultiviewCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct RenderPassMultiviewCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2EXT { pub s_type: StructureType, @@ -9451,8 +9289,7 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }) - .field("subset_allocation", &self.subset_allocation) + }).field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9468,9 +9305,6 @@ impl ::std::default::Default for PhysicalDeviceGroupProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceGroupPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryAllocateFlagsInfo { pub s_type: StructureType, @@ -9489,9 +9323,6 @@ impl ::std::default::Default for MemoryAllocateFlagsInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct MemoryAllocateFlagsInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryInfo { pub s_type: StructureType, @@ -9512,9 +9343,6 @@ impl ::std::default::Default for BindBufferMemoryInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct BindBufferMemoryInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryDeviceGroupInfo { pub s_type: StructureType, @@ -9533,9 +9361,6 @@ impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct BindBufferMemoryDeviceGroupInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImageMemoryInfo { pub s_type: StructureType, @@ -9556,9 +9381,6 @@ impl ::std::default::Default for BindImageMemoryInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct BindImageMemoryInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImageMemoryDeviceGroupInfo { pub s_type: StructureType, @@ -9581,9 +9403,6 @@ impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct BindImageMemoryDeviceGroupInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupRenderPassBeginInfo { pub s_type: StructureType, @@ -9604,9 +9423,6 @@ impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct DeviceGroupRenderPassBeginInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupCommandBufferBeginInfo { pub s_type: StructureType, @@ -9623,9 +9439,6 @@ impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct DeviceGroupCommandBufferBeginInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupSubmitInfo { pub s_type: StructureType, @@ -9652,9 +9465,6 @@ impl ::std::default::Default for DeviceGroupSubmitInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct DeviceGroupSubmitInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupBindSparseInfo { pub s_type: StructureType, @@ -9673,9 +9483,6 @@ impl ::std::default::Default for DeviceGroupBindSparseInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct DeviceGroupBindSparseInfoKHR {} -#[repr(C)] #[derive(Copy, Clone)] pub struct DeviceGroupPresentCapabilitiesKHR { pub s_type: StructureType, @@ -9690,8 +9497,7 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }) - .field("modes", &self.modes) + }).field("modes", &self.modes) .finish() } } @@ -9802,9 +9608,6 @@ impl ::std::default::Default for DeviceGroupDeviceCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct DeviceGroupDeviceCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupSwapchainCreateInfoKHR { pub s_type: StructureType, @@ -9831,9 +9634,6 @@ pub struct DescriptorUpdateTemplateEntry { pub stride: size_t, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct DescriptorUpdateTemplateEntryKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorUpdateTemplateCreateInfo { pub s_type: StructureType, @@ -9865,9 +9665,6 @@ impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] -pub struct DescriptorUpdateTemplateCreateInfoKHR {} -#[repr(C)] -#[derive(Copy, Clone, Default, Debug)] pub struct XYColorEXT { pub x: c_float, pub y: c_float, @@ -10092,9 +9889,6 @@ pub struct InputAttachmentAspectReference { pub aspect_mask: ImageAspectFlags, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct InputAttachmentAspectReferenceKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct RenderPassInputAttachmentAspectCreateInfo { pub s_type: StructureType, @@ -10113,9 +9907,6 @@ impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct RenderPassInputAttachmentAspectCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSurfaceInfo2KHR { pub s_type: StructureType, @@ -10284,9 +10075,6 @@ impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDevice16BitStorageFeaturesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSubgroupProperties { pub s_type: StructureType, @@ -10325,9 +10113,6 @@ impl ::std::default::Default for BufferMemoryRequirementsInfo2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct BufferMemoryRequirementsInfo2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageMemoryRequirementsInfo2 { pub s_type: StructureType, @@ -10344,9 +10129,6 @@ impl ::std::default::Default for ImageMemoryRequirementsInfo2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ImageMemoryRequirementsInfo2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageSparseMemoryRequirementsInfo2 { pub s_type: StructureType, @@ -10363,9 +10145,6 @@ impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ImageSparseMemoryRequirementsInfo2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryRequirements2 { pub s_type: StructureType, @@ -10382,9 +10161,6 @@ impl ::std::default::Default for MemoryRequirements2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct MemoryRequirements2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryRequirements2 { pub s_type: StructureType, @@ -10401,9 +10177,6 @@ impl ::std::default::Default for SparseImageMemoryRequirements2 { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct SparseImageMemoryRequirements2KHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePointClippingProperties { pub s_type: StructureType, @@ -10420,9 +10193,6 @@ impl ::std::default::Default for PhysicalDevicePointClippingProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDevicePointClippingPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedRequirements { pub s_type: StructureType, @@ -10441,9 +10211,6 @@ impl ::std::default::Default for MemoryDedicatedRequirements { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct MemoryDedicatedRequirementsKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedAllocateInfo { pub s_type: StructureType, @@ -10462,9 +10229,6 @@ impl ::std::default::Default for MemoryDedicatedAllocateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct MemoryDedicatedAllocateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageViewUsageCreateInfo { pub s_type: StructureType, @@ -10481,9 +10245,6 @@ impl ::std::default::Default for ImageViewUsageCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ImageViewUsageCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineTessellationDomainOriginStateCreateInfo { pub s_type: StructureType, @@ -10500,9 +10261,6 @@ impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PipelineTessellationDomainOriginStateCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionInfo { pub s_type: StructureType, @@ -10519,9 +10277,6 @@ impl ::std::default::Default for SamplerYcbcrConversionInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct SamplerYcbcrConversionInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionCreateInfo { pub s_type: StructureType, @@ -10552,9 +10307,6 @@ impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct SamplerYcbcrConversionCreateInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImagePlaneMemoryInfo { pub s_type: StructureType, @@ -10571,9 +10323,6 @@ impl ::std::default::Default for BindImagePlaneMemoryInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct BindImagePlaneMemoryInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImagePlaneMemoryRequirementsInfo { pub s_type: StructureType, @@ -10590,9 +10339,6 @@ impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct ImagePlaneMemoryRequirementsInfoKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { pub s_type: StructureType, @@ -10609,9 +10355,6 @@ impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionImageFormatProperties { pub s_type: StructureType, @@ -10628,9 +10371,6 @@ impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct SamplerYcbcrConversionImageFormatPropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct TextureLODGatherFormatPropertiesAMD { pub s_type: StructureType, @@ -10851,21 +10591,17 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ) - .field( + ).field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ) - .field("sample_location_coordinate_range", &unsafe { + ).field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }) - .field( + }).field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ) - .field("variable_sample_locations", &self.variable_sample_locations) + ).field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -11073,9 +10809,6 @@ impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct PhysicalDeviceMaintenance3PropertiesKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutSupport { pub s_type: StructureType, @@ -11092,9 +10825,6 @@ impl ::std::default::Default for DescriptorSetLayoutSupport { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -pub struct DescriptorSetLayoutSupportKHR {} -#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderDrawParameterFeatures { pub s_type: StructureType, @@ -11163,8 +10893,7 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -11256,8 +10985,7 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -11652,7 +11380,7 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSuppo } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug)] +#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] pub struct VertexInputBindingDivisorDescriptionEXT { pub binding: uint32_t, pub divisor: uint32_t, @@ -13588,12 +13316,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: self - .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: + self.get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: self - .get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: + self.get_physical_device_surface_present_modes_khr, } } } @@ -13742,12 +13470,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -14054,10 +13782,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: self - .get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: self - .get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: + self.get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: + self.get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14340,8 +14068,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: self - .get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: + self.get_physical_device_xlib_presentation_support_khr, } } } @@ -14426,8 +14154,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: self - .get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: + self.get_physical_device_xcb_presentation_support_khr, } } } @@ -14512,8 +14240,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: self - .get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: + self.get_physical_device_wayland_presentation_support_khr, } } } @@ -14595,8 +14323,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: self - .get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: + self.get_physical_device_mir_presentation_support_khr, } } } @@ -14731,8 +14459,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: self - .get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: + self.get_physical_device_win32_presentation_support_khr, } } } @@ -16298,8 +16026,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: self - .get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: + self.get_physical_device_external_image_format_properties_nv, } } } @@ -16492,12 +16220,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17309,8 +17037,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17496,8 +17224,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17611,8 +17339,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: self - .get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: + self.get_physical_device_generated_commands_properties_nvx, } } } @@ -18052,8 +17780,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: self - .get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: + self.get_physical_device_surface_capabilities2_ext, } } } @@ -19204,8 +18932,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: self - .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: + self.get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19336,10 +19064,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: self - .get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: self - .get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: + self.get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: + self.get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -19975,10 +19703,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: self - .get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: self - .get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: + self.get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: + self.get_memory_android_hardware_buffer_android, } } } @@ -20379,8 +20107,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: self - .get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: + self.get_physical_device_multisample_properties_ext, } } } diff --git a/generator/Cargo.toml b/generator/Cargo.toml index 04cbe30..6202abb 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -5,8 +5,7 @@ authors = ["Maik Klein "] [dependencies] vk-parse = "0.1" -vkxml = {git = "https://github.com/terrybrashaw/vkxml"} -#vkxml = {git = "https://github.com/maikklein/vkxml"} +vkxml = "0.3" nom = "4.0" heck = "0.3" proc-macro2 = "0.2" diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 6e0af14..1956396 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1092,7 +1092,7 @@ fn is_static_array(field: &vkxml::Field) -> bool { _ => false, }).unwrap_or(false) } -pub fn derive_default(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Option { +pub fn derive_default(_struct: &vkxml::Struct) -> Option { let name = name_to_tokens(&_struct.name); let members = _struct.elements.iter().filter_map(|elem| match *elem { vkxml::StructElement::Member(ref field) => Some(field), @@ -1219,6 +1219,27 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt }; Some(q) } + +pub fn auto_derive_partial_eq_hash(_struct: &vkxml::Struct) -> Tokens { + // TODO: Properly detect which types can implement PartialEq and Hash. + // At the moment we only implement it for structs that contain primitivet + // types. + let is_primitive = _struct + .elements + .iter() + .filter_map(|elem| match *elem { + vkxml::StructElement::Member(ref field) => Some(field), + _ => None, + }).all(|field| match field.basetype.as_str() { + "c_float" | "uint32_t" => true, + _ => false, + }); + if is_primitive { + quote!(Hash, PartialEq,) + } else { + quote!{} + } +} pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Tokens { let name = name_to_tokens(&_struct.name); let members = _struct.elements.iter().filter_map(|elem| match *elem { @@ -1233,7 +1254,8 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> }); let debug_tokens = derive_debug(_struct, union_types); - let default_tokens = derive_default(_struct, union_types); + let default_tokens = derive_default(_struct); + let partial_eq_hash_str = auto_derive_partial_eq_hash(_struct); let dbg_str = if debug_tokens.is_none() { quote!(Debug,) } else { @@ -1246,7 +1268,7 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> }; quote!{ #[repr(C)] - #[derive(Copy, Clone, #default_str #dbg_str)] + #[derive(Copy, Clone, #default_str #dbg_str #partial_eq_hash_str)] pub struct #name { #(#params,)* } From 6738c4c01c16e480ad785b5d7ccddca4d2e165c4 Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 19 Aug 2018 19:40:28 -0700 Subject: [PATCH 070/122] impl Display for constants --- ash/src/vk.rs | 3257 +++++++++++++++++++++++++++++++++++++++--- ash/tests/display.rs | 12 + generator/src/lib.rs | 113 +- 3 files changed, 3166 insertions(+), 216 deletions(-) create mode 100644 ash/tests/display.rs diff --git a/ash/src/vk.rs b/ash/src/vk.rs index ae6f425..b18aa34 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -4,6 +4,7 @@ pub use self::bitflags::*; pub use self::extensions::*; #[doc(hidden)] pub use libc::*; +use std::fmt; pub trait Handle { const TYPE: ObjectType; fn as_raw(self) -> u64; @@ -11,25 +12,25 @@ pub trait Handle { } #[macro_export] macro_rules! vk_make_version { - ( $ major : expr , $ minor : expr , $ patch : expr ) => { + ($major:expr, $minor:expr, $patch:expr) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ( $ major : expr ) => { + ($major:expr) => { ($major as uint32_t) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ( $ minor : expr ) => { + ($minor:expr) => { (($minor as uint32_t) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ( $ minor : expr ) => { + ($minor:expr) => { ($minor as uint32_t) & 0xfff }; } @@ -60,7 +61,7 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ( $ name : ident , $ all : expr , $ flag_type : ty ) => { + ($name:ident, $all:expr, $flag_type:ty) => { impl Default for $name { fn default() -> $name { $name(0) @@ -179,7 +180,7 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ( $ name : ident , $ ty : ident ) => { + ($name:ident, $ty:ident) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(uint64_t); @@ -216,7 +217,7 @@ macro_rules! handle_nondispatchable { }; } macro_rules! define_handle { - ( $ name : ident , $ ty : ident ) => { + ($name:ident, $ty:ident) => { #[repr(transparent)] #[derive(Clone, Copy, Debug)] pub struct $name(*mut u8); @@ -463,18 +464,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: - self.get_physical_device_image_format_properties, + get_physical_device_image_format_properties: self + .get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: - self.get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: self + .get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: - self.get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: self + .get_physical_device_sparse_image_format_properties, } } } @@ -3941,19 +3942,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: - self.get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: - self.get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: self + .get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: self + .get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: - self.get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: - self.get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: - self.get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: - self.get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: self + .get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: self + .get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: self + .get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: self + .get_physical_device_external_semaphore_properties, } } } @@ -5042,9 +5043,11 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }).field("pipeline_cache_uuid", &unsafe { + }) + .field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }).field("limits", &self.limits) + }) + .field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5075,7 +5078,8 @@ impl ::std::fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .finish() } } @@ -5100,11 +5104,13 @@ impl ::std::fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for LayerProperties { @@ -5161,7 +5167,8 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ) + .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5277,10 +5284,12 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }).field("memory_heap_count", &self.memory_heap_count) + }) + .field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5810,10 +5819,12 @@ impl ::std::fmt::Debug for ImageBlit { .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }).field("dst_subresource", &self.dst_subresource) + }) + .field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for ImageBlit { @@ -6227,7 +6238,8 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6931,155 +6943,202 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ).field( + ) + .field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ).field("buffer_image_granularity", &self.buffer_image_granularity) + ) + .field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ).field( + ) + .field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ).field( + ) + .field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ).field( + ) + .field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ).field( + ) + .field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ).field( + ) + .field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ).field("max_per_stage_resources", &self.max_per_stage_resources) + ) + .field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ).field( + ) + .field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ).field( + ) + .field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ).field( + ) + .field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ).field( + ) + .field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ).field( + ) + .field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ).field( + ) + .field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ).field( + ) + .field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ).field( + ) + .field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ) + .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ).field( + ) + .field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ).field( + ) + .field( "max_vertex_output_components", &self.max_vertex_output_components, - ).field( + ) + .field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ).field( + ) + .field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ).field( + ) + .field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ).field( + ) + .field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ).field( + ) + .field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ).field( + ) + .field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ).field( + ) + .field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ).field( + ) + .field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ).field( + ) + .field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ).field( + ) + .field( "max_geometry_input_components", &self.max_geometry_input_components, - ).field( + ) + .field( "max_geometry_output_components", &self.max_geometry_output_components, - ).field( + ) + .field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ).field( + ) + .field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ).field( + ) + .field( "max_fragment_input_components", &self.max_fragment_input_components, - ).field( + ) + .field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ).field( + ) + .field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ).field( + ) + .field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ).field( + ) + .field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ).field("max_compute_work_group_count", &unsafe { + ) + .field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }).field( + }) + .field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ).field("max_compute_work_group_size", &unsafe { + ) + .field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }) + .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ).field("max_draw_indirect_count", &self.max_draw_indirect_count) + ) + .field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }).field("viewport_bounds_range", &unsafe { + }) + .field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }) + .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ).field( + ) + .field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ).field( + ) + .field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ).field("min_texel_offset", &self.min_texel_offset) + ) + .field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7088,63 +7147,79 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ).field("max_framebuffer_width", &self.max_framebuffer_width) + ) + .field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ).field( + ) + .field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ).field( + ) + .field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ).field( + ) + .field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ).field("max_color_attachments", &self.max_color_attachments) + ) + .field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ).field( + ) + .field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ).field( + ) + .field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ).field( + ) + .field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ).field( + ) + .field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ).field("max_sample_mask_words", &self.max_sample_mask_words) + ) + .field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ).field("timestamp_period", &self.timestamp_period) + ) + .field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ).field("discrete_queue_priorities", &self.discrete_queue_priorities) + ) + .field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }).field("line_width_range", &unsafe { + }) + .field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }).field("point_size_granularity", &self.point_size_granularity) + }) + .field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ).field( + ) + .field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ).field("non_coherent_atom_size", &self.non_coherent_atom_size) + ) + .field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7854,7 +7929,8 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8554,11 +8630,14 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }).field("driver_uuid", &unsafe { + }) + .field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }).field("device_luid", &unsafe { + }) + .field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }).field("device_node_mask", &self.device_node_mask) + }) + .field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -9289,7 +9368,8 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }).field("subset_allocation", &self.subset_allocation) + }) + .field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9497,7 +9577,8 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }).field("modes", &self.modes) + }) + .field("modes", &self.modes) .finish() } } @@ -10591,17 +10672,21 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ).field( + ) + .field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ).field("sample_location_coordinate_range", &unsafe { + ) + .field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }).field( + }) + .field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ).field("variable_sample_locations", &self.variable_sample_locations) + ) + .field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -10893,7 +10978,8 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -10985,7 +11071,8 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -12144,54 +12231,77 @@ impl Result { } impl ::std::error::Error for Result { fn description(&self) -> &str { - "vk::Result" + let name = match *self { + Result::SUCCESS => Some("Command completed successfully"), + Result::NOT_READY => Some("A fence or query has not yet completed"), + Result::TIMEOUT => Some("A wait operation has not completed in the specified time"), + Result::EVENT_SET => Some("An event is signaled"), + Result::EVENT_RESET => Some("An event is unsignaled"), + Result::INCOMPLETE => Some("A return array was too small for the result"), + Result::ERROR_OUT_OF_HOST_MEMORY => Some("A host memory allocation has failed"), + Result::ERROR_OUT_OF_DEVICE_MEMORY => Some("A device memory allocation has failed"), + Result::ERROR_INITIALIZATION_FAILED => Some("Initialization of a object has failed"), + Result::ERROR_DEVICE_LOST => { + Some("The logical device has been lost. See <>") + } + Result::ERROR_MEMORY_MAP_FAILED => Some("Mapping of a memory object has failed"), + Result::ERROR_LAYER_NOT_PRESENT => Some("Layer specified does not exist"), + Result::ERROR_EXTENSION_NOT_PRESENT => Some("Extension specified does not exist"), + Result::ERROR_FEATURE_NOT_PRESENT => { + Some("Requested feature is not available on this device") + } + Result::ERROR_INCOMPATIBLE_DRIVER => Some("Unable to find a Vulkan driver"), + Result::ERROR_TOO_MANY_OBJECTS => { + Some("Too many objects of the type have already been created") + } + Result::ERROR_FORMAT_NOT_SUPPORTED => { + Some("Requested format is not supported on this device") + } + Result::ERROR_FRAGMENTED_POOL => Some( + "A requested pool allocation has failed due to fragmentation of the pool\'s memory", + ), + _ => None, + }; + name.unwrap_or("unknown error") } } -impl ::std::fmt::Display for Result { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - writeln!(fmt, "vk::Result::{:?}", self)?; - match *self { - Result::SUCCESS => write!(fmt, "Command completed successfully"), - Result::NOT_READY => write!(fmt, "A fence or query has not yet completed"), - Result::TIMEOUT => write!( - fmt, - "A wait operation has not completed in the specified time" - ), - Result::EVENT_SET => write!(fmt, "An event is signaled"), - Result::EVENT_RESET => write!(fmt, "An event is unsignaled"), - Result::INCOMPLETE => write!(fmt, "A return array was too small for the result"), - Result::ERROR_OUT_OF_HOST_MEMORY => write!(fmt, "A host memory allocation has failed"), - Result::ERROR_OUT_OF_DEVICE_MEMORY => { - write!(fmt, "A device memory allocation has failed") - } - Result::ERROR_INITIALIZATION_FAILED => { - write!(fmt, "Initialization of a object has failed") - } - Result::ERROR_DEVICE_LOST => write!( - fmt, - "The logical device has been lost. See <>" - ), - Result::ERROR_MEMORY_MAP_FAILED => write!(fmt, "Mapping of a memory object has failed"), - Result::ERROR_LAYER_NOT_PRESENT => write!(fmt, "Layer specified does not exist"), - Result::ERROR_EXTENSION_NOT_PRESENT => { - write!(fmt, "Extension specified does not exist") +impl fmt::Display for Result { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Result::SUCCESS => Some("Command completed successfully"), + Result::NOT_READY => Some("A fence or query has not yet completed"), + Result::TIMEOUT => Some("A wait operation has not completed in the specified time"), + Result::EVENT_SET => Some("An event is signaled"), + Result::EVENT_RESET => Some("An event is unsignaled"), + Result::INCOMPLETE => Some("A return array was too small for the result"), + Result::ERROR_OUT_OF_HOST_MEMORY => Some("A host memory allocation has failed"), + Result::ERROR_OUT_OF_DEVICE_MEMORY => Some("A device memory allocation has failed"), + Result::ERROR_INITIALIZATION_FAILED => Some("Initialization of a object has failed"), + Result::ERROR_DEVICE_LOST => { + Some("The logical device has been lost. See <>") } + Result::ERROR_MEMORY_MAP_FAILED => Some("Mapping of a memory object has failed"), + Result::ERROR_LAYER_NOT_PRESENT => Some("Layer specified does not exist"), + Result::ERROR_EXTENSION_NOT_PRESENT => Some("Extension specified does not exist"), Result::ERROR_FEATURE_NOT_PRESENT => { - write!(fmt, "Requested feature is not available on this device") + Some("Requested feature is not available on this device") + } + Result::ERROR_INCOMPATIBLE_DRIVER => Some("Unable to find a Vulkan driver"), + Result::ERROR_TOO_MANY_OBJECTS => { + Some("Too many objects of the type have already been created") } - Result::ERROR_INCOMPATIBLE_DRIVER => write!(fmt, "Unable to find a Vulkan driver"), - Result::ERROR_TOO_MANY_OBJECTS => write!( - fmt, - "Too many objects of the type have already been created" - ), Result::ERROR_FORMAT_NOT_SUPPORTED => { - write!(fmt, "Requested format is not supported on this device") + Some("Requested format is not supported on this device") } - Result::ERROR_FRAGMENTED_POOL => write!( - fmt, - "A requested pool allocation has failed due to fragmentation of the pool\'s memory" + Result::ERROR_FRAGMENTED_POOL => Some( + "A requested pool allocation has failed due to fragmentation of the pool\'s memory", ), - _ => write!(fmt, "Unknown variant"), + _ => None, + }; + if let Some(x) = name { + fmt.write_str(x) + } else { + write!(fmt, "{}", self.0) } } } @@ -13316,12 +13426,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: - self.get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: self + .get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: - self.get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: self + .get_physical_device_surface_present_modes_khr, } } } @@ -13470,12 +13580,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -13782,10 +13892,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: - self.get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: - self.get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: self + .get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: self + .get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14068,8 +14178,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: - self.get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: self + .get_physical_device_xlib_presentation_support_khr, } } } @@ -14154,8 +14264,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: - self.get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: self + .get_physical_device_xcb_presentation_support_khr, } } } @@ -14240,8 +14350,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: - self.get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: self + .get_physical_device_wayland_presentation_support_khr, } } } @@ -14323,8 +14433,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: - self.get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: self + .get_physical_device_mir_presentation_support_khr, } } } @@ -14459,8 +14569,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: - self.get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: self + .get_physical_device_win32_presentation_support_khr, } } } @@ -16026,8 +16136,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: - self.get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: self + .get_physical_device_external_image_format_properties_nv, } } } @@ -16220,12 +16330,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17037,8 +17147,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17224,8 +17334,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17339,8 +17449,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: - self.get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: self + .get_physical_device_generated_commands_properties_nvx, } } } @@ -17780,8 +17890,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: - self.get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: self + .get_physical_device_surface_capabilities2_ext, } } } @@ -18932,8 +19042,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: - self.get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: self + .get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19064,10 +19174,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: - self.get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: - self.get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: self + .get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: self + .get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -19703,10 +19813,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: - self.get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: - self.get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: self + .get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: self + .get_memory_android_hardware_buffer_android, } } } @@ -20107,8 +20217,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: - self.get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: self + .get_physical_device_multisample_properties_ext, } } } @@ -22778,3 +22888,2744 @@ pub mod extensions { pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = StructureType(1000063000); } } +fn display_flags( + f: &mut fmt::Formatter, + known: &[(Flags, &'static str)], + value: Flags, +) -> fmt::Result { + let mut first = true; + let mut accum = value; + for (bit, name) in known { + if accum & bit != 0 { + if !first { + f.write_str(" | ")?; + } + f.write_str(name)?; + first = false; + accum &= !bit; + } + } + if accum != 0 { + if !first { + f.write_str(" | ")?; + } + write!(f, "{:b}", accum)?; + } + Ok(()) +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StructureType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::APPLICATION_INFO => Some("APPLICATION_INFO"), + Self::INSTANCE_CREATE_INFO => Some("INSTANCE_CREATE_INFO"), + Self::DEVICE_QUEUE_CREATE_INFO => Some("DEVICE_QUEUE_CREATE_INFO"), + Self::DEVICE_CREATE_INFO => Some("DEVICE_CREATE_INFO"), + Self::SUBMIT_INFO => Some("SUBMIT_INFO"), + Self::MEMORY_ALLOCATE_INFO => Some("MEMORY_ALLOCATE_INFO"), + Self::MAPPED_MEMORY_RANGE => Some("MAPPED_MEMORY_RANGE"), + Self::BIND_SPARSE_INFO => Some("BIND_SPARSE_INFO"), + Self::FENCE_CREATE_INFO => Some("FENCE_CREATE_INFO"), + Self::SEMAPHORE_CREATE_INFO => Some("SEMAPHORE_CREATE_INFO"), + Self::EVENT_CREATE_INFO => Some("EVENT_CREATE_INFO"), + Self::QUERY_POOL_CREATE_INFO => Some("QUERY_POOL_CREATE_INFO"), + Self::BUFFER_CREATE_INFO => Some("BUFFER_CREATE_INFO"), + Self::BUFFER_VIEW_CREATE_INFO => Some("BUFFER_VIEW_CREATE_INFO"), + Self::IMAGE_CREATE_INFO => Some("IMAGE_CREATE_INFO"), + Self::IMAGE_VIEW_CREATE_INFO => Some("IMAGE_VIEW_CREATE_INFO"), + Self::SHADER_MODULE_CREATE_INFO => Some("SHADER_MODULE_CREATE_INFO"), + Self::PIPELINE_CACHE_CREATE_INFO => Some("PIPELINE_CACHE_CREATE_INFO"), + Self::PIPELINE_SHADER_STAGE_CREATE_INFO => Some("PIPELINE_SHADER_STAGE_CREATE_INFO"), + Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => { + Some("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO") + } + Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => { + Some("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO") + } + Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => { + Some("PIPELINE_TESSELLATION_STATE_CREATE_INFO") + } + Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => { + Some("PIPELINE_VIEWPORT_STATE_CREATE_INFO") + } + Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => { + Some("PIPELINE_RASTERIZATION_STATE_CREATE_INFO") + } + Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => { + Some("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO") + } + Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => { + Some("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO") + } + Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => { + Some("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO") + } + Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => Some("PIPELINE_DYNAMIC_STATE_CREATE_INFO"), + Self::GRAPHICS_PIPELINE_CREATE_INFO => Some("GRAPHICS_PIPELINE_CREATE_INFO"), + Self::COMPUTE_PIPELINE_CREATE_INFO => Some("COMPUTE_PIPELINE_CREATE_INFO"), + Self::PIPELINE_LAYOUT_CREATE_INFO => Some("PIPELINE_LAYOUT_CREATE_INFO"), + Self::SAMPLER_CREATE_INFO => Some("SAMPLER_CREATE_INFO"), + Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => Some("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"), + Self::DESCRIPTOR_POOL_CREATE_INFO => Some("DESCRIPTOR_POOL_CREATE_INFO"), + Self::DESCRIPTOR_SET_ALLOCATE_INFO => Some("DESCRIPTOR_SET_ALLOCATE_INFO"), + Self::WRITE_DESCRIPTOR_SET => Some("WRITE_DESCRIPTOR_SET"), + Self::COPY_DESCRIPTOR_SET => Some("COPY_DESCRIPTOR_SET"), + Self::FRAMEBUFFER_CREATE_INFO => Some("FRAMEBUFFER_CREATE_INFO"), + Self::RENDER_PASS_CREATE_INFO => Some("RENDER_PASS_CREATE_INFO"), + Self::COMMAND_POOL_CREATE_INFO => Some("COMMAND_POOL_CREATE_INFO"), + Self::COMMAND_BUFFER_ALLOCATE_INFO => Some("COMMAND_BUFFER_ALLOCATE_INFO"), + Self::COMMAND_BUFFER_INHERITANCE_INFO => Some("COMMAND_BUFFER_INHERITANCE_INFO"), + Self::COMMAND_BUFFER_BEGIN_INFO => Some("COMMAND_BUFFER_BEGIN_INFO"), + Self::RENDER_PASS_BEGIN_INFO => Some("RENDER_PASS_BEGIN_INFO"), + Self::BUFFER_MEMORY_BARRIER => Some("BUFFER_MEMORY_BARRIER"), + Self::IMAGE_MEMORY_BARRIER => Some("IMAGE_MEMORY_BARRIER"), + Self::MEMORY_BARRIER => Some("MEMORY_BARRIER"), + Self::LOADER_INSTANCE_CREATE_INFO => Some("LOADER_INSTANCE_CREATE_INFO"), + Self::LOADER_DEVICE_CREATE_INFO => Some("LOADER_DEVICE_CREATE_INFO"), + Self::SWAPCHAIN_CREATE_INFO_KHR => Some("SWAPCHAIN_CREATE_INFO_KHR"), + Self::PRESENT_INFO_KHR => Some("PRESENT_INFO_KHR"), + Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => { + Some("DEVICE_GROUP_PRESENT_CAPABILITIES_KHR") + } + Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => Some("IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), + Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => { + Some("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR") + } + Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => Some("ACQUIRE_NEXT_IMAGE_INFO_KHR"), + Self::DEVICE_GROUP_PRESENT_INFO_KHR => Some("DEVICE_GROUP_PRESENT_INFO_KHR"), + Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => { + Some("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR") + } + Self::DISPLAY_MODE_CREATE_INFO_KHR => Some("DISPLAY_MODE_CREATE_INFO_KHR"), + Self::DISPLAY_SURFACE_CREATE_INFO_KHR => Some("DISPLAY_SURFACE_CREATE_INFO_KHR"), + Self::DISPLAY_PRESENT_INFO_KHR => Some("DISPLAY_PRESENT_INFO_KHR"), + Self::XLIB_SURFACE_CREATE_INFO_KHR => Some("XLIB_SURFACE_CREATE_INFO_KHR"), + Self::XCB_SURFACE_CREATE_INFO_KHR => Some("XCB_SURFACE_CREATE_INFO_KHR"), + Self::WAYLAND_SURFACE_CREATE_INFO_KHR => Some("WAYLAND_SURFACE_CREATE_INFO_KHR"), + Self::MIR_SURFACE_CREATE_INFO_KHR => Some("MIR_SURFACE_CREATE_INFO_KHR"), + Self::ANDROID_SURFACE_CREATE_INFO_KHR => Some("ANDROID_SURFACE_CREATE_INFO_KHR"), + Self::WIN32_SURFACE_CREATE_INFO_KHR => Some("WIN32_SURFACE_CREATE_INFO_KHR"), + Self::NATIVE_BUFFER_ANDROID => Some("NATIVE_BUFFER_ANDROID"), + Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => { + Some("DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT") + } + Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => { + Some("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD") + } + Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"), + Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"), + Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"), + Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") + } + Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV") + } + Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV") + } + Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { + Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") + } + Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => { + Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV") + } + Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => Some("EXPORT_MEMORY_ALLOCATE_INFO_NV"), + Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => { + Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV") + } + Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"), + Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"), + Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { + Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR") + } + Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { + Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR") + } + Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => Some("MEMORY_WIN32_HANDLE_PROPERTIES_KHR"), + Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => Some("MEMORY_GET_WIN32_HANDLE_INFO_KHR"), + Self::IMPORT_MEMORY_FD_INFO_KHR => Some("IMPORT_MEMORY_FD_INFO_KHR"), + Self::MEMORY_FD_PROPERTIES_KHR => Some("MEMORY_FD_PROPERTIES_KHR"), + Self::MEMORY_GET_FD_INFO_KHR => Some("MEMORY_GET_FD_INFO_KHR"), + Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => { + Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR") + } + Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { + Some("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") + } + Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { + Some("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") + } + Self::D3D12_FENCE_SUBMIT_INFO_KHR => Some("D3D12_FENCE_SUBMIT_INFO_KHR"), + Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => { + Some("SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR") + } + Self::IMPORT_SEMAPHORE_FD_INFO_KHR => Some("IMPORT_SEMAPHORE_FD_INFO_KHR"), + Self::SEMAPHORE_GET_FD_INFO_KHR => Some("SEMAPHORE_GET_FD_INFO_KHR"), + Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR") + } + Self::PRESENT_REGIONS_KHR => Some("PRESENT_REGIONS_KHR"), + Self::OBJECT_TABLE_CREATE_INFO_NVX => Some("OBJECT_TABLE_CREATE_INFO_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX => { + Some("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX") + } + Self::CMD_PROCESS_COMMANDS_INFO_NVX => Some("CMD_PROCESS_COMMANDS_INFO_NVX"), + Self::CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX => { + Some("CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX") + } + Self::DEVICE_GENERATED_COMMANDS_LIMITS_NVX => { + Some("DEVICE_GENERATED_COMMANDS_LIMITS_NVX") + } + Self::DEVICE_GENERATED_COMMANDS_FEATURES_NVX => { + Some("DEVICE_GENERATED_COMMANDS_FEATURES_NVX") + } + Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV") + } + Self::SURFACE_CAPABILITIES_2_EXT => Some("SURFACE_CAPABILITIES_2_EXT"), + Self::DISPLAY_POWER_INFO_EXT => Some("DISPLAY_POWER_INFO_EXT"), + Self::DEVICE_EVENT_INFO_EXT => Some("DEVICE_EVENT_INFO_EXT"), + Self::DISPLAY_EVENT_INFO_EXT => Some("DISPLAY_EVENT_INFO_EXT"), + Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => Some("SWAPCHAIN_COUNTER_CREATE_INFO_EXT"), + Self::PRESENT_TIMES_INFO_GOOGLE => Some("PRESENT_TIMES_INFO_GOOGLE"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX") + } + Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT") + } + Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT") + } + Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT") + } + Self::HDR_METADATA_EXT => Some("HDR_METADATA_EXT"), + Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => { + Some("SHARED_PRESENT_SURFACE_CAPABILITIES_KHR") + } + Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => Some("FENCE_GET_WIN32_HANDLE_INFO_KHR"), + Self::IMPORT_FENCE_FD_INFO_KHR => Some("IMPORT_FENCE_FD_INFO_KHR"), + Self::FENCE_GET_FD_INFO_KHR => Some("FENCE_GET_FD_INFO_KHR"), + Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => Some("PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"), + Self::SURFACE_CAPABILITIES_2_KHR => Some("SURFACE_CAPABILITIES_2_KHR"), + Self::SURFACE_FORMAT_2_KHR => Some("SURFACE_FORMAT_2_KHR"), + Self::DISPLAY_PROPERTIES_2_KHR => Some("DISPLAY_PROPERTIES_2_KHR"), + Self::DISPLAY_PLANE_PROPERTIES_2_KHR => Some("DISPLAY_PLANE_PROPERTIES_2_KHR"), + Self::DISPLAY_MODE_PROPERTIES_2_KHR => Some("DISPLAY_MODE_PROPERTIES_2_KHR"), + Self::DISPLAY_PLANE_INFO_2_KHR => Some("DISPLAY_PLANE_INFO_2_KHR"), + Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => Some("DISPLAY_PLANE_CAPABILITIES_2_KHR"), + Self::IOS_SURFACE_CREATE_INFO_M => Some("IOS_SURFACE_CREATE_INFO_M"), + Self::MACOS_SURFACE_CREATE_INFO_M => Some("MACOS_SURFACE_CREATE_INFO_M"), + Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => Some("DEBUG_UTILS_OBJECT_NAME_INFO_EXT"), + Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => Some("DEBUG_UTILS_OBJECT_TAG_INFO_EXT"), + Self::DEBUG_UTILS_LABEL_EXT => Some("DEBUG_UTILS_LABEL_EXT"), + Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => { + Some("DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT") + } + Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => { + Some("DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT") + } + Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_USAGE_ANDROID") + } + Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID") + } + Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID") + } + Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { + Some("IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") + } + Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { + Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") + } + Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"), + Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT") + } + Self::SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT => { + Some("SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT") + } + Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"), + Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => { + Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT") + } + Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT") + } + Self::MULTISAMPLE_PROPERTIES_EXT => Some("MULTISAMPLE_PROPERTIES_EXT"), + Self::IMAGE_FORMAT_LIST_CREATE_INFO_KHR => Some("IMAGE_FORMAT_LIST_CREATE_INFO_KHR"), + Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT") + } + Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT") + } + Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV") + } + Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV") + } + Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"), + Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => { + Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT") + } + Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT => { + Some("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT") + } + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT => { + Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT") + } + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT => { + Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT") + } + Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT => { + Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT") + } + Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => { + Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT") + } + Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => Some("MEMORY_HOST_POINTER_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => { + Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD") + } + Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT") + } + Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { + Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") + } + Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"), + Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"), + Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => { + Some("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES") + } + Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"), + Self::MEMORY_DEDICATED_ALLOCATE_INFO => Some("MEMORY_DEDICATED_ALLOCATE_INFO"), + Self::MEMORY_ALLOCATE_FLAGS_INFO => Some("MEMORY_ALLOCATE_FLAGS_INFO"), + Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => { + Some("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO") + } + Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => { + Some("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO") + } + Self::DEVICE_GROUP_SUBMIT_INFO => Some("DEVICE_GROUP_SUBMIT_INFO"), + Self::DEVICE_GROUP_BIND_SPARSE_INFO => Some("DEVICE_GROUP_BIND_SPARSE_INFO"), + Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => { + Some("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO") + } + Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => { + Some("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO") + } + Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => Some("PHYSICAL_DEVICE_GROUP_PROPERTIES"), + Self::DEVICE_GROUP_DEVICE_CREATE_INFO => Some("DEVICE_GROUP_DEVICE_CREATE_INFO"), + Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => Some("BUFFER_MEMORY_REQUIREMENTS_INFO_2"), + Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => Some("IMAGE_MEMORY_REQUIREMENTS_INFO_2"), + Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => { + Some("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2") + } + Self::MEMORY_REQUIREMENTS_2 => Some("MEMORY_REQUIREMENTS_2"), + Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => Some("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"), + Self::PHYSICAL_DEVICE_FEATURES_2 => Some("PHYSICAL_DEVICE_FEATURES_2"), + Self::PHYSICAL_DEVICE_PROPERTIES_2 => Some("PHYSICAL_DEVICE_PROPERTIES_2"), + Self::FORMAT_PROPERTIES_2 => Some("FORMAT_PROPERTIES_2"), + Self::IMAGE_FORMAT_PROPERTIES_2 => Some("IMAGE_FORMAT_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => { + Some("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2") + } + Self::QUEUE_FAMILY_PROPERTIES_2 => Some("QUEUE_FAMILY_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => { + Some("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2") + } + Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2 => Some("SPARSE_IMAGE_FORMAT_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => { + Some("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2") + } + Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => { + Some("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES") + } + Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => { + Some("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO") + } + Self::IMAGE_VIEW_USAGE_CREATE_INFO => Some("IMAGE_VIEW_USAGE_CREATE_INFO"), + Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => { + Some("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO") + } + Self::RENDER_PASS_MULTIVIEW_CREATE_INFO => Some("RENDER_PASS_MULTIVIEW_CREATE_INFO"), + Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES => Some("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES") + } + Self::PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES => { + Some("PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES") + } + Self::PROTECTED_SUBMIT_INFO => Some("PROTECTED_SUBMIT_INFO"), + Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => { + Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES") + } + Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => { + Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES") + } + Self::DEVICE_QUEUE_INFO_2 => Some("DEVICE_QUEUE_INFO_2"), + Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO => { + Some("SAMPLER_YCBCR_CONVERSION_CREATE_INFO") + } + Self::SAMPLER_YCBCR_CONVERSION_INFO => Some("SAMPLER_YCBCR_CONVERSION_INFO"), + Self::BIND_IMAGE_PLANE_MEMORY_INFO => Some("BIND_IMAGE_PLANE_MEMORY_INFO"), + Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => { + Some("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO") + } + Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => { + Some("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES") + } + Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => { + Some("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES") + } + Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => { + Some("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO") + } + Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES => Some("EXTERNAL_IMAGE_FORMAT_PROPERTIES"), + Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO") + } + Self::EXTERNAL_BUFFER_PROPERTIES => Some("EXTERNAL_BUFFER_PROPERTIES"), + Self::PHYSICAL_DEVICE_ID_PROPERTIES => Some("PHYSICAL_DEVICE_ID_PROPERTIES"), + Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO => Some("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"), + Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO => Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"), + Self::EXPORT_MEMORY_ALLOCATE_INFO => Some("EXPORT_MEMORY_ALLOCATE_INFO"), + Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO") + } + Self::EXTERNAL_FENCE_PROPERTIES => Some("EXTERNAL_FENCE_PROPERTIES"), + Self::EXPORT_FENCE_CREATE_INFO => Some("EXPORT_FENCE_CREATE_INFO"), + Self::EXPORT_SEMAPHORE_CREATE_INFO => Some("EXPORT_SEMAPHORE_CREATE_INFO"), + Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO") + } + Self::EXTERNAL_SEMAPHORE_PROPERTIES => Some("EXTERNAL_SEMAPHORE_PROPERTIES"), + Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => { + Some("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES") + } + Self::DESCRIPTOR_SET_LAYOUT_SUPPORT => Some("DESCRIPTOR_SET_LAYOUT_SUPPORT"), + Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} diff --git a/ash/tests/display.rs b/ash/tests/display.rs new file mode 100644 index 0000000..5ab861a --- /dev/null +++ b/ash/tests/display.rs @@ -0,0 +1,12 @@ +extern crate ash; +use ash::vk; + +#[test] +fn display_flags() { + assert_eq!((vk::AccessFlags::INDIRECT_COMMAND_READ | vk::AccessFlags::VERTEX_ATTRIBUTE_READ).to_string(), "INDIRECT_COMMAND_READ | VERTEX_ATTRIBUTE_READ"); +} + +#[test] +fn display_enum() { + assert_eq!(vk::ChromaLocation::MIDPOINT.to_string(), "MIDPOINT"); +} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 1956396..12e4bdc 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -786,6 +786,7 @@ pub fn generate_extension_constants<'a>( extension_number: i64, extension_items: &'a [vk_parse::ExtensionItem], const_cache: &mut HashSet<&'a str>, + const_values: &mut HashMap>, ) -> quote::Tokens { let items = extension_items .iter() @@ -819,13 +820,14 @@ pub fn generate_extension_constants<'a>( } _ => None, }?; - let extends = extends?; let ext_constant = ExtensionConstant { name: &_enum.name, constant, }; let ident = name_to_tokens(&extends); + const_values.entry(ident.clone()).or_insert_with(Vec::new) + .push(ext_constant.variant_ident(&extends)); let impl_block = bitflags_impl_block(ident, &extends, &[&ext_constant]); let doc_string = format!("Generated from '{}'", extension_name); let q = quote!{ @@ -867,6 +869,7 @@ pub fn generate_extension<'a>( extension: &'a vk_parse::Extension, cmd_map: &CommandMap, const_cache: &mut HashSet<&'a str>, + const_values: &mut HashMap> ) -> Option { // Okay this is a little bit odd. We need to generate all extensions, even disabled ones, // because otherwise some StructureTypes won't get generated. But we don't generate extensions @@ -879,6 +882,7 @@ pub fn generate_extension<'a>( extension.number.unwrap_or(0), &extension.items, const_cache, + const_values, ); let fp = generate_extension_commands(&extension.name, &extension.items, cmd_map); let q = quote!{ @@ -991,6 +995,7 @@ pub fn bitflags_impl_block( pub fn generate_enum<'a>( _enum: &'a vkxml::Enumeration, const_cache: &mut HashSet<&'a str>, + const_values: &mut HashMap> ) -> EnumType { let name = &_enum.name[2..]; let _name = name.replace("FlagBits", "Flags"); @@ -1002,8 +1007,10 @@ pub fn generate_enum<'a>( vkxml::EnumerationElement::Enum(ref constant) => Some(constant), _ => None, }).collect_vec(); + let values = const_values.entry(ident.clone()).or_insert_with(Vec::new); for constant in &constants { const_cache.insert(constant.name.as_str()); + values.push(constant.variant_ident(&_enum.name)); } if name.contains("Bit") { @@ -1061,22 +1068,31 @@ pub fn generate_result(ident: Ident, _enum: &vkxml::Enumeration) -> Tokens { let variant_ident = variant_ident(&_enum.name, variant_name); Some(quote!{ - #ident::#variant_ident => write!(fmt, #notation) + #ident::#variant_ident => Some(#notation) }) }); + let notation2 = notation.clone(); quote!{ impl ::std::error::Error for #ident { fn description(&self) -> &str { - "vk::Result" + let name = match *self { + #(#notation),*, + _ => None, + }; + name.unwrap_or("unknown error") } } - impl ::std::fmt::Display for #ident { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - writeln!(fmt, "vk::Result::{:?}", self)?; - match *self { - #(#notation),*, - _ => write!(fmt, "Unknown variant") + impl fmt::Display for #ident { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + #(#notation2),*, + _ => None, + }; + if let Some(x) = name { + fmt.write_str(x) + } else { + write!(fmt, "{}", self.0) } } } @@ -1447,10 +1463,11 @@ pub fn generate_constant<'a>( pub fn generate_feature_extension<'a>( registry: &'a vk_parse::Registry, const_cache: &mut HashSet<&'a str>, + const_values: &mut HashMap> ) -> Tokens { let constants = registry.0.iter().filter_map(|item| match item { vk_parse::RegistryItem::Feature { name, items, .. } => { - Some(generate_extension_constants(name, 0, items, const_cache)) + Some(generate_extension_constants(name, 0, items, const_cache, const_values)) } _ => None, }); @@ -1459,6 +1476,68 @@ pub fn generate_feature_extension<'a>( } } +pub fn generate_const_displays<'a>(const_values: &HashMap>) -> Tokens { + let impls = const_values.iter() + .filter(|(ty, _)| *ty != "Result") + .map(|(ty, values)| { + if ty.to_string().contains("Flags") { + let cases = values.iter().map(|value| { + let name = value.to_string(); + quote!{ (#ty::#value.0, #name) } + }); + quote!{ + impl fmt::Display for #ty { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[#(#cases),*]; + display_flags(f, KNOWN, self.0) + } + } + } + } else { + let cases = values.iter().map(|value| { + let name = value.to_string(); + quote!{ Self::#value => Some(#name), } + }); + quote!{ + impl fmt::Display for #ty { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + #(#cases)* + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } + } + } + } + }); + quote!{ + fn display_flags(f: &mut fmt::Formatter, known: &[(Flags, &'static str)], value: Flags) -> fmt::Result { + let mut first = true; + let mut accum = value; + for (bit, name) in known { + if accum & bit != 0 { + if !first { f.write_str(" | ")?; } + f.write_str(name)?; + first = false; + accum &= !bit; + } + } + if accum != 0 { + if !first { f.write_str(" | ")?; } + write!(f, "{:b}", accum)?; + } + Ok(()) + } + + #(#impls)* + } +} + pub fn write_source_code(path: &Path) { use std::fs::File; use std::io::Write; @@ -1523,9 +1602,12 @@ pub fn write_source_code(path: &Path) { .collect(); let mut const_cache = HashSet::new(); + + let mut const_values: HashMap> = HashMap::new(); + let (enum_code, bitflags_code) = enums .into_iter() - .map(|e| generate_enum(e, &mut const_cache)) + .map(|e| generate_enum(e, &mut const_cache, &mut const_values)) .fold((Vec::new(), Vec::new()), |mut acc, elem| { match elem { EnumType::Enum(token) => acc.0.push(token), @@ -1533,13 +1615,14 @@ pub fn write_source_code(path: &Path) { }; acc }); + let constants_code: Vec<_> = constants .iter() .map(|constant| generate_constant(constant, &mut const_cache)) .collect(); let extension_code = extensions .iter() - .filter_map(|ext| generate_extension(ext, &commands, &mut const_cache)) + .filter_map(|ext| generate_extension(ext, &commands, &mut const_cache, &mut const_values)) .collect_vec(); let union_types = definitions @@ -1558,7 +1641,9 @@ pub fn write_source_code(path: &Path) { .iter() .map(|feature| generate_feature(feature, &commands)) .collect(); - let feature_extensions_code = generate_feature_extension(&spec2, &mut const_cache); + let feature_extensions_code = generate_feature_extension(&spec2, &mut const_cache, &mut const_values); + + let const_displays = generate_const_displays(&const_values); let mut file = File::create("../ash/src/vk.rs").expect("vk"); let bitflags_macro = vk_bitflags_wrapped_macro(); @@ -1567,6 +1652,7 @@ pub fn write_source_code(path: &Path) { let version_macros = vk_version_macros(); let platform_specific_types = platform_specific_types(); let source_code = quote!{ + use std::fmt; #[doc(hidden)] pub use libc::*; #[doc(hidden)] @@ -1598,6 +1684,7 @@ pub fn write_source_code(path: &Path) { #(#extension_code)* #feature_extensions_code } + #const_displays }; write!(&mut file, "{}", source_code).expect("Unable to write to file"); } From 6a329084e8d4a472956cd5ebba399adca8bc3a50 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 20 Aug 2018 07:30:59 +0200 Subject: [PATCH 071/122] Add generator to travis --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index b4e18b7..adcbf04 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,3 +6,4 @@ rust: script: - cargo build --manifest-path ash/Cargo.toml - cargo build --manifest-path examples/Cargo.toml + - cargo build --manifest-path generator/Cargo.toml From 8521f01488e8d0e057ac4433140ef7b912ff3ec9 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 20 Aug 2018 07:30:10 +0200 Subject: [PATCH 072/122] Switch to manual_derives --- ash/src/vk.rs | 10 +++++----- generator/src/lib.rs | 30 ++++++++++-------------------- 2 files changed, 15 insertions(+), 25 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index b18aa34..56056c2 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -4977,13 +4977,13 @@ pub struct Offset3D { pub z: int32_t, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] +#[derive(Copy, Clone, Default, Debug)] pub struct Extent2D { pub width: uint32_t, pub height: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] +#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)] pub struct Extent3D { pub width: uint32_t, pub height: uint32_t, @@ -7402,7 +7402,7 @@ impl ::std::default::Default for FramebufferCreateInfo { } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] +#[derive(Copy, Clone, Default, Debug)] pub struct DrawIndirectCommand { pub vertex_count: uint32_t, pub instance_count: uint32_t, @@ -7419,7 +7419,7 @@ pub struct DrawIndexedIndirectCommand { pub first_instance: uint32_t, } #[repr(C)] -#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] +#[derive(Copy, Clone, Default, Debug)] pub struct DispatchIndirectCommand { pub x: uint32_t, pub y: uint32_t, @@ -11467,7 +11467,7 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSuppo } } #[repr(C)] -#[derive(Copy, Clone, Default, Debug, Hash, PartialEq)] +#[derive(Copy, Clone, Default, Debug)] pub struct VertexInputBindingDivisorDescriptionEXT { pub binding: uint32_t, pub divisor: uint32_t, diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 12e4bdc..4217001 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1236,24 +1236,14 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt Some(q) } -pub fn auto_derive_partial_eq_hash(_struct: &vkxml::Struct) -> Tokens { - // TODO: Properly detect which types can implement PartialEq and Hash. - // At the moment we only implement it for structs that contain primitivet - // types. - let is_primitive = _struct - .elements - .iter() - .filter_map(|elem| match *elem { - vkxml::StructElement::Member(ref field) => Some(field), - _ => None, - }).all(|field| match field.basetype.as_str() { - "c_float" | "uint32_t" => true, - _ => false, - }); - if is_primitive { - quote!(Hash, PartialEq,) - } else { - quote!{} +/// At the moment `Ash` doesn't properly derive all the necessary drives +/// like Eq, Hash etc. +/// To Address some cases, you can add the name of the struct that you +/// require and add the missing derives yourself. +pub fn manual_derives(_struct: &vkxml::Struct) -> Tokens { + match _struct.name.as_str() { + "VkExtent3D" | "VKExtent2D" => quote!{PartialEq, Eq, Hash,}, + _ => quote!{}, } } pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Tokens { @@ -1271,7 +1261,7 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> let debug_tokens = derive_debug(_struct, union_types); let default_tokens = derive_default(_struct); - let partial_eq_hash_str = auto_derive_partial_eq_hash(_struct); + let manual_derive_tokens = manual_derives(_struct); let dbg_str = if debug_tokens.is_none() { quote!(Debug,) } else { @@ -1284,7 +1274,7 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> }; quote!{ #[repr(C)] - #[derive(Copy, Clone, #default_str #dbg_str #partial_eq_hash_str)] + #[derive(Copy, Clone, #default_str #dbg_str #manual_derive_tokens)] pub struct #name { #(#params,)* } From e546fbbb5df527942a8012b34eb6b750e0d2cf5b Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 20 Aug 2018 09:55:41 +0200 Subject: [PATCH 073/122] [Fix] BitPos can be negative --- ash/src/vk.rs | 3998 +++++++++++++++++++++--------------------- generator/src/lib.rs | 3 +- 2 files changed, 1958 insertions(+), 2043 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 56056c2..8917c52 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -12,25 +12,25 @@ pub trait Handle { } #[macro_export] macro_rules! vk_make_version { - ($major:expr, $minor:expr, $patch:expr) => { + ( $ major : expr , $ minor : expr , $ patch : expr ) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ($major:expr) => { + ( $ major : expr ) => { ($major as uint32_t) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ($minor:expr) => { + ( $ minor : expr ) => { (($minor as uint32_t) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ($minor:expr) => { + ( $ minor : expr ) => { ($minor as uint32_t) & 0xfff }; } @@ -61,7 +61,7 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ($name:ident, $all:expr, $flag_type:ty) => { + ( $ name : ident , $ all : expr , $ flag_type : ty ) => { impl Default for $name { fn default() -> $name { $name(0) @@ -180,7 +180,7 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(uint64_t); @@ -217,7 +217,7 @@ macro_rules! handle_nondispatchable { }; } macro_rules! define_handle { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] #[derive(Clone, Copy, Debug)] pub struct $name(*mut u8); @@ -464,18 +464,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: self - .get_physical_device_image_format_properties, + get_physical_device_image_format_properties: + self.get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: self - .get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: + self.get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: self - .get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: + self.get_physical_device_sparse_image_format_properties, } } } @@ -3942,19 +3942,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: self - .get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: self - .get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: + self.get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: + self.get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: self - .get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: self - .get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: self - .get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: self - .get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: + self.get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: + self.get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: + self.get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: + self.get_physical_device_external_semaphore_properties, } } } @@ -5043,11 +5043,9 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }) - .field("pipeline_cache_uuid", &unsafe { + }).field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }) - .field("limits", &self.limits) + }).field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5078,8 +5076,7 @@ impl ::std::fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .finish() } } @@ -5104,13 +5101,11 @@ impl ::std::fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for LayerProperties { @@ -5167,8 +5162,7 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ) - .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5284,12 +5278,10 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }) - .field("memory_heap_count", &self.memory_heap_count) + }).field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5819,12 +5811,10 @@ impl ::std::fmt::Debug for ImageBlit { .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }) - .field("dst_subresource", &self.dst_subresource) + }).field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ImageBlit { @@ -6238,8 +6228,7 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6943,202 +6932,155 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ) - .field( + ).field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ) - .field("buffer_image_granularity", &self.buffer_image_granularity) + ).field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ) - .field( + ).field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ) - .field( + ).field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ) - .field( + ).field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ) - .field("max_per_stage_resources", &self.max_per_stage_resources) + ).field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ) - .field( + ).field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ) - .field( + ).field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ) - .field( + ).field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ) - .field( + ).field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ) - .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ) - .field( + ).field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ) - .field( + ).field( "max_vertex_output_components", &self.max_vertex_output_components, - ) - .field( + ).field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ) - .field( + ).field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ) - .field( + ).field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ) - .field( + ).field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ) - .field( + ).field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ) - .field( + ).field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ) - .field( + ).field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ) - .field( + ).field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ) - .field( + ).field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ) - .field( + ).field( "max_geometry_input_components", &self.max_geometry_input_components, - ) - .field( + ).field( "max_geometry_output_components", &self.max_geometry_output_components, - ) - .field( + ).field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ) - .field( + ).field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ) - .field( + ).field( "max_fragment_input_components", &self.max_fragment_input_components, - ) - .field( + ).field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ) - .field( + ).field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ) - .field( + ).field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ) - .field( + ).field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ) - .field("max_compute_work_group_count", &unsafe { + ).field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }) - .field( + }).field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ) - .field("max_compute_work_group_size", &unsafe { + ).field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }) - .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ) - .field("max_draw_indirect_count", &self.max_draw_indirect_count) + ).field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }) - .field("viewport_bounds_range", &unsafe { + }).field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }) - .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ) - .field( + ).field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ) - .field( + ).field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ) - .field("min_texel_offset", &self.min_texel_offset) + ).field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7147,79 +7089,63 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ) - .field("max_framebuffer_width", &self.max_framebuffer_width) + ).field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ) - .field( + ).field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ) - .field( + ).field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ) - .field( + ).field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ) - .field("max_color_attachments", &self.max_color_attachments) + ).field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ) - .field( + ).field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ) - .field( + ).field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ) - .field( + ).field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ) - .field( + ).field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ) - .field("max_sample_mask_words", &self.max_sample_mask_words) + ).field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ) - .field("timestamp_period", &self.timestamp_period) + ).field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ) - .field("discrete_queue_priorities", &self.discrete_queue_priorities) + ).field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }) - .field("line_width_range", &unsafe { + }).field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }) - .field("point_size_granularity", &self.point_size_granularity) + }).field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ) - .field( + ).field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ) - .field("non_coherent_atom_size", &self.non_coherent_atom_size) + ).field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7929,8 +7855,7 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8630,14 +8555,11 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }) - .field("driver_uuid", &unsafe { + }).field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }) - .field("device_luid", &unsafe { + }).field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }) - .field("device_node_mask", &self.device_node_mask) + }).field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -9368,8 +9290,7 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }) - .field("subset_allocation", &self.subset_allocation) + }).field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9577,8 +9498,7 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }) - .field("modes", &self.modes) + }).field("modes", &self.modes) .finish() } } @@ -10672,21 +10592,17 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ) - .field( + ).field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ) - .field("sample_location_coordinate_range", &unsafe { + ).field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }) - .field( + }).field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ) - .field("variable_sample_locations", &self.variable_sample_locations) + ).field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -10978,8 +10894,7 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -11071,8 +10986,7 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -13426,12 +13340,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: self - .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: + self.get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: self - .get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: + self.get_physical_device_surface_present_modes_khr, } } } @@ -13559,11 +13473,11 @@ pub mod extensions { } #[doc = "Generated from \'VK_KHR_surface\'"] impl Result { - pub const ERROR_SURFACE_LOST_KHR: Self = Result(1000000000); + pub const ERROR_SURFACE_LOST_KHR: Self = Result(-1000000000); } #[doc = "Generated from \'VK_KHR_surface\'"] impl Result { - pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Result(1000000001); + pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Result(-1000000001); } #[doc = "Generated from \'VK_KHR_surface\'"] impl ObjectType { @@ -13580,12 +13494,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -13800,7 +13714,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_KHR_swapchain\'"] impl Result { - pub const ERROR_OUT_OF_DATE_KHR: Self = Result(1000001004); + pub const ERROR_OUT_OF_DATE_KHR: Self = Result(-1000001004); } #[doc = "Generated from \'VK_KHR_swapchain\'"] impl ObjectType { @@ -13892,10 +13806,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: self - .get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: self - .get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: + self.get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: + self.get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14155,7 +14069,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_KHR_display_swapchain\'"] impl Result { - pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Result(1000003001); + pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Result(-1000003001); } pub struct KhrXlibSurfaceFn { create_xlib_surface_khr: extern "system" fn( @@ -14178,8 +14092,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: self - .get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: + self.get_physical_device_xlib_presentation_support_khr, } } } @@ -14264,8 +14178,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: self - .get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: + self.get_physical_device_xcb_presentation_support_khr, } } } @@ -14350,8 +14264,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: self - .get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: + self.get_physical_device_wayland_presentation_support_khr, } } } @@ -14433,8 +14347,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: self - .get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: + self.get_physical_device_mir_presentation_support_khr, } } } @@ -14569,8 +14483,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: self - .get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: + self.get_physical_device_win32_presentation_support_khr, } } } @@ -14872,7 +14786,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_debug_report\'"] impl Result { - pub const ERROR_VALIDATION_FAILED_EXT: Self = Result(1000011001); + pub const ERROR_VALIDATION_FAILED_EXT: Self = Result(-1000011001); } #[doc = "Generated from \'VK_EXT_debug_report\'"] impl ObjectType { @@ -14910,7 +14824,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_NV_glsl_shader\'"] impl Result { - pub const ERROR_INVALID_SHADER_NV: Self = Result(1000012000); + pub const ERROR_INVALID_SHADER_NV: Self = Result(-1000012000); } pub struct ExtDepthRangeUnrestrictedFn {} unsafe impl Send for ExtDepthRangeUnrestrictedFn {} @@ -16136,8 +16050,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: self - .get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: + self.get_physical_device_external_image_format_properties_nv, } } } @@ -16330,12 +16244,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17147,8 +17061,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17334,8 +17248,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17449,8 +17363,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: self - .get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: + self.get_physical_device_generated_commands_properties_nvx, } } } @@ -17890,8 +17804,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: self - .get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: + self.get_physical_device_surface_capabilities2_ext, } } } @@ -19042,8 +18956,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: self - .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: + self.get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19174,10 +19088,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: self - .get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: self - .get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: + self.get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: + self.get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -19813,10 +19727,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: self - .get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: self - .get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: + self.get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: + self.get_memory_android_hardware_buffer_android, } } } @@ -20217,8 +20131,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: self - .get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: + self.get_physical_device_multisample_properties_ext, } } } @@ -21050,7 +20964,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] impl Result { - pub const ERROR_FRAGMENTATION_EXT: Self = Result(1000161000); + pub const ERROR_FRAGMENTATION_EXT: Self = Result(-1000161000); } pub struct ExtShaderViewportIndexLayerFn {} unsafe impl Send for ExtShaderViewportIndexLayerFn {} @@ -21425,7 +21339,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_EXT_global_priority\'"] impl Result { - pub const ERROR_NOT_PERMITTED_EXT: Self = Result(1000174001); + pub const ERROR_NOT_PERMITTED_EXT: Self = Result(-1000174001); } pub struct ExtExtension176Fn {} unsafe impl Send for ExtExtension176Fn {} @@ -22486,7 +22400,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_VERSION_1_1\'"] impl Result { - pub const ERROR_OUT_OF_POOL_MEMORY: Self = Result(1000069000); + pub const ERROR_OUT_OF_POOL_MEMORY: Self = Result(-1000069000); } #[doc = "Generated from \'VK_VERSION_1_1\'"] impl FormatFeatureFlags { @@ -22849,7 +22763,7 @@ pub mod extensions { } #[doc = "Generated from \'VK_VERSION_1_1\'"] impl Result { - pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Result(1000072003); + pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Result(-1000072003); } #[doc = "Generated from \'VK_VERSION_1_1\'"] impl StructureType { @@ -22913,51 +22827,11 @@ fn display_flags( } Ok(()) } -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), _ => None, }; if let Some(x) = name { @@ -22967,6 +22841,109 @@ impl fmt::Display for BlendOverlapEXT { } } } +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for DescriptorPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -22982,16 +22959,157 @@ impl fmt::Display for DescriptorPoolCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentDescriptionFlags { +impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorUpdateTemplateType { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -23001,161 +23119,63 @@ impl fmt::Display for DescriptorUpdateTemplateType { } } } -impl fmt::Display for ExternalSemaphoreFeatureFlags { +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, "SPLIT_INSTANCE_BIND_REGIONS", ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentStoreOp { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), _ => None, }; if let Some(x) = name { @@ -23165,6 +23185,71 @@ impl fmt::Display for AttachmentStoreOp { } } } +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for SurfaceTransformFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -23193,17 +23278,72 @@ impl fmt::Display for SurfaceTransformFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SurfaceCounterFlagsEXT { +impl fmt::Display for BlendOverlapEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassContents { +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), _ => None, }; if let Some(x) = name { @@ -23213,21 +23353,12 @@ impl fmt::Display for SubpassContents { } } } -impl fmt::Display for DynamicState { +impl fmt::Display for VendorId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), _ => None, }; if let Some(x) = name { @@ -23237,16 +23368,75 @@ impl fmt::Display for DynamicState { } } } -impl fmt::Display for SampleCountFlags { +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), ]; display_flags(f, KNOWN, self.0) } @@ -23314,480 +23504,17 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } @@ -23811,9 +23538,9 @@ impl fmt::Display for ExternalMemoryFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FormatFeatureFlags { +impl fmt::Display for SurfaceCounterFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; display_flags(f, KNOWN, self.0) } } @@ -23838,7 +23565,648 @@ impl fmt::Display for ShaderStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::ONE => Some("ONE"), @@ -23851,45 +24219,6 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -23933,27 +24262,12 @@ impl fmt::Display for PipelineStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { +impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -23963,51 +24277,24 @@ impl fmt::Display for ValidationCheckEXT { } } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { +impl fmt::Display for ColorSpaceKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), _ => None, }; if let Some(x) = name { @@ -24017,11 +24304,17 @@ impl fmt::Display for ComponentSwizzle { } } } -impl fmt::Display for FrontFace { +impl fmt::Display for IndirectCommandsTokenTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), _ => None, }; if let Some(x) = name { @@ -24031,26 +24324,240 @@ impl fmt::Display for FrontFace { } } } -impl fmt::Display for ImageLayout { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -24074,6 +24581,95 @@ impl fmt::Display for SharingMode { } } } +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24093,6 +24689,52 @@ impl fmt::Display for ImageViewType { } } } +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24141,80 +24783,6 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -24234,36 +24802,261 @@ impl fmt::Display for CommandBufferUsageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PrimitiveTopology { +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), _ => None, }; if let Some(x) = name { @@ -24713,322 +25506,9 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for Format { +impl fmt::Display for SemaphoreImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } @@ -25038,388 +25518,6 @@ impl fmt::Display for FenceImportFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25436,196 +25534,12 @@ impl fmt::Display for PolygonMode { } } } -impl fmt::Display for BufferUsageFlags { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 4217001..8c95cf7 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -810,12 +810,13 @@ pub fn generate_extension_constants<'a>( offset, extends, extnumber, - .. + dir: positive, } => { let ext_base = 1_000_000_000; let ext_block_size = 1000; let extnumber = extnumber.unwrap_or_else(|| extension_number); let value = ext_base + (extnumber - 1) * ext_block_size + offset; + let value = if *positive { value } else { -value }; Some((Constant::Number(value as i32), Some(extends.clone()))) } _ => None, From d5666554fc109a49d26bb262f3af6f08b380a43e Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Mon, 20 Aug 2018 23:56:33 -0700 Subject: [PATCH 074/122] Expose conversions between enums and raw values --- ash/src/vk.rs | 4500 ++++++++++++++++++++++++------------------ generator/src/lib.rs | 4 + 2 files changed, 2545 insertions(+), 1959 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 8917c52..2705cee 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -12,25 +12,25 @@ pub trait Handle { } #[macro_export] macro_rules! vk_make_version { - ( $ major : expr , $ minor : expr , $ patch : expr ) => { + ($major:expr, $minor:expr, $patch:expr) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ( $ major : expr ) => { + ($major:expr) => { ($major as uint32_t) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ( $ minor : expr ) => { + ($minor:expr) => { (($minor as uint32_t) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ( $ minor : expr ) => { + ($minor:expr) => { ($minor as uint32_t) & 0xfff }; } @@ -61,7 +61,7 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ( $ name : ident , $ all : expr , $ flag_type : ty ) => { + ($name:ident, $all:expr, $flag_type:ty) => { impl Default for $name { fn default() -> $name { $name(0) @@ -180,7 +180,7 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ( $ name : ident , $ ty : ident ) => { + ($name:ident, $ty:ident) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(uint64_t); @@ -217,7 +217,7 @@ macro_rules! handle_nondispatchable { }; } macro_rules! define_handle { - ( $ name : ident , $ ty : ident ) => { + ($name:ident, $ty:ident) => { #[repr(transparent)] #[derive(Clone, Copy, Debug)] pub struct $name(*mut u8); @@ -464,18 +464,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: - self.get_physical_device_image_format_properties, + get_physical_device_image_format_properties: self + .get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: - self.get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: self + .get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: - self.get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: self + .get_physical_device_sparse_image_format_properties, } } } @@ -3942,19 +3942,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: - self.get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: - self.get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: self + .get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: self + .get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: - self.get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: - self.get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: - self.get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: - self.get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: self + .get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: self + .get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: self + .get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: self + .get_physical_device_external_semaphore_properties, } } } @@ -5043,9 +5043,11 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }).field("pipeline_cache_uuid", &unsafe { + }) + .field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }).field("limits", &self.limits) + }) + .field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5076,7 +5078,8 @@ impl ::std::fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .finish() } } @@ -5101,11 +5104,13 @@ impl ::std::fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for LayerProperties { @@ -5162,7 +5167,8 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ) + .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5278,10 +5284,12 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }).field("memory_heap_count", &self.memory_heap_count) + }) + .field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5811,10 +5819,12 @@ impl ::std::fmt::Debug for ImageBlit { .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }).field("dst_subresource", &self.dst_subresource) + }) + .field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for ImageBlit { @@ -6228,7 +6238,8 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6932,155 +6943,202 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ).field( + ) + .field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ).field("buffer_image_granularity", &self.buffer_image_granularity) + ) + .field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ).field( + ) + .field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ).field( + ) + .field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ).field( + ) + .field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ).field( + ) + .field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ).field( + ) + .field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ).field("max_per_stage_resources", &self.max_per_stage_resources) + ) + .field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ).field( + ) + .field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ).field( + ) + .field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ).field( + ) + .field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ).field( + ) + .field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ).field( + ) + .field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ).field( + ) + .field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ).field( + ) + .field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ).field( + ) + .field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ) + .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ).field( + ) + .field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ).field( + ) + .field( "max_vertex_output_components", &self.max_vertex_output_components, - ).field( + ) + .field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ).field( + ) + .field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ).field( + ) + .field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ).field( + ) + .field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ).field( + ) + .field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ).field( + ) + .field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ).field( + ) + .field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ).field( + ) + .field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ).field( + ) + .field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ).field( + ) + .field( "max_geometry_input_components", &self.max_geometry_input_components, - ).field( + ) + .field( "max_geometry_output_components", &self.max_geometry_output_components, - ).field( + ) + .field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ).field( + ) + .field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ).field( + ) + .field( "max_fragment_input_components", &self.max_fragment_input_components, - ).field( + ) + .field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ).field( + ) + .field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ).field( + ) + .field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ).field( + ) + .field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ).field("max_compute_work_group_count", &unsafe { + ) + .field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }).field( + }) + .field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ).field("max_compute_work_group_size", &unsafe { + ) + .field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }) + .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ).field("max_draw_indirect_count", &self.max_draw_indirect_count) + ) + .field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }).field("viewport_bounds_range", &unsafe { + }) + .field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }) + .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ).field( + ) + .field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ).field( + ) + .field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ).field("min_texel_offset", &self.min_texel_offset) + ) + .field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7089,63 +7147,79 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ).field("max_framebuffer_width", &self.max_framebuffer_width) + ) + .field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ).field( + ) + .field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ).field( + ) + .field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ).field( + ) + .field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ).field("max_color_attachments", &self.max_color_attachments) + ) + .field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ).field( + ) + .field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ).field( + ) + .field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ).field( + ) + .field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ).field( + ) + .field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ).field("max_sample_mask_words", &self.max_sample_mask_words) + ) + .field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ).field("timestamp_period", &self.timestamp_period) + ) + .field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ).field("discrete_queue_priorities", &self.discrete_queue_priorities) + ) + .field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }).field("line_width_range", &unsafe { + }) + .field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }).field("point_size_granularity", &self.point_size_granularity) + }) + .field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ).field( + ) + .field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ).field("non_coherent_atom_size", &self.non_coherent_atom_size) + ) + .field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7855,7 +7929,8 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8555,11 +8630,14 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }).field("driver_uuid", &unsafe { + }) + .field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }).field("device_luid", &unsafe { + }) + .field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }).field("device_node_mask", &self.device_node_mask) + }) + .field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -9290,7 +9368,8 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }).field("subset_allocation", &self.subset_allocation) + }) + .field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9498,7 +9577,8 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }).field("modes", &self.modes) + }) + .field("modes", &self.modes) .finish() } } @@ -10592,17 +10672,21 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ).field( + ) + .field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ).field("sample_location_coordinate_range", &unsafe { + ) + .field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }).field( + }) + .field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ).field("variable_sample_locations", &self.variable_sample_locations) + ) + .field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -10894,7 +10978,8 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -10986,7 +11071,8 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -11535,6 +11621,14 @@ impl ::std::default::Default for ExternalFormatANDROID { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ImageLayout(pub(crate) i32); +impl ImageLayout { + pub fn from_raw(x: i32) -> Self { + ImageLayout(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ImageLayout { #[doc = "Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)"] pub const UNDEFINED: Self = ImageLayout(0); @@ -11558,6 +11652,14 @@ impl ImageLayout { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct AttachmentLoadOp(pub(crate) i32); +impl AttachmentLoadOp { + pub fn from_raw(x: i32) -> Self { + AttachmentLoadOp(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl AttachmentLoadOp { pub const LOAD: Self = AttachmentLoadOp(0); pub const CLEAR: Self = AttachmentLoadOp(1); @@ -11566,6 +11668,14 @@ impl AttachmentLoadOp { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct AttachmentStoreOp(pub(crate) i32); +impl AttachmentStoreOp { + pub fn from_raw(x: i32) -> Self { + AttachmentStoreOp(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl AttachmentStoreOp { pub const STORE: Self = AttachmentStoreOp(0); pub const DONT_CARE: Self = AttachmentStoreOp(1); @@ -11573,6 +11683,14 @@ impl AttachmentStoreOp { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ImageType(pub(crate) i32); +impl ImageType { + pub fn from_raw(x: i32) -> Self { + ImageType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ImageType { pub const TYPE_1D: Self = ImageType(0); pub const TYPE_2D: Self = ImageType(1); @@ -11581,6 +11699,14 @@ impl ImageType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ImageTiling(pub(crate) i32); +impl ImageTiling { + pub fn from_raw(x: i32) -> Self { + ImageTiling(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ImageTiling { pub const OPTIMAL: Self = ImageTiling(0); pub const LINEAR: Self = ImageTiling(1); @@ -11588,6 +11714,14 @@ impl ImageTiling { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ImageViewType(pub(crate) i32); +impl ImageViewType { + pub fn from_raw(x: i32) -> Self { + ImageViewType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ImageViewType { pub const TYPE_1D: Self = ImageViewType(0); pub const TYPE_2D: Self = ImageViewType(1); @@ -11600,6 +11734,14 @@ impl ImageViewType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct CommandBufferLevel(pub(crate) i32); +impl CommandBufferLevel { + pub fn from_raw(x: i32) -> Self { + CommandBufferLevel(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl CommandBufferLevel { pub const PRIMARY: Self = CommandBufferLevel(0); pub const SECONDARY: Self = CommandBufferLevel(1); @@ -11607,6 +11749,14 @@ impl CommandBufferLevel { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ComponentSwizzle(pub(crate) i32); +impl ComponentSwizzle { + pub fn from_raw(x: i32) -> Self { + ComponentSwizzle(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ComponentSwizzle { pub const IDENTITY: Self = ComponentSwizzle(0); pub const ZERO: Self = ComponentSwizzle(1); @@ -11619,6 +11769,14 @@ impl ComponentSwizzle { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DescriptorType(pub(crate) i32); +impl DescriptorType { + pub fn from_raw(x: i32) -> Self { + DescriptorType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DescriptorType { pub const SAMPLER: Self = DescriptorType(0); pub const COMBINED_IMAGE_SAMPLER: Self = DescriptorType(1); @@ -11635,6 +11793,14 @@ impl DescriptorType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct QueryType(pub(crate) i32); +impl QueryType { + pub fn from_raw(x: i32) -> Self { + QueryType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl QueryType { pub const OCCLUSION: Self = QueryType(0); #[doc = "Optional"] @@ -11644,6 +11810,14 @@ impl QueryType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct BorderColor(pub(crate) i32); +impl BorderColor { + pub fn from_raw(x: i32) -> Self { + BorderColor(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl BorderColor { pub const FLOAT_TRANSPARENT_BLACK: Self = BorderColor(0); pub const INT_TRANSPARENT_BLACK: Self = BorderColor(1); @@ -11655,6 +11829,14 @@ impl BorderColor { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct PipelineBindPoint(pub(crate) i32); +impl PipelineBindPoint { + pub fn from_raw(x: i32) -> Self { + PipelineBindPoint(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl PipelineBindPoint { pub const GRAPHICS: Self = PipelineBindPoint(0); pub const COMPUTE: Self = PipelineBindPoint(1); @@ -11662,12 +11844,28 @@ impl PipelineBindPoint { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct PipelineCacheHeaderVersion(pub(crate) i32); +impl PipelineCacheHeaderVersion { + pub fn from_raw(x: i32) -> Self { + PipelineCacheHeaderVersion(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl PipelineCacheHeaderVersion { pub const ONE: Self = PipelineCacheHeaderVersion(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct PrimitiveTopology(pub(crate) i32); +impl PrimitiveTopology { + pub fn from_raw(x: i32) -> Self { + PrimitiveTopology(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl PrimitiveTopology { pub const POINT_LIST: Self = PrimitiveTopology(0); pub const LINE_LIST: Self = PrimitiveTopology(1); @@ -11684,6 +11882,14 @@ impl PrimitiveTopology { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SharingMode(pub(crate) i32); +impl SharingMode { + pub fn from_raw(x: i32) -> Self { + SharingMode(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SharingMode { pub const EXCLUSIVE: Self = SharingMode(0); pub const CONCURRENT: Self = SharingMode(1); @@ -11691,6 +11897,14 @@ impl SharingMode { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct IndexType(pub(crate) i32); +impl IndexType { + pub fn from_raw(x: i32) -> Self { + IndexType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl IndexType { pub const UINT16: Self = IndexType(0); pub const UINT32: Self = IndexType(1); @@ -11698,6 +11912,14 @@ impl IndexType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct Filter(pub(crate) i32); +impl Filter { + pub fn from_raw(x: i32) -> Self { + Filter(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl Filter { pub const NEAREST: Self = Filter(0); pub const LINEAR: Self = Filter(1); @@ -11705,6 +11927,14 @@ impl Filter { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SamplerMipmapMode(pub(crate) i32); +impl SamplerMipmapMode { + pub fn from_raw(x: i32) -> Self { + SamplerMipmapMode(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SamplerMipmapMode { #[doc = "Choose nearest mip level"] pub const NEAREST: Self = SamplerMipmapMode(0); @@ -11714,6 +11944,14 @@ impl SamplerMipmapMode { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SamplerAddressMode(pub(crate) i32); +impl SamplerAddressMode { + pub fn from_raw(x: i32) -> Self { + SamplerAddressMode(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SamplerAddressMode { pub const REPEAT: Self = SamplerAddressMode(0); pub const MIRRORED_REPEAT: Self = SamplerAddressMode(1); @@ -11723,6 +11961,14 @@ impl SamplerAddressMode { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct CompareOp(pub(crate) i32); +impl CompareOp { + pub fn from_raw(x: i32) -> Self { + CompareOp(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl CompareOp { pub const NEVER: Self = CompareOp(0); pub const LESS: Self = CompareOp(1); @@ -11736,6 +11982,14 @@ impl CompareOp { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct PolygonMode(pub(crate) i32); +impl PolygonMode { + pub fn from_raw(x: i32) -> Self { + PolygonMode(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl PolygonMode { pub const FILL: Self = PolygonMode(0); pub const LINE: Self = PolygonMode(1); @@ -11744,6 +11998,14 @@ impl PolygonMode { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct FrontFace(pub(crate) i32); +impl FrontFace { + pub fn from_raw(x: i32) -> Self { + FrontFace(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl FrontFace { pub const COUNTER_CLOCKWISE: Self = FrontFace(0); pub const CLOCKWISE: Self = FrontFace(1); @@ -11751,6 +12013,14 @@ impl FrontFace { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct BlendFactor(pub(crate) i32); +impl BlendFactor { + pub fn from_raw(x: i32) -> Self { + BlendFactor(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl BlendFactor { pub const ZERO: Self = BlendFactor(0); pub const ONE: Self = BlendFactor(1); @@ -11775,6 +12045,14 @@ impl BlendFactor { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct BlendOp(pub(crate) i32); +impl BlendOp { + pub fn from_raw(x: i32) -> Self { + BlendOp(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl BlendOp { pub const ADD: Self = BlendOp(0); pub const SUBTRACT: Self = BlendOp(1); @@ -11785,6 +12063,14 @@ impl BlendOp { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct StencilOp(pub(crate) i32); +impl StencilOp { + pub fn from_raw(x: i32) -> Self { + StencilOp(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl StencilOp { pub const KEEP: Self = StencilOp(0); pub const ZERO: Self = StencilOp(1); @@ -11798,6 +12084,14 @@ impl StencilOp { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct LogicOp(pub(crate) i32); +impl LogicOp { + pub fn from_raw(x: i32) -> Self { + LogicOp(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl LogicOp { pub const CLEAR: Self = LogicOp(0); pub const AND: Self = LogicOp(1); @@ -11819,12 +12113,28 @@ impl LogicOp { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct InternalAllocationType(pub(crate) i32); +impl InternalAllocationType { + pub fn from_raw(x: i32) -> Self { + InternalAllocationType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl InternalAllocationType { pub const EXECUTABLE: Self = InternalAllocationType(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SystemAllocationScope(pub(crate) i32); +impl SystemAllocationScope { + pub fn from_raw(x: i32) -> Self { + SystemAllocationScope(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SystemAllocationScope { pub const COMMAND: Self = SystemAllocationScope(0); pub const OBJECT: Self = SystemAllocationScope(1); @@ -11835,6 +12145,14 @@ impl SystemAllocationScope { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct PhysicalDeviceType(pub(crate) i32); +impl PhysicalDeviceType { + pub fn from_raw(x: i32) -> Self { + PhysicalDeviceType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl PhysicalDeviceType { pub const OTHER: Self = PhysicalDeviceType(0); pub const INTEGRATED_GPU: Self = PhysicalDeviceType(1); @@ -11845,6 +12163,14 @@ impl PhysicalDeviceType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct VertexInputRate(pub(crate) i32); +impl VertexInputRate { + pub fn from_raw(x: i32) -> Self { + VertexInputRate(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl VertexInputRate { pub const VERTEX: Self = VertexInputRate(0); pub const INSTANCE: Self = VertexInputRate(1); @@ -11852,6 +12178,14 @@ impl VertexInputRate { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct Format(pub(crate) i32); +impl Format { + pub fn from_raw(x: i32) -> Self { + Format(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl Format { pub const UNDEFINED: Self = Format(0); pub const R4G4_UNORM_PACK8: Self = Format(1); @@ -12042,6 +12376,14 @@ impl Format { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct StructureType(pub(crate) i32); +impl StructureType { + pub fn from_raw(x: i32) -> Self { + StructureType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl StructureType { pub const APPLICATION_INFO: Self = StructureType(0); pub const INSTANCE_CREATE_INFO: Self = StructureType(1); @@ -12098,6 +12440,14 @@ impl StructureType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SubpassContents(pub(crate) i32); +impl SubpassContents { + pub fn from_raw(x: i32) -> Self { + SubpassContents(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SubpassContents { pub const INLINE: Self = SubpassContents(0); pub const SECONDARY_COMMAND_BUFFERS: Self = SubpassContents(1); @@ -12105,6 +12455,14 @@ impl SubpassContents { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct Result(pub(crate) i32); +impl Result { + pub fn from_raw(x: i32) -> Self { + Result(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl Result { #[doc = "Command completed successfully"] pub const SUCCESS: Self = Result(0); @@ -12222,6 +12580,14 @@ impl fmt::Display for Result { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DynamicState(pub(crate) i32); +impl DynamicState { + pub fn from_raw(x: i32) -> Self { + DynamicState(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DynamicState { pub const VIEWPORT: Self = DynamicState(0); pub const SCISSOR: Self = DynamicState(1); @@ -12236,6 +12602,14 @@ impl DynamicState { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DescriptorUpdateTemplateType(pub(crate) i32); +impl DescriptorUpdateTemplateType { + pub fn from_raw(x: i32) -> Self { + DescriptorUpdateTemplateType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DescriptorUpdateTemplateType { #[doc = "Create descriptor update template for descriptor set updates"] pub const DESCRIPTOR_SET: Self = DescriptorUpdateTemplateType(0); @@ -12243,6 +12617,14 @@ impl DescriptorUpdateTemplateType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ObjectType(pub(crate) i32); +impl ObjectType { + pub fn from_raw(x: i32) -> Self { + ObjectType(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ObjectType { pub const UNKNOWN: Self = ObjectType(0); #[doc = "VkInstance"] @@ -12299,6 +12681,14 @@ impl ObjectType { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct PresentModeKHR(pub(crate) i32); +impl PresentModeKHR { + pub fn from_raw(x: i32) -> Self { + PresentModeKHR(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl PresentModeKHR { pub const IMMEDIATE: Self = PresentModeKHR(0); pub const MAILBOX: Self = PresentModeKHR(1); @@ -12308,12 +12698,28 @@ impl PresentModeKHR { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ColorSpaceKHR(pub(crate) i32); +impl ColorSpaceKHR { + pub fn from_raw(x: i32) -> Self { + ColorSpaceKHR(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ColorSpaceKHR { pub const SRGB_NONLINEAR: Self = ColorSpaceKHR(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DebugReportObjectTypeEXT(pub(crate) i32); +impl DebugReportObjectTypeEXT { + pub fn from_raw(x: i32) -> Self { + DebugReportObjectTypeEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DebugReportObjectTypeEXT { pub const UNKNOWN: Self = DebugReportObjectTypeEXT(0); pub const INSTANCE: Self = DebugReportObjectTypeEXT(1); @@ -12353,6 +12759,14 @@ impl DebugReportObjectTypeEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct RasterizationOrderAMD(pub(crate) i32); +impl RasterizationOrderAMD { + pub fn from_raw(x: i32) -> Self { + RasterizationOrderAMD(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl RasterizationOrderAMD { pub const STRICT: Self = RasterizationOrderAMD(0); pub const RELAXED: Self = RasterizationOrderAMD(1); @@ -12360,6 +12774,14 @@ impl RasterizationOrderAMD { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ValidationCheckEXT(pub(crate) i32); +impl ValidationCheckEXT { + pub fn from_raw(x: i32) -> Self { + ValidationCheckEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ValidationCheckEXT { pub const ALL: Self = ValidationCheckEXT(0); pub const SHADERS: Self = ValidationCheckEXT(1); @@ -12367,6 +12789,14 @@ impl ValidationCheckEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct IndirectCommandsTokenTypeNVX(pub(crate) i32); +impl IndirectCommandsTokenTypeNVX { + pub fn from_raw(x: i32) -> Self { + IndirectCommandsTokenTypeNVX(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl IndirectCommandsTokenTypeNVX { pub const PIPELINE: Self = IndirectCommandsTokenTypeNVX(0); pub const DESCRIPTOR_SET: Self = IndirectCommandsTokenTypeNVX(1); @@ -12380,6 +12810,14 @@ impl IndirectCommandsTokenTypeNVX { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ObjectEntryTypeNVX(pub(crate) i32); +impl ObjectEntryTypeNVX { + pub fn from_raw(x: i32) -> Self { + ObjectEntryTypeNVX(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ObjectEntryTypeNVX { pub const DESCRIPTOR_SET: Self = ObjectEntryTypeNVX(0); pub const PIPELINE: Self = ObjectEntryTypeNVX(1); @@ -12390,6 +12828,14 @@ impl ObjectEntryTypeNVX { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DisplayPowerStateEXT(pub(crate) i32); +impl DisplayPowerStateEXT { + pub fn from_raw(x: i32) -> Self { + DisplayPowerStateEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DisplayPowerStateEXT { pub const OFF: Self = DisplayPowerStateEXT(0); pub const SUSPEND: Self = DisplayPowerStateEXT(1); @@ -12398,18 +12844,42 @@ impl DisplayPowerStateEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DeviceEventTypeEXT(pub(crate) i32); +impl DeviceEventTypeEXT { + pub fn from_raw(x: i32) -> Self { + DeviceEventTypeEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DeviceEventTypeEXT { pub const DISPLAY_HOTPLUG: Self = DeviceEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DisplayEventTypeEXT(pub(crate) i32); +impl DisplayEventTypeEXT { + pub fn from_raw(x: i32) -> Self { + DisplayEventTypeEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DisplayEventTypeEXT { pub const FIRST_PIXEL_OUT: Self = DisplayEventTypeEXT(0); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); +impl ViewportCoordinateSwizzleNV { + pub fn from_raw(x: i32) -> Self { + ViewportCoordinateSwizzleNV(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ViewportCoordinateSwizzleNV { pub const POSITIVE_X: Self = ViewportCoordinateSwizzleNV(0); pub const NEGATIVE_X: Self = ViewportCoordinateSwizzleNV(1); @@ -12423,6 +12893,14 @@ impl ViewportCoordinateSwizzleNV { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct DiscardRectangleModeEXT(pub(crate) i32); +impl DiscardRectangleModeEXT { + pub fn from_raw(x: i32) -> Self { + DiscardRectangleModeEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl DiscardRectangleModeEXT { pub const INCLUSIVE: Self = DiscardRectangleModeEXT(0); pub const EXCLUSIVE: Self = DiscardRectangleModeEXT(1); @@ -12430,6 +12908,14 @@ impl DiscardRectangleModeEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct PointClippingBehavior(pub(crate) i32); +impl PointClippingBehavior { + pub fn from_raw(x: i32) -> Self { + PointClippingBehavior(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl PointClippingBehavior { pub const ALL_CLIP_PLANES: Self = PointClippingBehavior(0); pub const USER_CLIP_PLANES_ONLY: Self = PointClippingBehavior(1); @@ -12437,6 +12923,14 @@ impl PointClippingBehavior { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SamplerReductionModeEXT(pub(crate) i32); +impl SamplerReductionModeEXT { + pub fn from_raw(x: i32) -> Self { + SamplerReductionModeEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SamplerReductionModeEXT { pub const WEIGHTED_AVERAGE: Self = SamplerReductionModeEXT(0); pub const MIN: Self = SamplerReductionModeEXT(1); @@ -12445,6 +12939,14 @@ impl SamplerReductionModeEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct TessellationDomainOrigin(pub(crate) i32); +impl TessellationDomainOrigin { + pub fn from_raw(x: i32) -> Self { + TessellationDomainOrigin(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl TessellationDomainOrigin { pub const UPPER_LEFT: Self = TessellationDomainOrigin(0); pub const LOWER_LEFT: Self = TessellationDomainOrigin(1); @@ -12452,6 +12954,14 @@ impl TessellationDomainOrigin { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SamplerYcbcrModelConversion(pub(crate) i32); +impl SamplerYcbcrModelConversion { + pub fn from_raw(x: i32) -> Self { + SamplerYcbcrModelConversion(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SamplerYcbcrModelConversion { pub const RGB_IDENTITY: Self = SamplerYcbcrModelConversion(0); #[doc = "just range expansion"] @@ -12466,6 +12976,14 @@ impl SamplerYcbcrModelConversion { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct SamplerYcbcrRange(pub(crate) i32); +impl SamplerYcbcrRange { + pub fn from_raw(x: i32) -> Self { + SamplerYcbcrRange(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl SamplerYcbcrRange { #[doc = "Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)"] pub const ITU_FULL: Self = SamplerYcbcrRange(0); @@ -12475,6 +12993,14 @@ impl SamplerYcbcrRange { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ChromaLocation(pub(crate) i32); +impl ChromaLocation { + pub fn from_raw(x: i32) -> Self { + ChromaLocation(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ChromaLocation { pub const COSITED_EVEN: Self = ChromaLocation(0); pub const MIDPOINT: Self = ChromaLocation(1); @@ -12482,6 +13008,14 @@ impl ChromaLocation { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct BlendOverlapEXT(pub(crate) i32); +impl BlendOverlapEXT { + pub fn from_raw(x: i32) -> Self { + BlendOverlapEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl BlendOverlapEXT { pub const UNCORRELATED: Self = BlendOverlapEXT(0); pub const DISJOINT: Self = BlendOverlapEXT(1); @@ -12490,6 +13024,14 @@ impl BlendOverlapEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct CoverageModulationModeNV(pub(crate) i32); +impl CoverageModulationModeNV { + pub fn from_raw(x: i32) -> Self { + CoverageModulationModeNV(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl CoverageModulationModeNV { pub const NONE: Self = CoverageModulationModeNV(0); pub const RGB: Self = CoverageModulationModeNV(1); @@ -12499,12 +13041,28 @@ impl CoverageModulationModeNV { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); +impl ValidationCacheHeaderVersionEXT { + pub fn from_raw(x: i32) -> Self { + ValidationCacheHeaderVersionEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ValidationCacheHeaderVersionEXT { pub const ONE: Self = ValidationCacheHeaderVersionEXT(1); } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ShaderInfoTypeAMD(pub(crate) i32); +impl ShaderInfoTypeAMD { + pub fn from_raw(x: i32) -> Self { + ShaderInfoTypeAMD(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ShaderInfoTypeAMD { pub const STATISTICS: Self = ShaderInfoTypeAMD(0); pub const BINARY: Self = ShaderInfoTypeAMD(1); @@ -12513,6 +13071,14 @@ impl ShaderInfoTypeAMD { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct QueueGlobalPriorityEXT(pub(crate) i32); +impl QueueGlobalPriorityEXT { + pub fn from_raw(x: i32) -> Self { + QueueGlobalPriorityEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl QueueGlobalPriorityEXT { pub const LOW: Self = QueueGlobalPriorityEXT(128); pub const MEDIUM: Self = QueueGlobalPriorityEXT(256); @@ -12522,6 +13088,14 @@ impl QueueGlobalPriorityEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ConservativeRasterizationModeEXT(pub(crate) i32); +impl ConservativeRasterizationModeEXT { + pub fn from_raw(x: i32) -> Self { + ConservativeRasterizationModeEXT(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl ConservativeRasterizationModeEXT { pub const DISABLED: Self = ConservativeRasterizationModeEXT(0); pub const OVERESTIMATE: Self = ConservativeRasterizationModeEXT(1); @@ -12530,6 +13104,14 @@ impl ConservativeRasterizationModeEXT { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct VendorId(pub(crate) i32); +impl VendorId { + pub fn from_raw(x: i32) -> Self { + VendorId(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} impl VendorId { #[doc = "Vivante vendor ID"] pub const VIV: Self = VendorId(0x10001); @@ -13340,12 +13922,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: - self.get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: self + .get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: - self.get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: self + .get_physical_device_surface_present_modes_khr, } } } @@ -13494,12 +14076,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -13806,10 +14388,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: - self.get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: - self.get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: self + .get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: self + .get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14092,8 +14674,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: - self.get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: self + .get_physical_device_xlib_presentation_support_khr, } } } @@ -14178,8 +14760,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: - self.get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: self + .get_physical_device_xcb_presentation_support_khr, } } } @@ -14264,8 +14846,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: - self.get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: self + .get_physical_device_wayland_presentation_support_khr, } } } @@ -14347,8 +14929,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: - self.get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: self + .get_physical_device_mir_presentation_support_khr, } } } @@ -14483,8 +15065,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: - self.get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: self + .get_physical_device_win32_presentation_support_khr, } } } @@ -16050,8 +16632,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: - self.get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: self + .get_physical_device_external_image_format_properties_nv, } } } @@ -16244,12 +16826,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17061,8 +17643,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17248,8 +17830,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17363,8 +17945,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: - self.get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: self + .get_physical_device_generated_commands_properties_nvx, } } } @@ -17804,8 +18386,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: - self.get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: self + .get_physical_device_surface_capabilities2_ext, } } } @@ -18956,8 +19538,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: - self.get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: self + .get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19088,10 +19670,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: - self.get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: - self.get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: self + .get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: self + .get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -19727,10 +20309,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: - self.get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: - self.get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: self + .get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: self + .get_memory_android_hardware_buffer_android, } } } @@ -20131,8 +20713,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: - self.get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: self + .get_physical_device_multisample_properties_ext, } } } @@ -22827,138 +23409,75 @@ fn display_flags( } Ok(()) } -impl fmt::Display for SamplerMipmapMode { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorPoolCreateFlags { +impl fmt::Display for ExternalMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", ), ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -22974,93 +23493,39 @@ impl fmt::Display for DebugReportFlagsEXT { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { +impl fmt::Display for SurfaceTransformFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { +impl fmt::Display for SamplerYcbcrRange { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -23070,6 +23535,129 @@ impl fmt::Display for SamplerYcbcrModelConversion { } } } +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -23119,211 +23707,15 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for ImageCreateFlags { +impl fmt::Display for StencilFaceFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), ]; display_flags(f, KNOWN, self.0) } @@ -23337,13 +23729,22 @@ impl fmt::Display for CommandBufferResetFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueueGlobalPriorityEXT { +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), _ => None, }; if let Some(x) = name { @@ -23353,12 +23754,39 @@ impl fmt::Display for QueueGlobalPriorityEXT { } } } -impl fmt::Display for VendorId { +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { @@ -23368,21 +23796,20 @@ impl fmt::Display for VendorId { } } } -impl fmt::Display for SystemAllocationScope { +impl fmt::Display for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for ColorComponentFlags { @@ -23396,24 +23823,6 @@ impl fmt::Display for ColorComponentFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -23441,60 +23850,13 @@ impl fmt::Display for ExternalSemaphoreHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BlendOp { +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), _ => None, }; if let Some(x) = name { @@ -23504,88 +23866,12 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), _ => None, }; if let Some(x) = name { @@ -23595,315 +23881,187 @@ impl fmt::Display for RasterizationOrderAMD { } } } -impl fmt::Display for AttachmentLoadOp { +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOAD => Some("LOAD"), Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), _ => None, }; if let Some(x) = name { @@ -23970,73 +24128,25 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ChromaLocation { +impl fmt::Display for DescriptorUpdateTemplateType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), _ => None, }; if let Some(x) = name { @@ -24046,11 +24156,21 @@ impl fmt::Display for ChromaLocation { } } } -impl fmt::Display for DiscardRectangleModeEXT { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), _ => None, }; if let Some(x) = name { @@ -24060,11 +24180,12 @@ impl fmt::Display for DiscardRectangleModeEXT { } } } -impl fmt::Display for ImageTiling { +impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -24074,17 +24195,220 @@ impl fmt::Display for ImageTiling { } } } -impl fmt::Display for QueryResultFlags { +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24099,12 +24423,24 @@ impl fmt::Display for PipelineBindPoint { } } } -impl fmt::Display for QueryType { +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -24114,13 +24450,11 @@ impl fmt::Display for QueryType { } } } -impl fmt::Display for CoverageModulationModeNV { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -24130,11 +24464,127 @@ impl fmt::Display for CoverageModulationModeNV { } } } -impl fmt::Display for FrontFace { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), _ => None, }; if let Some(x) = name { @@ -24179,558 +24629,13 @@ impl fmt::Display for BufferUsageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryHeapFlags { +impl fmt::Display for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), ]; display_flags(f, KNOWN, self.0) } @@ -24783,289 +24688,6 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25506,25 +25128,45 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for SemaphoreImportFlags { +impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FenceImportFlags { +impl fmt::Display for CullModeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PolygonMode { +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -25534,12 +25176,952 @@ impl fmt::Display for PolygonMode { } } } -impl fmt::Display for CommandPoolResetFlags { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 8c95cf7..47ea4ad 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1037,6 +1037,10 @@ pub fn generate_enum<'a>( #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct #ident(pub(crate) i32); + impl #ident { + pub fn from_raw(x: i32) -> Self { #ident(x) } + pub fn as_raw(self) -> i32 { self.0 } + } #impl_block }; let special_quote = match _name.as_str() { From b5651ed3513ce7f32f6931f4e3547e06c4eefd32 Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Tue, 21 Aug 2018 16:04:57 +0300 Subject: [PATCH 075/122] Export the DebugUtils extension --- ash/src/extensions/mod.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ash/src/extensions/mod.rs b/ash/src/extensions/mod.rs index bf9b023..db61e32 100644 --- a/ash/src/extensions/mod.rs +++ b/ash/src/extensions/mod.rs @@ -1,6 +1,7 @@ pub use self::android_surface::AndroidSurface; pub use self::debug_marker::DebugMarker; pub use self::debug_report::DebugReport; +pub use self::debug_utils::DebugUtils; pub use self::display_swapchain::DisplaySwapchain; pub use self::ios_surface::IOSSurface; pub use self::macos_surface::MacOSSurface; @@ -15,6 +16,7 @@ pub use self::xlib_surface::XlibSurface; mod android_surface; mod debug_marker; mod debug_report; +mod debug_utils; mod display_swapchain; mod ios_surface; mod macos_surface; @@ -25,4 +27,3 @@ mod wayland_surface; mod win32_surface; mod xcb_surface; mod xlib_surface; -mod debug_utils; From b1451747b54ccfa0cec13eeb4a4b21d1ec6b364c Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Tue, 21 Aug 2018 21:14:10 -0700 Subject: [PATCH 076/122] Expose cmd_copy_query_pool_results --- ash/src/device.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/ash/src/device.rs b/ash/src/device.rs index 960fe20..e562b0d 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -862,6 +862,29 @@ pub trait DeviceV1_0 { ); } + unsafe fn cmd_copy_query_pool_results( + &self, + command_buffer: vk::CommandBuffer, + query_pool: vk::QueryPool, + first_query: vk::uint32_t, + query_count: vk::uint32_t, + dst_buffer: vk::Buffer, + dst_offset: vk::DeviceSize, + stride: vk::DeviceSize, + flags: vk::QueryResultFlags, + ) { + self.fp_v1_0().cmd_copy_query_pool_results( + command_buffer, + query_pool, + first_query, + query_count, + dst_buffer, + dst_offset, + stride, + flags, + ); + } + unsafe fn cmd_push_constants( &self, command_buffer: vk::CommandBuffer, From a0424596a54acd8e0a587d9b6834be3e752bc43e Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Tue, 21 Aug 2018 00:24:01 -0700 Subject: [PATCH 077/122] More robust Display for flags types Fixes strange behavior if a Vulkan flags constant setting multiple bits is defined prior to that which sets only one of those bits. --- ash/src/vk.rs | 2970 +++++++++++++++++++++--------------------- generator/src/lib.rs | 2 +- 2 files changed, 1486 insertions(+), 1486 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 2705cee..5dece39 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -23392,7 +23392,7 @@ fn display_flags( let mut first = true; let mut accum = value; for (bit, name) in known { - if accum & bit != 0 { + if *bit != 0 && accum & *bit == *bit { if !first { f.write_str(" | ")?; } @@ -23409,12 +23409,116 @@ fn display_flags( } Ok(()) } -impl fmt::Display for CommandPoolResetFlags { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; display_flags(f, KNOWN, self.0) } } @@ -23432,43 +23536,13 @@ impl fmt::Display for DisplayPlaneAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), _ => None, }; if let Some(x) = name { @@ -23478,54 +23552,10 @@ impl fmt::Display for BlendOverlapEXT { } } } -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { +impl fmt::Display for DescriptorUpdateTemplateType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), _ => None, }; if let Some(x) = name { @@ -23535,11 +23565,11 @@ impl fmt::Display for SamplerYcbcrRange { } } } -impl fmt::Display for ValidationCheckEXT { +impl fmt::Display for FrontFace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), _ => None, }; if let Some(x) = name { @@ -23549,46 +23579,14 @@ impl fmt::Display for ValidationCheckEXT { } } } -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TessellationDomainOrigin { +impl fmt::Display for SystemAllocationScope { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), _ => None, }; if let Some(x) = name { @@ -23598,64 +23596,33 @@ impl fmt::Display for TessellationDomainOrigin { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { +impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } impl fmt::Display for ObjectType { @@ -23707,44 +23674,173 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageTiling { +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), _ => None, }; if let Some(x) = name { @@ -23777,16 +23873,26 @@ impl fmt::Display for ExternalFenceHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageViewType { +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), _ => None, }; if let Some(x) = name { @@ -23796,67 +23902,17 @@ impl fmt::Display for ImageViewType { } } } -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { +impl fmt::Display for IndirectCommandsTokenTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), _ => None, }; if let Some(x) = name { @@ -23866,12 +23922,22 @@ impl fmt::Display for QueueGlobalPriorityEXT { } } } -impl fmt::Display for QueryType { +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), _ => None, }; if let Some(x) = name { @@ -23881,34 +23947,84 @@ impl fmt::Display for QueryType { } } } -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", ), ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", ), ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryHeapFlags { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), ]; display_flags(f, KNOWN, self.0) } @@ -23928,27 +24044,22 @@ impl fmt::Display for ExternalSemaphoreFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FrontFace { +impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PolygonMode { +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), _ => None, }; if let Some(x) = name { @@ -23964,36 +24075,6 @@ impl fmt::Display for AttachmentDescriptionFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24014,139 +24095,14 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -24156,21 +24112,11 @@ impl fmt::Display for DescriptorUpdateTemplateType { } } } -impl fmt::Display for DynamicState { +impl fmt::Display for SamplerYcbcrRange { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -24180,158 +24126,31 @@ impl fmt::Display for DynamicState { } } } -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", ), ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageLayout { +impl fmt::Display for QueueFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for BorderColor { @@ -24352,294 +24171,6 @@ impl fmt::Display for BorderColor { } } } -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24688,6 +24219,764 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25128,45 +25417,86 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for ShaderStageFlags { +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CullModeFlags { +impl fmt::Display for DescriptorSetLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), _ => None, }; if let Some(x) = name { @@ -25191,89 +25521,102 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for SubgroupFeatureFlags { +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { +impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", ), ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", ), ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompareOp { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), _ => None, }; if let Some(x) = name { @@ -25283,131 +25626,35 @@ impl fmt::Display for CompareOp { } } } -impl fmt::Display for PipelineCreateFlags { +impl fmt::Display for DescriptorPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", ), ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25692,40 +25939,76 @@ impl fmt::Display for PhysicalDeviceType { } } } -impl fmt::Display for ImageAspectFlags { +impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SampleCountFlags { +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerReductionModeEXT { +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { @@ -25735,10 +26018,12 @@ impl fmt::Display for SamplerReductionModeEXT { } } } -impl fmt::Display for DisplayEventTypeEXT { +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), _ => None, }; if let Some(x) = name { @@ -25748,191 +26033,7 @@ impl fmt::Display for DisplayEventTypeEXT { } } } -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::ONE => Some("ONE"), @@ -25945,183 +26046,82 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for DescriptorBindingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryPipelineStatisticFlags { +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", ), ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 47ea4ad..5afc9a8 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1515,7 +1515,7 @@ pub fn generate_const_displays<'a>(const_values: &HashMap>) -> let mut first = true; let mut accum = value; for (bit, name) in known { - if accum & bit != 0 { + if *bit != 0 && accum & *bit == *bit { if !first { f.write_str(" | ")?; } f.write_str(name)?; first = false; From 22cce9be30304c5fb81ae8b5715c2e8647fa88b8 Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Wed, 22 Aug 2018 10:06:03 +0300 Subject: [PATCH 078/122] Export the Vk 1.1 traits --- ash/src/version.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ash/src/version.rs b/ash/src/version.rs index bc1ed91..3aa6833 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -1,6 +1,6 @@ -pub use device::DeviceV1_0; +pub use device::{DeviceV1_0, DeviceV1_1}; pub use entry::EntryV1_0; -pub use instance::InstanceV1_0; +pub use instance::{InstanceV1_0, InstanceV1_1}; use std::mem; use vk; pub trait FunctionPointers { From 15839ddc4e2be1acf425742fcfcb606cb4aa7f5f Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Wed, 22 Aug 2018 10:24:50 +0300 Subject: [PATCH 079/122] Move enumerate_instance_version to Entry Also adds `EntryV1_1` trait # Conflicts: # ash/src/version.rs --- ash/src/entry.rs | 14 ++++++++++++++ ash/src/instance.rs | 9 --------- ash/src/version.rs | 2 +- generator/src/lib.rs | 3 ++- 4 files changed, 17 insertions(+), 11 deletions(-) diff --git a/ash/src/entry.rs b/ash/src/entry.rs index b4d0590..3513755 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -170,3 +170,17 @@ impl Entry { }) } } + +#[allow(non_camel_case_types)] +pub trait EntryV1_1: EntryV1_0 { + fn fp_v1_1(&self) -> &vk::EntryFnV1_1; + + unsafe fn enumerate_instance_version(&self) -> VkResult { + let mut api_version = mem::uninitialized(); + let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version); + match err_code { + vk::Result::SUCCESS => Ok(api_version), + _ => Err(err_code), + } + } +} diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 151b6c5..50c459a 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -86,15 +86,6 @@ impl Instance { pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; - unsafe fn enumerate_instance_version(&self) -> VkResult { - let mut api_version = mem::uninitialized(); - let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version); - match err_code { - vk::Result::SUCCESS => Ok(api_version), - _ => Err(err_code), - } - } - fn enumerate_physical_device_groups(&self) -> VkResult> { unsafe { let mut group_count = mem::uninitialized(); diff --git a/ash/src/version.rs b/ash/src/version.rs index 3aa6833..a4033e3 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -1,5 +1,5 @@ pub use device::{DeviceV1_0, DeviceV1_1}; -pub use entry::EntryV1_0; +pub use entry::{EntryV1_0, EntryV1_1}; pub use instance::{InstanceV1_0, InstanceV1_1}; use std::mem; use vk; diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 47ea4ad..80fb916 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -540,7 +540,8 @@ impl CommandExt for vkxml::Command { "vkGetInstanceProcAddr" => FunctionType::Static, "vkCreateInstance" | "vkEnumerateInstanceLayerProperties" - | "vkEnumerateInstanceExtensionProperties" => FunctionType::Entry, + | "vkEnumerateInstanceExtensionProperties" + | "vkEnumerateInstanceVersion" => FunctionType::Entry, // This is actually not a device level function "vkGetDeviceProcAddr" => FunctionType::Instance, _ => { From 67ea40b30c138fe15a4e34527bb10c6a0850fa10 Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Wed, 22 Aug 2018 10:33:58 +0300 Subject: [PATCH 080/122] Regenerate vk.rs --- ash/src/vk.rs | 37 ++++++++++++++++++++----------------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 2705cee..41e6954 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -3844,12 +3844,16 @@ impl DeviceFnV1_0 { (self.cmd_execute_commands)(command_buffer, command_buffer_count, p_command_buffers) } } -pub struct EntryFnV1_1 {} +pub struct EntryFnV1_1 { + enumerate_instance_version: extern "system" fn(p_api_version: *mut uint32_t) -> Result, +} unsafe impl Send for EntryFnV1_1 {} unsafe impl Sync for EntryFnV1_1 {} impl ::std::clone::Clone for EntryFnV1_1 { fn clone(&self) -> Self { - EntryFnV1_1 {} + EntryFnV1_1 { + enumerate_instance_version: self.enumerate_instance_version, + } } } impl EntryFnV1_1 { @@ -3858,16 +3862,28 @@ impl EntryFnV1_1 { F: FnMut(&::std::ffi::CStr) -> *const c_void, { let mut _err_str = Vec::new(); - let s = EntryFnV1_1 {}; + let s = EntryFnV1_1 { + enumerate_instance_version: unsafe { + let raw_name = stringify!(vkEnumerateInstanceVersion); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; if _err_str.is_empty() { Ok(s) } else { Err(_err_str) } } + pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut uint32_t) -> Result { + (self.enumerate_instance_version)(p_api_version) + } } pub struct InstanceFnV1_1 { - enumerate_instance_version: extern "system" fn(p_api_version: *mut uint32_t) -> Result, enumerate_physical_device_groups: extern "system" fn( instance: Instance, @@ -3937,7 +3953,6 @@ unsafe impl Sync for InstanceFnV1_1 {} impl ::std::clone::Clone for InstanceFnV1_1 { fn clone(&self) -> Self { InstanceFnV1_1 { - enumerate_instance_version: self.enumerate_instance_version, enumerate_physical_device_groups: self.enumerate_physical_device_groups, get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, @@ -3965,15 +3980,6 @@ impl InstanceFnV1_1 { { let mut _err_str = Vec::new(); let s = InstanceFnV1_1 { - enumerate_instance_version: unsafe { - let raw_name = stringify!(vkEnumerateInstanceVersion); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, enumerate_physical_device_groups: unsafe { let raw_name = stringify!(vkEnumeratePhysicalDeviceGroups); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -4080,9 +4086,6 @@ impl InstanceFnV1_1 { Err(_err_str) } } - pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut uint32_t) -> Result { - (self.enumerate_instance_version)(p_api_version) - } pub unsafe fn enumerate_physical_device_groups( &self, instance: Instance, From ce6820f92367e018e5224753cd53325cfe83ffce Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Wed, 22 Aug 2018 10:49:41 +0300 Subject: [PATCH 081/122] Add traits and FP loading for Entry 1.1 --- ash/src/entry.rs | 18 +++++++++++++++++- ash/src/version.rs | 28 +++++++++++++++++++++++++++- 2 files changed, 44 insertions(+), 2 deletions(-) diff --git a/ash/src/entry.rs b/ash/src/entry.rs index 3513755..b91a3d9 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -6,7 +6,7 @@ use std::fmt; use std::mem; use std::path::Path; use std::ptr; -use version::{EntryLoader, FunctionPointers, InstanceLoader, V1_0}; +use version::{EntryLoader, FunctionPointers, InstanceLoader, V1_0, V1_1}; use vk; use RawPtr; @@ -150,6 +150,22 @@ impl EntryV1_0 for Entry { } } +impl EntryV1_0 for Entry { + type Fp = V1_1; + fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { + self.entry_fn.fp_v1_0() + } + fn static_fn(&self) -> &vk::StaticFn { + &self.static_fn + } +} + +impl EntryV1_1 for Entry { + fn fp_v1_1(&self) -> &vk::EntryFnV1_1 { + &self.entry_fn.entry_fn_1_1 + } +} + impl Entry { pub fn new() -> Result { let lib = VK_LIB diff --git a/ash/src/version.rs b/ash/src/version.rs index a4033e3..710c5ee 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -15,7 +15,7 @@ pub struct V1_1; impl FunctionPointers for V1_1 { type InstanceFp = InstanceFpV1_1; type DeviceFp = DeviceFpV1_1; - type EntryFp = EntryFpV1_0; + type EntryFp = EntryFpV1_1; } #[allow(non_camel_case_types)] @@ -50,6 +50,32 @@ pub trait EntryLoader: Sized { unsafe fn load(static_fn: &vk::StaticFn) -> Result>; } +#[allow(non_camel_case_types)] +#[derive(Clone)] +pub struct EntryFpV1_1 { + pub entry_fn_1_0: vk::EntryFnV1_0, + pub entry_fn_1_1: vk::EntryFnV1_1, +} + +impl EntryLoader for EntryFpV1_1 { + fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { + &self.entry_fn_1_0 + } + unsafe fn load(static_fn: &vk::StaticFn) -> Result> { + let entry_fn_1_0 = vk::EntryFnV1_0::load(|name| { + mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) + })?; + let entry_fn_1_1 = vk::EntryFnV1_1::load(|name| { + mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) + })?; + + Ok(EntryFpV1_1 { + entry_fn_1_0, + entry_fn_1_1, + }) + } +} + pub trait InstanceLoader: Sized { unsafe fn load( static_fn: &vk::StaticFn, From c4d92d410b272a4b98af1aa90c2ab803b8999d05 Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Wed, 22 Aug 2018 10:51:05 +0300 Subject: [PATCH 082/122] Make enumerate_instance_version safe --- ash/src/entry.rs | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/ash/src/entry.rs b/ash/src/entry.rs index b91a3d9..3552ab6 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -191,12 +191,14 @@ impl Entry { pub trait EntryV1_1: EntryV1_0 { fn fp_v1_1(&self) -> &vk::EntryFnV1_1; - unsafe fn enumerate_instance_version(&self) -> VkResult { - let mut api_version = mem::uninitialized(); - let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version); - match err_code { - vk::Result::SUCCESS => Ok(api_version), - _ => Err(err_code), + fn enumerate_instance_version(&self) -> VkResult { + unsafe { + let mut api_version = 0; + let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version); + match err_code { + vk::Result::SUCCESS => Ok(api_version), + _ => Err(err_code), + } } } } From 7e505347f47bfd0f73710210c08613d78fa7b1ea Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Wed, 22 Aug 2018 22:53:17 +0200 Subject: [PATCH 083/122] Default trait: set pointers to std::ptr::null()/null_mut() instead of zeroed --- ash/src/vk.rs | 778 +++++++++++++++++++++---------------------- generator/src/lib.rs | 35 +- 2 files changed, 421 insertions(+), 392 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 2705cee..d7dca5f 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -4945,7 +4945,7 @@ impl ::std::default::Default for BaseOutStructure { fn default() -> BaseOutStructure { BaseOutStructure { s_type: unsafe { ::std::mem::zeroed() }, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), } } } @@ -4959,7 +4959,7 @@ impl ::std::default::Default for BaseInStructure { fn default() -> BaseInStructure { BaseInStructure { s_type: unsafe { ::std::mem::zeroed() }, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), } } } @@ -5138,10 +5138,10 @@ impl ::std::default::Default for ApplicationInfo { fn default() -> ApplicationInfo { ApplicationInfo { s_type: StructureType::APPLICATION_INFO, - p_next: unsafe { ::std::mem::zeroed() }, - p_application_name: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + p_application_name: ::std::ptr::null(), application_version: uint32_t::default(), - p_engine_name: unsafe { ::std::mem::zeroed() }, + p_engine_name: ::std::ptr::null(), engine_version: uint32_t::default(), api_version: uint32_t::default(), } @@ -5175,7 +5175,7 @@ impl ::std::fmt::Debug for AllocationCallbacks { impl ::std::default::Default for AllocationCallbacks { fn default() -> AllocationCallbacks { AllocationCallbacks { - p_user_data: unsafe { ::std::mem::zeroed() }, + p_user_data: ::std::ptr::null_mut(), pfn_allocation: unsafe { ::std::mem::zeroed() }, pfn_reallocation: unsafe { ::std::mem::zeroed() }, pfn_free: unsafe { ::std::mem::zeroed() }, @@ -5198,11 +5198,11 @@ impl ::std::default::Default for DeviceQueueCreateInfo { fn default() -> DeviceQueueCreateInfo { DeviceQueueCreateInfo { s_type: StructureType::DEVICE_QUEUE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DeviceQueueCreateFlags::default(), queue_family_index: uint32_t::default(), queue_count: uint32_t::default(), - p_queue_priorities: unsafe { ::std::mem::zeroed() }, + p_queue_priorities: ::std::ptr::null(), } } } @@ -5224,15 +5224,15 @@ impl ::std::default::Default for DeviceCreateInfo { fn default() -> DeviceCreateInfo { DeviceCreateInfo { s_type: StructureType::DEVICE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DeviceCreateFlags::default(), queue_create_info_count: uint32_t::default(), - p_queue_create_infos: unsafe { ::std::mem::zeroed() }, + p_queue_create_infos: ::std::ptr::null(), enabled_layer_count: uint32_t::default(), - pp_enabled_layer_names: unsafe { ::std::mem::zeroed() }, + pp_enabled_layer_names: ::std::ptr::null(), enabled_extension_count: uint32_t::default(), - pp_enabled_extension_names: unsafe { ::std::mem::zeroed() }, - p_enabled_features: unsafe { ::std::mem::zeroed() }, + pp_enabled_extension_names: ::std::ptr::null(), + p_enabled_features: ::std::ptr::null(), } } } @@ -5252,13 +5252,13 @@ impl ::std::default::Default for InstanceCreateInfo { fn default() -> InstanceCreateInfo { InstanceCreateInfo { s_type: StructureType::INSTANCE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: InstanceCreateFlags::default(), - p_application_info: unsafe { ::std::mem::zeroed() }, + p_application_info: ::std::ptr::null(), enabled_layer_count: uint32_t::default(), - pp_enabled_layer_names: unsafe { ::std::mem::zeroed() }, + pp_enabled_layer_names: ::std::ptr::null(), enabled_extension_count: uint32_t::default(), - pp_enabled_extension_names: unsafe { ::std::mem::zeroed() }, + pp_enabled_extension_names: ::std::ptr::null(), } } } @@ -5314,7 +5314,7 @@ impl ::std::default::Default for MemoryAllocateInfo { fn default() -> MemoryAllocateInfo { MemoryAllocateInfo { s_type: StructureType::MEMORY_ALLOCATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), allocation_size: DeviceSize::default(), memory_type_index: uint32_t::default(), } @@ -5368,7 +5368,7 @@ impl ::std::default::Default for MappedMemoryRange { fn default() -> MappedMemoryRange { MappedMemoryRange { s_type: StructureType::MAPPED_MEMORY_RANGE, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), memory: DeviceMemory::default(), offset: DeviceSize::default(), size: DeviceSize::default(), @@ -5423,15 +5423,15 @@ impl ::std::default::Default for WriteDescriptorSet { fn default() -> WriteDescriptorSet { WriteDescriptorSet { s_type: StructureType::WRITE_DESCRIPTOR_SET, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), dst_set: DescriptorSet::default(), dst_binding: uint32_t::default(), dst_array_element: uint32_t::default(), descriptor_count: uint32_t::default(), descriptor_type: DescriptorType::default(), - p_image_info: unsafe { ::std::mem::zeroed() }, - p_buffer_info: unsafe { ::std::mem::zeroed() }, - p_texel_buffer_view: unsafe { ::std::mem::zeroed() }, + p_image_info: ::std::ptr::null(), + p_buffer_info: ::std::ptr::null(), + p_texel_buffer_view: ::std::ptr::null(), } } } @@ -5452,7 +5452,7 @@ impl ::std::default::Default for CopyDescriptorSet { fn default() -> CopyDescriptorSet { CopyDescriptorSet { s_type: StructureType::COPY_DESCRIPTOR_SET, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), src_set: DescriptorSet::default(), src_binding: uint32_t::default(), src_array_element: uint32_t::default(), @@ -5479,13 +5479,13 @@ impl ::std::default::Default for BufferCreateInfo { fn default() -> BufferCreateInfo { BufferCreateInfo { s_type: StructureType::BUFFER_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: BufferCreateFlags::default(), size: DeviceSize::default(), usage: BufferUsageFlags::default(), sharing_mode: SharingMode::default(), queue_family_index_count: uint32_t::default(), - p_queue_family_indices: unsafe { ::std::mem::zeroed() }, + p_queue_family_indices: ::std::ptr::null(), } } } @@ -5504,7 +5504,7 @@ impl ::std::default::Default for BufferViewCreateInfo { fn default() -> BufferViewCreateInfo { BufferViewCreateInfo { s_type: StructureType::BUFFER_VIEW_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: BufferViewCreateFlags::default(), buffer: Buffer::default(), format: Format::default(), @@ -5549,7 +5549,7 @@ impl ::std::default::Default for MemoryBarrier { fn default() -> MemoryBarrier { MemoryBarrier { s_type: StructureType::MEMORY_BARRIER, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), src_access_mask: AccessFlags::default(), dst_access_mask: AccessFlags::default(), } @@ -5572,7 +5572,7 @@ impl ::std::default::Default for BufferMemoryBarrier { fn default() -> BufferMemoryBarrier { BufferMemoryBarrier { s_type: StructureType::BUFFER_MEMORY_BARRIER, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), src_access_mask: AccessFlags::default(), dst_access_mask: AccessFlags::default(), src_queue_family_index: uint32_t::default(), @@ -5601,7 +5601,7 @@ impl ::std::default::Default for ImageMemoryBarrier { fn default() -> ImageMemoryBarrier { ImageMemoryBarrier { s_type: StructureType::IMAGE_MEMORY_BARRIER, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), src_access_mask: AccessFlags::default(), dst_access_mask: AccessFlags::default(), old_layout: ImageLayout::default(), @@ -5636,7 +5636,7 @@ impl ::std::default::Default for ImageCreateInfo { fn default() -> ImageCreateInfo { ImageCreateInfo { s_type: StructureType::IMAGE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: ImageCreateFlags::default(), image_type: ImageType::default(), format: Format::default(), @@ -5648,7 +5648,7 @@ impl ::std::default::Default for ImageCreateInfo { usage: ImageUsageFlags::default(), sharing_mode: SharingMode::default(), queue_family_index_count: uint32_t::default(), - p_queue_family_indices: unsafe { ::std::mem::zeroed() }, + p_queue_family_indices: ::std::ptr::null(), initial_layout: ImageLayout::default(), } } @@ -5678,7 +5678,7 @@ impl ::std::default::Default for ImageViewCreateInfo { fn default() -> ImageViewCreateInfo { ImageViewCreateInfo { s_type: StructureType::IMAGE_VIEW_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: ImageViewCreateFlags::default(), image: Image::default(), view_type: ImageViewType::default(), @@ -5726,7 +5726,7 @@ impl ::std::default::Default for SparseBufferMemoryBindInfo { SparseBufferMemoryBindInfo { buffer: Buffer::default(), bind_count: uint32_t::default(), - p_binds: unsafe { ::std::mem::zeroed() }, + p_binds: ::std::ptr::null(), } } } @@ -5742,7 +5742,7 @@ impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { SparseImageOpaqueMemoryBindInfo { image: Image::default(), bind_count: uint32_t::default(), - p_binds: unsafe { ::std::mem::zeroed() }, + p_binds: ::std::ptr::null(), } } } @@ -5758,7 +5758,7 @@ impl ::std::default::Default for SparseImageMemoryBindInfo { SparseImageMemoryBindInfo { image: Image::default(), bind_count: uint32_t::default(), - p_binds: unsafe { ::std::mem::zeroed() }, + p_binds: ::std::ptr::null(), } } } @@ -5782,17 +5782,17 @@ impl ::std::default::Default for BindSparseInfo { fn default() -> BindSparseInfo { BindSparseInfo { s_type: StructureType::BIND_SPARSE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), wait_semaphore_count: uint32_t::default(), - p_wait_semaphores: unsafe { ::std::mem::zeroed() }, + p_wait_semaphores: ::std::ptr::null(), buffer_bind_count: uint32_t::default(), - p_buffer_binds: unsafe { ::std::mem::zeroed() }, + p_buffer_binds: ::std::ptr::null(), image_opaque_bind_count: uint32_t::default(), - p_image_opaque_binds: unsafe { ::std::mem::zeroed() }, + p_image_opaque_binds: ::std::ptr::null(), image_bind_count: uint32_t::default(), - p_image_binds: unsafe { ::std::mem::zeroed() }, + p_image_binds: ::std::ptr::null(), signal_semaphore_count: uint32_t::default(), - p_signal_semaphores: unsafe { ::std::mem::zeroed() }, + p_signal_semaphores: ::std::ptr::null(), } } } @@ -5869,10 +5869,10 @@ impl ::std::default::Default for ShaderModuleCreateInfo { fn default() -> ShaderModuleCreateInfo { ShaderModuleCreateInfo { s_type: StructureType::SHADER_MODULE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: ShaderModuleCreateFlags::default(), code_size: size_t::default(), - p_code: unsafe { ::std::mem::zeroed() }, + p_code: ::std::ptr::null(), } } } @@ -5892,7 +5892,7 @@ impl ::std::default::Default for DescriptorSetLayoutBinding { descriptor_type: DescriptorType::default(), descriptor_count: uint32_t::default(), stage_flags: ShaderStageFlags::default(), - p_immutable_samplers: unsafe { ::std::mem::zeroed() }, + p_immutable_samplers: ::std::ptr::null(), } } } @@ -5909,10 +5909,10 @@ impl ::std::default::Default for DescriptorSetLayoutCreateInfo { fn default() -> DescriptorSetLayoutCreateInfo { DescriptorSetLayoutCreateInfo { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DescriptorSetLayoutCreateFlags::default(), binding_count: uint32_t::default(), - p_bindings: unsafe { ::std::mem::zeroed() }, + p_bindings: ::std::ptr::null(), } } } @@ -5936,11 +5936,11 @@ impl ::std::default::Default for DescriptorPoolCreateInfo { fn default() -> DescriptorPoolCreateInfo { DescriptorPoolCreateInfo { s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DescriptorPoolCreateFlags::default(), max_sets: uint32_t::default(), pool_size_count: uint32_t::default(), - p_pool_sizes: unsafe { ::std::mem::zeroed() }, + p_pool_sizes: ::std::ptr::null(), } } } @@ -5957,10 +5957,10 @@ impl ::std::default::Default for DescriptorSetAllocateInfo { fn default() -> DescriptorSetAllocateInfo { DescriptorSetAllocateInfo { s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), descriptor_pool: DescriptorPool::default(), descriptor_set_count: uint32_t::default(), - p_set_layouts: unsafe { ::std::mem::zeroed() }, + p_set_layouts: ::std::ptr::null(), } } } @@ -5983,9 +5983,9 @@ impl ::std::default::Default for SpecializationInfo { fn default() -> SpecializationInfo { SpecializationInfo { map_entry_count: uint32_t::default(), - p_map_entries: unsafe { ::std::mem::zeroed() }, + p_map_entries: ::std::ptr::null(), data_size: size_t::default(), - p_data: unsafe { ::std::mem::zeroed() }, + p_data: ::std::ptr::null(), } } } @@ -6004,12 +6004,12 @@ impl ::std::default::Default for PipelineShaderStageCreateInfo { fn default() -> PipelineShaderStageCreateInfo { PipelineShaderStageCreateInfo { s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineShaderStageCreateFlags::default(), stage: ShaderStageFlags::default(), module: ShaderModule::default(), - p_name: unsafe { ::std::mem::zeroed() }, - p_specialization_info: unsafe { ::std::mem::zeroed() }, + p_name: ::std::ptr::null(), + p_specialization_info: ::std::ptr::null(), } } } @@ -6028,7 +6028,7 @@ impl ::std::default::Default for ComputePipelineCreateInfo { fn default() -> ComputePipelineCreateInfo { ComputePipelineCreateInfo { s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineCreateFlags::default(), stage: PipelineShaderStageCreateInfo::default(), layout: PipelineLayout::default(), @@ -6067,12 +6067,12 @@ impl ::std::default::Default for PipelineVertexInputStateCreateInfo { fn default() -> PipelineVertexInputStateCreateInfo { PipelineVertexInputStateCreateInfo { s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineVertexInputStateCreateFlags::default(), vertex_binding_description_count: uint32_t::default(), - p_vertex_binding_descriptions: unsafe { ::std::mem::zeroed() }, + p_vertex_binding_descriptions: ::std::ptr::null(), vertex_attribute_description_count: uint32_t::default(), - p_vertex_attribute_descriptions: unsafe { ::std::mem::zeroed() }, + p_vertex_attribute_descriptions: ::std::ptr::null(), } } } @@ -6089,7 +6089,7 @@ impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo { fn default() -> PipelineInputAssemblyStateCreateInfo { PipelineInputAssemblyStateCreateInfo { s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineInputAssemblyStateCreateFlags::default(), topology: PrimitiveTopology::default(), primitive_restart_enable: Bool32::default(), @@ -6108,7 +6108,7 @@ impl ::std::default::Default for PipelineTessellationStateCreateInfo { fn default() -> PipelineTessellationStateCreateInfo { PipelineTessellationStateCreateInfo { s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineTessellationStateCreateFlags::default(), patch_control_points: uint32_t::default(), } @@ -6129,12 +6129,12 @@ impl ::std::default::Default for PipelineViewportStateCreateInfo { fn default() -> PipelineViewportStateCreateInfo { PipelineViewportStateCreateInfo { s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineViewportStateCreateFlags::default(), viewport_count: uint32_t::default(), - p_viewports: unsafe { ::std::mem::zeroed() }, + p_viewports: ::std::ptr::null(), scissor_count: uint32_t::default(), - p_scissors: unsafe { ::std::mem::zeroed() }, + p_scissors: ::std::ptr::null(), } } } @@ -6159,7 +6159,7 @@ impl ::std::default::Default for PipelineRasterizationStateCreateInfo { fn default() -> PipelineRasterizationStateCreateInfo { PipelineRasterizationStateCreateInfo { s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineRasterizationStateCreateFlags::default(), depth_clamp_enable: Bool32::default(), rasterizer_discard_enable: Bool32::default(), @@ -6191,12 +6191,12 @@ impl ::std::default::Default for PipelineMultisampleStateCreateInfo { fn default() -> PipelineMultisampleStateCreateInfo { PipelineMultisampleStateCreateInfo { s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineMultisampleStateCreateFlags::default(), rasterization_samples: SampleCountFlags::default(), sample_shading_enable: Bool32::default(), min_sample_shading: c_float::default(), - p_sample_mask: unsafe { ::std::mem::zeroed() }, + p_sample_mask: ::std::ptr::null(), alpha_to_coverage_enable: Bool32::default(), alpha_to_one_enable: Bool32::default(), } @@ -6246,12 +6246,12 @@ impl ::std::default::Default for PipelineColorBlendStateCreateInfo { fn default() -> PipelineColorBlendStateCreateInfo { PipelineColorBlendStateCreateInfo { s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineColorBlendStateCreateFlags::default(), logic_op_enable: Bool32::default(), logic_op: LogicOp::default(), attachment_count: uint32_t::default(), - p_attachments: unsafe { ::std::mem::zeroed() }, + p_attachments: ::std::ptr::null(), blend_constants: unsafe { ::std::mem::zeroed() }, } } @@ -6269,10 +6269,10 @@ impl ::std::default::Default for PipelineDynamicStateCreateInfo { fn default() -> PipelineDynamicStateCreateInfo { PipelineDynamicStateCreateInfo { s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineDynamicStateCreateFlags::default(), dynamic_state_count: uint32_t::default(), - p_dynamic_states: unsafe { ::std::mem::zeroed() }, + p_dynamic_states: ::std::ptr::null(), } } } @@ -6307,7 +6307,7 @@ impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { fn default() -> PipelineDepthStencilStateCreateInfo { PipelineDepthStencilStateCreateInfo { s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineDepthStencilStateCreateFlags::default(), depth_test_enable: Bool32::default(), depth_write_enable: Bool32::default(), @@ -6348,19 +6348,19 @@ impl ::std::default::Default for GraphicsPipelineCreateInfo { fn default() -> GraphicsPipelineCreateInfo { GraphicsPipelineCreateInfo { s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineCreateFlags::default(), stage_count: uint32_t::default(), - p_stages: unsafe { ::std::mem::zeroed() }, - p_vertex_input_state: unsafe { ::std::mem::zeroed() }, - p_input_assembly_state: unsafe { ::std::mem::zeroed() }, - p_tessellation_state: unsafe { ::std::mem::zeroed() }, - p_viewport_state: unsafe { ::std::mem::zeroed() }, - p_rasterization_state: unsafe { ::std::mem::zeroed() }, - p_multisample_state: unsafe { ::std::mem::zeroed() }, - p_depth_stencil_state: unsafe { ::std::mem::zeroed() }, - p_color_blend_state: unsafe { ::std::mem::zeroed() }, - p_dynamic_state: unsafe { ::std::mem::zeroed() }, + p_stages: ::std::ptr::null(), + p_vertex_input_state: ::std::ptr::null(), + p_input_assembly_state: ::std::ptr::null(), + p_tessellation_state: ::std::ptr::null(), + p_viewport_state: ::std::ptr::null(), + p_rasterization_state: ::std::ptr::null(), + p_multisample_state: ::std::ptr::null(), + p_depth_stencil_state: ::std::ptr::null(), + p_color_blend_state: ::std::ptr::null(), + p_dynamic_state: ::std::ptr::null(), layout: PipelineLayout::default(), render_pass: RenderPass::default(), subpass: uint32_t::default(), @@ -6382,10 +6382,10 @@ impl ::std::default::Default for PipelineCacheCreateInfo { fn default() -> PipelineCacheCreateInfo { PipelineCacheCreateInfo { s_type: StructureType::PIPELINE_CACHE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineCacheCreateFlags::default(), initial_data_size: size_t::default(), - p_initial_data: unsafe { ::std::mem::zeroed() }, + p_initial_data: ::std::ptr::null(), } } } @@ -6411,12 +6411,12 @@ impl ::std::default::Default for PipelineLayoutCreateInfo { fn default() -> PipelineLayoutCreateInfo { PipelineLayoutCreateInfo { s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineLayoutCreateFlags::default(), set_layout_count: uint32_t::default(), - p_set_layouts: unsafe { ::std::mem::zeroed() }, + p_set_layouts: ::std::ptr::null(), push_constant_range_count: uint32_t::default(), - p_push_constant_ranges: unsafe { ::std::mem::zeroed() }, + p_push_constant_ranges: ::std::ptr::null(), } } } @@ -6446,7 +6446,7 @@ impl ::std::default::Default for SamplerCreateInfo { fn default() -> SamplerCreateInfo { SamplerCreateInfo { s_type: StructureType::SAMPLER_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: SamplerCreateFlags::default(), mag_filter: Filter::default(), min_filter: Filter::default(), @@ -6478,7 +6478,7 @@ impl ::std::default::Default for CommandPoolCreateInfo { fn default() -> CommandPoolCreateInfo { CommandPoolCreateInfo { s_type: StructureType::COMMAND_POOL_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: CommandPoolCreateFlags::default(), queue_family_index: uint32_t::default(), } @@ -6497,7 +6497,7 @@ impl ::std::default::Default for CommandBufferAllocateInfo { fn default() -> CommandBufferAllocateInfo { CommandBufferAllocateInfo { s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), command_pool: CommandPool::default(), level: CommandBufferLevel::default(), command_buffer_count: uint32_t::default(), @@ -6520,7 +6520,7 @@ impl ::std::default::Default for CommandBufferInheritanceInfo { fn default() -> CommandBufferInheritanceInfo { CommandBufferInheritanceInfo { s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), render_pass: RenderPass::default(), subpass: uint32_t::default(), framebuffer: Framebuffer::default(), @@ -6542,9 +6542,9 @@ impl ::std::default::Default for CommandBufferBeginInfo { fn default() -> CommandBufferBeginInfo { CommandBufferBeginInfo { s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: CommandBufferUsageFlags::default(), - p_inheritance_info: unsafe { ::std::mem::zeroed() }, + p_inheritance_info: ::std::ptr::null(), } } } @@ -6576,12 +6576,12 @@ impl ::std::default::Default for RenderPassBeginInfo { fn default() -> RenderPassBeginInfo { RenderPassBeginInfo { s_type: StructureType::RENDER_PASS_BEGIN_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), render_pass: RenderPass::default(), framebuffer: Framebuffer::default(), render_area: Rect2D::default(), clear_value_count: uint32_t::default(), - p_clear_values: unsafe { ::std::mem::zeroed() }, + p_clear_values: ::std::ptr::null(), } } } @@ -6669,13 +6669,13 @@ impl ::std::default::Default for SubpassDescription { flags: SubpassDescriptionFlags::default(), pipeline_bind_point: PipelineBindPoint::default(), input_attachment_count: uint32_t::default(), - p_input_attachments: unsafe { ::std::mem::zeroed() }, + p_input_attachments: ::std::ptr::null(), color_attachment_count: uint32_t::default(), - p_color_attachments: unsafe { ::std::mem::zeroed() }, - p_resolve_attachments: unsafe { ::std::mem::zeroed() }, - p_depth_stencil_attachment: unsafe { ::std::mem::zeroed() }, + p_color_attachments: ::std::ptr::null(), + p_resolve_attachments: ::std::ptr::null(), + p_depth_stencil_attachment: ::std::ptr::null(), preserve_attachment_count: uint32_t::default(), - p_preserve_attachments: unsafe { ::std::mem::zeroed() }, + p_preserve_attachments: ::std::ptr::null(), } } } @@ -6707,14 +6707,14 @@ impl ::std::default::Default for RenderPassCreateInfo { fn default() -> RenderPassCreateInfo { RenderPassCreateInfo { s_type: StructureType::RENDER_PASS_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: RenderPassCreateFlags::default(), attachment_count: uint32_t::default(), - p_attachments: unsafe { ::std::mem::zeroed() }, + p_attachments: ::std::ptr::null(), subpass_count: uint32_t::default(), - p_subpasses: unsafe { ::std::mem::zeroed() }, + p_subpasses: ::std::ptr::null(), dependency_count: uint32_t::default(), - p_dependencies: unsafe { ::std::mem::zeroed() }, + p_dependencies: ::std::ptr::null(), } } } @@ -6729,7 +6729,7 @@ impl ::std::default::Default for EventCreateInfo { fn default() -> EventCreateInfo { EventCreateInfo { s_type: StructureType::EVENT_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: EventCreateFlags::default(), } } @@ -6745,7 +6745,7 @@ impl ::std::default::Default for FenceCreateInfo { fn default() -> FenceCreateInfo { FenceCreateInfo { s_type: StructureType::FENCE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: FenceCreateFlags::default(), } } @@ -7346,7 +7346,7 @@ impl ::std::default::Default for SemaphoreCreateInfo { fn default() -> SemaphoreCreateInfo { SemaphoreCreateInfo { s_type: StructureType::SEMAPHORE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: SemaphoreCreateFlags::default(), } } @@ -7365,7 +7365,7 @@ impl ::std::default::Default for QueryPoolCreateInfo { fn default() -> QueryPoolCreateInfo { QueryPoolCreateInfo { s_type: StructureType::QUERY_POOL_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: QueryPoolCreateFlags::default(), query_type: QueryType::default(), query_count: uint32_t::default(), @@ -7390,11 +7390,11 @@ impl ::std::default::Default for FramebufferCreateInfo { fn default() -> FramebufferCreateInfo { FramebufferCreateInfo { s_type: StructureType::FRAMEBUFFER_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: FramebufferCreateFlags::default(), render_pass: RenderPass::default(), attachment_count: uint32_t::default(), - p_attachments: unsafe { ::std::mem::zeroed() }, + p_attachments: ::std::ptr::null(), width: uint32_t::default(), height: uint32_t::default(), layers: uint32_t::default(), @@ -7442,14 +7442,14 @@ impl ::std::default::Default for SubmitInfo { fn default() -> SubmitInfo { SubmitInfo { s_type: StructureType::SUBMIT_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), wait_semaphore_count: uint32_t::default(), - p_wait_semaphores: unsafe { ::std::mem::zeroed() }, - p_wait_dst_stage_mask: unsafe { ::std::mem::zeroed() }, + p_wait_semaphores: ::std::ptr::null(), + p_wait_dst_stage_mask: ::std::ptr::null(), command_buffer_count: uint32_t::default(), - p_command_buffers: unsafe { ::std::mem::zeroed() }, + p_command_buffers: ::std::ptr::null(), signal_semaphore_count: uint32_t::default(), - p_signal_semaphores: unsafe { ::std::mem::zeroed() }, + p_signal_semaphores: ::std::ptr::null(), } } } @@ -7468,7 +7468,7 @@ impl ::std::default::Default for DisplayPropertiesKHR { fn default() -> DisplayPropertiesKHR { DisplayPropertiesKHR { display: DisplayKHR::default(), - display_name: unsafe { ::std::mem::zeroed() }, + display_name: ::std::ptr::null(), physical_dimensions: Extent2D::default(), physical_resolution: Extent2D::default(), supported_transforms: SurfaceTransformFlagsKHR::default(), @@ -7507,7 +7507,7 @@ impl ::std::default::Default for DisplayModeCreateInfoKHR { fn default() -> DisplayModeCreateInfoKHR { DisplayModeCreateInfoKHR { s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DisplayModeCreateFlagsKHR::default(), parameters: DisplayModeParametersKHR::default(), } @@ -7544,7 +7544,7 @@ impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { fn default() -> DisplaySurfaceCreateInfoKHR { DisplaySurfaceCreateInfoKHR { s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DisplaySurfaceCreateFlagsKHR::default(), display_mode: DisplayModeKHR::default(), plane_index: uint32_t::default(), @@ -7569,7 +7569,7 @@ impl ::std::default::Default for DisplayPresentInfoKHR { fn default() -> DisplayPresentInfoKHR { DisplayPresentInfoKHR { s_type: StructureType::DISPLAY_PRESENT_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), src_rect: Rect2D::default(), dst_rect: Rect2D::default(), persistent: Bool32::default(), @@ -7602,9 +7602,9 @@ impl ::std::default::Default for AndroidSurfaceCreateInfoKHR { fn default() -> AndroidSurfaceCreateInfoKHR { AndroidSurfaceCreateInfoKHR { s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: AndroidSurfaceCreateFlagsKHR::default(), - window: unsafe { ::std::mem::zeroed() }, + window: ::std::ptr::null_mut(), } } } @@ -7621,10 +7621,10 @@ impl ::std::default::Default for MirSurfaceCreateInfoKHR { fn default() -> MirSurfaceCreateInfoKHR { MirSurfaceCreateInfoKHR { s_type: StructureType::MIR_SURFACE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: MirSurfaceCreateFlagsKHR::default(), - connection: unsafe { ::std::mem::zeroed() }, - mir_surface: unsafe { ::std::mem::zeroed() }, + connection: ::std::ptr::null_mut(), + mir_surface: ::std::ptr::null_mut(), } } } @@ -7640,9 +7640,9 @@ impl ::std::default::Default for ViSurfaceCreateInfoNN { fn default() -> ViSurfaceCreateInfoNN { ViSurfaceCreateInfoNN { s_type: StructureType::VI_SURFACE_CREATE_INFO_NN, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: ViSurfaceCreateFlagsNN::default(), - window: unsafe { ::std::mem::zeroed() }, + window: ::std::ptr::null_mut(), } } } @@ -7659,10 +7659,10 @@ impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { fn default() -> WaylandSurfaceCreateInfoKHR { WaylandSurfaceCreateInfoKHR { s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: WaylandSurfaceCreateFlagsKHR::default(), - display: unsafe { ::std::mem::zeroed() }, - surface: unsafe { ::std::mem::zeroed() }, + display: ::std::ptr::null_mut(), + surface: ::std::ptr::null_mut(), } } } @@ -7679,7 +7679,7 @@ impl ::std::default::Default for Win32SurfaceCreateInfoKHR { fn default() -> Win32SurfaceCreateInfoKHR { Win32SurfaceCreateInfoKHR { s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: Win32SurfaceCreateFlagsKHR::default(), hinstance: unsafe { ::std::mem::zeroed() }, hwnd: unsafe { ::std::mem::zeroed() }, @@ -7699,9 +7699,9 @@ impl ::std::default::Default for XlibSurfaceCreateInfoKHR { fn default() -> XlibSurfaceCreateInfoKHR { XlibSurfaceCreateInfoKHR { s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: XlibSurfaceCreateFlagsKHR::default(), - dpy: unsafe { ::std::mem::zeroed() }, + dpy: ::std::ptr::null_mut(), window: Window::default(), } } @@ -7719,9 +7719,9 @@ impl ::std::default::Default for XcbSurfaceCreateInfoKHR { fn default() -> XcbSurfaceCreateInfoKHR { XcbSurfaceCreateInfoKHR { s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: XcbSurfaceCreateFlagsKHR::default(), - connection: unsafe { ::std::mem::zeroed() }, + connection: ::std::ptr::null_mut(), window: xcb_window_t::default(), } } @@ -7758,7 +7758,7 @@ impl ::std::default::Default for SwapchainCreateInfoKHR { fn default() -> SwapchainCreateInfoKHR { SwapchainCreateInfoKHR { s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: SwapchainCreateFlagsKHR::default(), surface: SurfaceKHR::default(), min_image_count: uint32_t::default(), @@ -7769,7 +7769,7 @@ impl ::std::default::Default for SwapchainCreateInfoKHR { image_usage: ImageUsageFlags::default(), image_sharing_mode: SharingMode::default(), queue_family_index_count: uint32_t::default(), - p_queue_family_indices: unsafe { ::std::mem::zeroed() }, + p_queue_family_indices: ::std::ptr::null(), pre_transform: SurfaceTransformFlagsKHR::default(), composite_alpha: CompositeAlphaFlagsKHR::default(), present_mode: PresentModeKHR::default(), @@ -7794,13 +7794,13 @@ impl ::std::default::Default for PresentInfoKHR { fn default() -> PresentInfoKHR { PresentInfoKHR { s_type: StructureType::PRESENT_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), wait_semaphore_count: uint32_t::default(), - p_wait_semaphores: unsafe { ::std::mem::zeroed() }, + p_wait_semaphores: ::std::ptr::null(), swapchain_count: uint32_t::default(), - p_swapchains: unsafe { ::std::mem::zeroed() }, - p_image_indices: unsafe { ::std::mem::zeroed() }, - p_results: unsafe { ::std::mem::zeroed() }, + p_swapchains: ::std::ptr::null(), + p_image_indices: ::std::ptr::null(), + p_results: ::std::ptr::null_mut(), } } } @@ -7828,10 +7828,10 @@ impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { fn default() -> DebugReportCallbackCreateInfoEXT { DebugReportCallbackCreateInfoEXT { s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DebugReportFlagsEXT::default(), pfn_callback: unsafe { ::std::mem::zeroed() }, - p_user_data: unsafe { ::std::mem::zeroed() }, + p_user_data: ::std::ptr::null_mut(), } } } @@ -7847,9 +7847,9 @@ impl ::std::default::Default for ValidationFlagsEXT { fn default() -> ValidationFlagsEXT { ValidationFlagsEXT { s_type: StructureType::VALIDATION_FLAGS_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), disabled_validation_check_count: uint32_t::default(), - p_disabled_validation_checks: unsafe { ::std::mem::zeroed() }, + p_disabled_validation_checks: ::std::ptr::null_mut(), } } } @@ -7864,7 +7864,7 @@ impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD fn default() -> PipelineRasterizationStateRasterizationOrderAMD { PipelineRasterizationStateRasterizationOrderAMD { s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), rasterization_order: RasterizationOrderAMD::default(), } } @@ -7882,10 +7882,10 @@ impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { fn default() -> DebugMarkerObjectNameInfoEXT { DebugMarkerObjectNameInfoEXT { s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), object_type: DebugReportObjectTypeEXT::default(), object: uint64_t::default(), - p_object_name: unsafe { ::std::mem::zeroed() }, + p_object_name: ::std::ptr::null(), } } } @@ -7904,12 +7904,12 @@ impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { fn default() -> DebugMarkerObjectTagInfoEXT { DebugMarkerObjectTagInfoEXT { s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), object_type: DebugReportObjectTypeEXT::default(), object: uint64_t::default(), tag_name: uint64_t::default(), tag_size: size_t::default(), - p_tag: unsafe { ::std::mem::zeroed() }, + p_tag: ::std::ptr::null(), } } } @@ -7937,8 +7937,8 @@ impl ::std::default::Default for DebugMarkerMarkerInfoEXT { fn default() -> DebugMarkerMarkerInfoEXT { DebugMarkerMarkerInfoEXT { s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, - p_marker_name: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + p_marker_name: ::std::ptr::null(), color: unsafe { ::std::mem::zeroed() }, } } @@ -7954,7 +7954,7 @@ impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV { fn default() -> DedicatedAllocationImageCreateInfoNV { DedicatedAllocationImageCreateInfoNV { s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), dedicated_allocation: Bool32::default(), } } @@ -7970,7 +7970,7 @@ impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV { fn default() -> DedicatedAllocationBufferCreateInfoNV { DedicatedAllocationBufferCreateInfoNV { s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), dedicated_allocation: Bool32::default(), } } @@ -7987,7 +7987,7 @@ impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV { fn default() -> DedicatedAllocationMemoryAllocateInfoNV { DedicatedAllocationMemoryAllocateInfoNV { s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), image: Image::default(), buffer: Buffer::default(), } @@ -8012,7 +8012,7 @@ impl ::std::default::Default for ExternalMemoryImageCreateInfoNV { fn default() -> ExternalMemoryImageCreateInfoNV { ExternalMemoryImageCreateInfoNV { s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlagsNV::default(), } } @@ -8028,7 +8028,7 @@ impl ::std::default::Default for ExportMemoryAllocateInfoNV { fn default() -> ExportMemoryAllocateInfoNV { ExportMemoryAllocateInfoNV { s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlagsNV::default(), } } @@ -8045,7 +8045,7 @@ impl ::std::default::Default for ImportMemoryWin32HandleInfoNV { fn default() -> ImportMemoryWin32HandleInfoNV { ImportMemoryWin32HandleInfoNV { s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlagsNV::default(), handle: unsafe { ::std::mem::zeroed() }, } @@ -8063,8 +8063,8 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoNV { fn default() -> ExportMemoryWin32HandleInfoNV { ExportMemoryWin32HandleInfoNV { s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, - p_attributes: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), } } @@ -8086,14 +8086,14 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { fn default() -> Win32KeyedMutexAcquireReleaseInfoNV { Win32KeyedMutexAcquireReleaseInfoNV { s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), acquire_count: uint32_t::default(), - p_acquire_syncs: unsafe { ::std::mem::zeroed() }, - p_acquire_keys: unsafe { ::std::mem::zeroed() }, - p_acquire_timeout_milliseconds: unsafe { ::std::mem::zeroed() }, + p_acquire_syncs: ::std::ptr::null(), + p_acquire_keys: ::std::ptr::null(), + p_acquire_timeout_milliseconds: ::std::ptr::null(), release_count: uint32_t::default(), - p_release_syncs: unsafe { ::std::mem::zeroed() }, - p_release_keys: unsafe { ::std::mem::zeroed() }, + p_release_syncs: ::std::ptr::null(), + p_release_keys: ::std::ptr::null(), } } } @@ -8108,7 +8108,7 @@ impl ::std::default::Default for DeviceGeneratedCommandsFeaturesNVX { fn default() -> DeviceGeneratedCommandsFeaturesNVX { DeviceGeneratedCommandsFeaturesNVX { s_type: StructureType::DEVICE_GENERATED_COMMANDS_FEATURES_NVX, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), compute_binding_point_support: Bool32::default(), } } @@ -8128,7 +8128,7 @@ impl ::std::default::Default for DeviceGeneratedCommandsLimitsNVX { fn default() -> DeviceGeneratedCommandsLimitsNVX { DeviceGeneratedCommandsLimitsNVX { s_type: StructureType::DEVICE_GENERATED_COMMANDS_LIMITS_NVX, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), max_indirect_commands_layout_token_count: uint32_t::default(), max_object_entry_counts: uint32_t::default(), min_sequence_count_buffer_offset_alignment: uint32_t::default(), @@ -8166,11 +8166,11 @@ impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNVX { fn default() -> IndirectCommandsLayoutCreateInfoNVX { IndirectCommandsLayoutCreateInfoNVX { s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), pipeline_bind_point: PipelineBindPoint::default(), flags: IndirectCommandsLayoutUsageFlagsNVX::default(), token_count: uint32_t::default(), - p_tokens: unsafe { ::std::mem::zeroed() }, + p_tokens: ::std::ptr::null(), } } } @@ -8194,11 +8194,11 @@ impl ::std::default::Default for CmdProcessCommandsInfoNVX { fn default() -> CmdProcessCommandsInfoNVX { CmdProcessCommandsInfoNVX { s_type: StructureType::CMD_PROCESS_COMMANDS_INFO_NVX, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), object_table: ObjectTableNVX::default(), indirect_commands_layout: IndirectCommandsLayoutNVX::default(), indirect_commands_token_count: uint32_t::default(), - p_indirect_commands_tokens: unsafe { ::std::mem::zeroed() }, + p_indirect_commands_tokens: ::std::ptr::null(), max_sequences_count: uint32_t::default(), target_command_buffer: CommandBuffer::default(), sequences_count_buffer: Buffer::default(), @@ -8221,7 +8221,7 @@ impl ::std::default::Default for CmdReserveSpaceForCommandsInfoNVX { fn default() -> CmdReserveSpaceForCommandsInfoNVX { CmdReserveSpaceForCommandsInfoNVX { s_type: StructureType::CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), object_table: ObjectTableNVX::default(), indirect_commands_layout: IndirectCommandsLayoutNVX::default(), max_sequences_count: uint32_t::default(), @@ -8247,11 +8247,11 @@ impl ::std::default::Default for ObjectTableCreateInfoNVX { fn default() -> ObjectTableCreateInfoNVX { ObjectTableCreateInfoNVX { s_type: StructureType::OBJECT_TABLE_CREATE_INFO_NVX, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), object_count: uint32_t::default(), - p_object_entry_types: unsafe { ::std::mem::zeroed() }, - p_object_entry_counts: unsafe { ::std::mem::zeroed() }, - p_object_entry_usage_flags: unsafe { ::std::mem::zeroed() }, + p_object_entry_types: ::std::ptr::null(), + p_object_entry_counts: ::std::ptr::null(), + p_object_entry_usage_flags: ::std::ptr::null(), max_uniform_buffers_per_descriptor: uint32_t::default(), max_storage_buffers_per_descriptor: uint32_t::default(), max_storage_images_per_descriptor: uint32_t::default(), @@ -8315,7 +8315,7 @@ impl ::std::default::Default for PhysicalDeviceFeatures2 { fn default() -> PhysicalDeviceFeatures2 { PhysicalDeviceFeatures2 { s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), features: PhysicalDeviceFeatures::default(), } } @@ -8331,7 +8331,7 @@ impl ::std::default::Default for PhysicalDeviceProperties2 { fn default() -> PhysicalDeviceProperties2 { PhysicalDeviceProperties2 { s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), properties: PhysicalDeviceProperties::default(), } } @@ -8347,7 +8347,7 @@ impl ::std::default::Default for FormatProperties2 { fn default() -> FormatProperties2 { FormatProperties2 { s_type: StructureType::FORMAT_PROPERTIES_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), format_properties: FormatProperties::default(), } } @@ -8363,7 +8363,7 @@ impl ::std::default::Default for ImageFormatProperties2 { fn default() -> ImageFormatProperties2 { ImageFormatProperties2 { s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), image_format_properties: ImageFormatProperties::default(), } } @@ -8383,7 +8383,7 @@ impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { fn default() -> PhysicalDeviceImageFormatInfo2 { PhysicalDeviceImageFormatInfo2 { s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), format: Format::default(), ty: ImageType::default(), tiling: ImageTiling::default(), @@ -8403,7 +8403,7 @@ impl ::std::default::Default for QueueFamilyProperties2 { fn default() -> QueueFamilyProperties2 { QueueFamilyProperties2 { s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), queue_family_properties: QueueFamilyProperties::default(), } } @@ -8419,7 +8419,7 @@ impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { fn default() -> PhysicalDeviceMemoryProperties2 { PhysicalDeviceMemoryProperties2 { s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), memory_properties: PhysicalDeviceMemoryProperties::default(), } } @@ -8435,7 +8435,7 @@ impl ::std::default::Default for SparseImageFormatProperties2 { fn default() -> SparseImageFormatProperties2 { SparseImageFormatProperties2 { s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), properties: SparseImageFormatProperties::default(), } } @@ -8455,7 +8455,7 @@ impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { fn default() -> PhysicalDeviceSparseImageFormatInfo2 { PhysicalDeviceSparseImageFormatInfo2 { s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), format: Format::default(), ty: ImageType::default(), samples: SampleCountFlags::default(), @@ -8475,7 +8475,7 @@ impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { fn default() -> PhysicalDevicePushDescriptorPropertiesKHR { PhysicalDevicePushDescriptorPropertiesKHR { s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_push_descriptors: uint32_t::default(), } } @@ -8492,9 +8492,9 @@ impl ::std::default::Default for PresentRegionsKHR { fn default() -> PresentRegionsKHR { PresentRegionsKHR { s_type: StructureType::PRESENT_REGIONS_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), swapchain_count: uint32_t::default(), - p_regions: unsafe { ::std::mem::zeroed() }, + p_regions: ::std::ptr::null(), } } } @@ -8508,7 +8508,7 @@ impl ::std::default::Default for PresentRegionKHR { fn default() -> PresentRegionKHR { PresentRegionKHR { rectangle_count: uint32_t::default(), - p_rectangles: unsafe { ::std::mem::zeroed() }, + p_rectangles: ::std::ptr::null(), } } } @@ -8531,7 +8531,7 @@ impl ::std::default::Default for PhysicalDeviceVariablePointerFeatures { fn default() -> PhysicalDeviceVariablePointerFeatures { PhysicalDeviceVariablePointerFeatures { s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), variable_pointers_storage_buffer: Bool32::default(), variable_pointers: Bool32::default(), } @@ -8555,7 +8555,7 @@ impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo { fn default() -> PhysicalDeviceExternalImageFormatInfo { PhysicalDeviceExternalImageFormatInfo { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), } } @@ -8571,7 +8571,7 @@ impl ::std::default::Default for ExternalImageFormatProperties { fn default() -> ExternalImageFormatProperties { ExternalImageFormatProperties { s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), external_memory_properties: ExternalMemoryProperties::default(), } } @@ -8589,7 +8589,7 @@ impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { fn default() -> PhysicalDeviceExternalBufferInfo { PhysicalDeviceExternalBufferInfo { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: BufferCreateFlags::default(), usage: BufferUsageFlags::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), @@ -8607,7 +8607,7 @@ impl ::std::default::Default for ExternalBufferProperties { fn default() -> ExternalBufferProperties { ExternalBufferProperties { s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), external_memory_properties: ExternalMemoryProperties::default(), } } @@ -8646,7 +8646,7 @@ impl ::std::default::Default for PhysicalDeviceIDProperties { fn default() -> PhysicalDeviceIDProperties { PhysicalDeviceIDProperties { s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), device_uuid: unsafe { ::std::mem::zeroed() }, driver_uuid: unsafe { ::std::mem::zeroed() }, device_luid: unsafe { ::std::mem::zeroed() }, @@ -8666,7 +8666,7 @@ impl ::std::default::Default for ExternalMemoryImageCreateInfo { fn default() -> ExternalMemoryImageCreateInfo { ExternalMemoryImageCreateInfo { s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlags::default(), } } @@ -8682,7 +8682,7 @@ impl ::std::default::Default for ExternalMemoryBufferCreateInfo { fn default() -> ExternalMemoryBufferCreateInfo { ExternalMemoryBufferCreateInfo { s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlags::default(), } } @@ -8698,7 +8698,7 @@ impl ::std::default::Default for ExportMemoryAllocateInfo { fn default() -> ExportMemoryAllocateInfo { ExportMemoryAllocateInfo { s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlags::default(), } } @@ -8716,7 +8716,7 @@ impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR { fn default() -> ImportMemoryWin32HandleInfoKHR { ImportMemoryWin32HandleInfoKHR { s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), handle: unsafe { ::std::mem::zeroed() }, name: unsafe { ::std::mem::zeroed() }, @@ -8736,8 +8736,8 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { fn default() -> ExportMemoryWin32HandleInfoKHR { ExportMemoryWin32HandleInfoKHR { s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, - p_attributes: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), name: unsafe { ::std::mem::zeroed() }, } @@ -8754,7 +8754,7 @@ impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { fn default() -> MemoryWin32HandlePropertiesKHR { MemoryWin32HandlePropertiesKHR { s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), memory_type_bits: uint32_t::default(), } } @@ -8771,7 +8771,7 @@ impl ::std::default::Default for MemoryGetWin32HandleInfoKHR { fn default() -> MemoryGetWin32HandleInfoKHR { MemoryGetWin32HandleInfoKHR { s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), memory: DeviceMemory::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), } @@ -8789,7 +8789,7 @@ impl ::std::default::Default for ImportMemoryFdInfoKHR { fn default() -> ImportMemoryFdInfoKHR { ImportMemoryFdInfoKHR { s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), fd: c_int::default(), } @@ -8806,7 +8806,7 @@ impl ::std::default::Default for MemoryFdPropertiesKHR { fn default() -> MemoryFdPropertiesKHR { MemoryFdPropertiesKHR { s_type: StructureType::MEMORY_FD_PROPERTIES_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), memory_type_bits: uint32_t::default(), } } @@ -8823,7 +8823,7 @@ impl ::std::default::Default for MemoryGetFdInfoKHR { fn default() -> MemoryGetFdInfoKHR { MemoryGetFdInfoKHR { s_type: StructureType::MEMORY_GET_FD_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), memory: DeviceMemory::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), } @@ -8846,14 +8846,14 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { fn default() -> Win32KeyedMutexAcquireReleaseInfoKHR { Win32KeyedMutexAcquireReleaseInfoKHR { s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), acquire_count: uint32_t::default(), - p_acquire_syncs: unsafe { ::std::mem::zeroed() }, - p_acquire_keys: unsafe { ::std::mem::zeroed() }, - p_acquire_timeouts: unsafe { ::std::mem::zeroed() }, + p_acquire_syncs: ::std::ptr::null(), + p_acquire_keys: ::std::ptr::null(), + p_acquire_timeouts: ::std::ptr::null(), release_count: uint32_t::default(), - p_release_syncs: unsafe { ::std::mem::zeroed() }, - p_release_keys: unsafe { ::std::mem::zeroed() }, + p_release_syncs: ::std::ptr::null(), + p_release_keys: ::std::ptr::null(), } } } @@ -8868,7 +8868,7 @@ impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo { fn default() -> PhysicalDeviceExternalSemaphoreInfo { PhysicalDeviceExternalSemaphoreInfo { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), } } @@ -8886,7 +8886,7 @@ impl ::std::default::Default for ExternalSemaphoreProperties { fn default() -> ExternalSemaphoreProperties { ExternalSemaphoreProperties { s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(), compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(), external_semaphore_features: ExternalSemaphoreFeatureFlags::default(), @@ -8904,7 +8904,7 @@ impl ::std::default::Default for ExportSemaphoreCreateInfo { fn default() -> ExportSemaphoreCreateInfo { ExportSemaphoreCreateInfo { s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_types: ExternalSemaphoreHandleTypeFlags::default(), } } @@ -8924,7 +8924,7 @@ impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR { fn default() -> ImportSemaphoreWin32HandleInfoKHR { ImportSemaphoreWin32HandleInfoKHR { s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), semaphore: Semaphore::default(), flags: SemaphoreImportFlags::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), @@ -8946,8 +8946,8 @@ impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { fn default() -> ExportSemaphoreWin32HandleInfoKHR { ExportSemaphoreWin32HandleInfoKHR { s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, - p_attributes: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), name: unsafe { ::std::mem::zeroed() }, } @@ -8967,11 +8967,11 @@ impl ::std::default::Default for D3D12FenceSubmitInfoKHR { fn default() -> D3D12FenceSubmitInfoKHR { D3D12FenceSubmitInfoKHR { s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), wait_semaphore_values_count: uint32_t::default(), - p_wait_semaphore_values: unsafe { ::std::mem::zeroed() }, + p_wait_semaphore_values: ::std::ptr::null(), signal_semaphore_values_count: uint32_t::default(), - p_signal_semaphore_values: unsafe { ::std::mem::zeroed() }, + p_signal_semaphore_values: ::std::ptr::null(), } } } @@ -8987,7 +8987,7 @@ impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR { fn default() -> SemaphoreGetWin32HandleInfoKHR { SemaphoreGetWin32HandleInfoKHR { s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), semaphore: Semaphore::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), } @@ -9007,7 +9007,7 @@ impl ::std::default::Default for ImportSemaphoreFdInfoKHR { fn default() -> ImportSemaphoreFdInfoKHR { ImportSemaphoreFdInfoKHR { s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), semaphore: Semaphore::default(), flags: SemaphoreImportFlags::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), @@ -9027,7 +9027,7 @@ impl ::std::default::Default for SemaphoreGetFdInfoKHR { fn default() -> SemaphoreGetFdInfoKHR { SemaphoreGetFdInfoKHR { s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), semaphore: Semaphore::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), } @@ -9044,7 +9044,7 @@ impl ::std::default::Default for PhysicalDeviceExternalFenceInfo { fn default() -> PhysicalDeviceExternalFenceInfo { PhysicalDeviceExternalFenceInfo { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_type: ExternalFenceHandleTypeFlags::default(), } } @@ -9062,7 +9062,7 @@ impl ::std::default::Default for ExternalFenceProperties { fn default() -> ExternalFenceProperties { ExternalFenceProperties { s_type: StructureType::EXTERNAL_FENCE_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(), compatible_handle_types: ExternalFenceHandleTypeFlags::default(), external_fence_features: ExternalFenceFeatureFlags::default(), @@ -9080,7 +9080,7 @@ impl ::std::default::Default for ExportFenceCreateInfo { fn default() -> ExportFenceCreateInfo { ExportFenceCreateInfo { s_type: StructureType::EXPORT_FENCE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_types: ExternalFenceHandleTypeFlags::default(), } } @@ -9100,7 +9100,7 @@ impl ::std::default::Default for ImportFenceWin32HandleInfoKHR { fn default() -> ImportFenceWin32HandleInfoKHR { ImportFenceWin32HandleInfoKHR { s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), fence: Fence::default(), flags: FenceImportFlags::default(), handle_type: ExternalFenceHandleTypeFlags::default(), @@ -9122,8 +9122,8 @@ impl ::std::default::Default for ExportFenceWin32HandleInfoKHR { fn default() -> ExportFenceWin32HandleInfoKHR { ExportFenceWin32HandleInfoKHR { s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, - p_attributes: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), name: unsafe { ::std::mem::zeroed() }, } @@ -9141,7 +9141,7 @@ impl ::std::default::Default for FenceGetWin32HandleInfoKHR { fn default() -> FenceGetWin32HandleInfoKHR { FenceGetWin32HandleInfoKHR { s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), fence: Fence::default(), handle_type: ExternalFenceHandleTypeFlags::default(), } @@ -9161,7 +9161,7 @@ impl ::std::default::Default for ImportFenceFdInfoKHR { fn default() -> ImportFenceFdInfoKHR { ImportFenceFdInfoKHR { s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), fence: Fence::default(), flags: FenceImportFlags::default(), handle_type: ExternalFenceHandleTypeFlags::default(), @@ -9181,7 +9181,7 @@ impl ::std::default::Default for FenceGetFdInfoKHR { fn default() -> FenceGetFdInfoKHR { FenceGetFdInfoKHR { s_type: StructureType::FENCE_GET_FD_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), fence: Fence::default(), handle_type: ExternalFenceHandleTypeFlags::default(), } @@ -9200,7 +9200,7 @@ impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { fn default() -> PhysicalDeviceMultiviewFeatures { PhysicalDeviceMultiviewFeatures { s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), multiview: Bool32::default(), multiview_geometry_shader: Bool32::default(), multiview_tessellation_shader: Bool32::default(), @@ -9219,7 +9219,7 @@ impl ::std::default::Default for PhysicalDeviceMultiviewProperties { fn default() -> PhysicalDeviceMultiviewProperties { PhysicalDeviceMultiviewProperties { s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_multiview_view_count: uint32_t::default(), max_multiview_instance_index: uint32_t::default(), } @@ -9241,13 +9241,13 @@ impl ::std::default::Default for RenderPassMultiviewCreateInfo { fn default() -> RenderPassMultiviewCreateInfo { RenderPassMultiviewCreateInfo { s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), subpass_count: uint32_t::default(), - p_view_masks: unsafe { ::std::mem::zeroed() }, + p_view_masks: ::std::ptr::null(), dependency_count: uint32_t::default(), - p_view_offsets: unsafe { ::std::mem::zeroed() }, + p_view_offsets: ::std::ptr::null(), correlation_mask_count: uint32_t::default(), - p_correlation_masks: unsafe { ::std::mem::zeroed() }, + p_correlation_masks: ::std::ptr::null(), } } } @@ -9272,7 +9272,7 @@ impl ::std::default::Default for SurfaceCapabilities2EXT { fn default() -> SurfaceCapabilities2EXT { SurfaceCapabilities2EXT { s_type: StructureType::SURFACE_CAPABILITIES_2_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), min_image_count: uint32_t::default(), max_image_count: uint32_t::default(), current_extent: Extent2D::default(), @@ -9298,7 +9298,7 @@ impl ::std::default::Default for DisplayPowerInfoEXT { fn default() -> DisplayPowerInfoEXT { DisplayPowerInfoEXT { s_type: StructureType::DISPLAY_POWER_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), power_state: DisplayPowerStateEXT::default(), } } @@ -9314,7 +9314,7 @@ impl ::std::default::Default for DeviceEventInfoEXT { fn default() -> DeviceEventInfoEXT { DeviceEventInfoEXT { s_type: StructureType::DEVICE_EVENT_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), device_event: DeviceEventTypeEXT::default(), } } @@ -9330,7 +9330,7 @@ impl ::std::default::Default for DisplayEventInfoEXT { fn default() -> DisplayEventInfoEXT { DisplayEventInfoEXT { s_type: StructureType::DISPLAY_EVENT_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), display_event: DisplayEventTypeEXT::default(), } } @@ -9346,7 +9346,7 @@ impl ::std::default::Default for SwapchainCounterCreateInfoEXT { fn default() -> SwapchainCounterCreateInfoEXT { SwapchainCounterCreateInfoEXT { s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), surface_counters: SurfaceCounterFlagsEXT::default(), } } @@ -9377,7 +9377,7 @@ impl ::std::default::Default for PhysicalDeviceGroupProperties { fn default() -> PhysicalDeviceGroupProperties { PhysicalDeviceGroupProperties { s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), physical_device_count: uint32_t::default(), physical_devices: unsafe { ::std::mem::zeroed() }, subset_allocation: Bool32::default(), @@ -9396,7 +9396,7 @@ impl ::std::default::Default for MemoryAllocateFlagsInfo { fn default() -> MemoryAllocateFlagsInfo { MemoryAllocateFlagsInfo { s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: MemoryAllocateFlags::default(), device_mask: uint32_t::default(), } @@ -9415,7 +9415,7 @@ impl ::std::default::Default for BindBufferMemoryInfo { fn default() -> BindBufferMemoryInfo { BindBufferMemoryInfo { s_type: StructureType::BIND_BUFFER_MEMORY_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), buffer: Buffer::default(), memory: DeviceMemory::default(), memory_offset: DeviceSize::default(), @@ -9434,9 +9434,9 @@ impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { fn default() -> BindBufferMemoryDeviceGroupInfo { BindBufferMemoryDeviceGroupInfo { s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), device_index_count: uint32_t::default(), - p_device_indices: unsafe { ::std::mem::zeroed() }, + p_device_indices: ::std::ptr::null(), } } } @@ -9453,7 +9453,7 @@ impl ::std::default::Default for BindImageMemoryInfo { fn default() -> BindImageMemoryInfo { BindImageMemoryInfo { s_type: StructureType::BIND_IMAGE_MEMORY_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), image: Image::default(), memory: DeviceMemory::default(), memory_offset: DeviceSize::default(), @@ -9474,11 +9474,11 @@ impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { fn default() -> BindImageMemoryDeviceGroupInfo { BindImageMemoryDeviceGroupInfo { s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), device_index_count: uint32_t::default(), - p_device_indices: unsafe { ::std::mem::zeroed() }, + p_device_indices: ::std::ptr::null(), split_instance_bind_region_count: uint32_t::default(), - p_split_instance_bind_regions: unsafe { ::std::mem::zeroed() }, + p_split_instance_bind_regions: ::std::ptr::null(), } } } @@ -9495,10 +9495,10 @@ impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { fn default() -> DeviceGroupRenderPassBeginInfo { DeviceGroupRenderPassBeginInfo { s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), device_mask: uint32_t::default(), device_render_area_count: uint32_t::default(), - p_device_render_areas: unsafe { ::std::mem::zeroed() }, + p_device_render_areas: ::std::ptr::null(), } } } @@ -9513,7 +9513,7 @@ impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { fn default() -> DeviceGroupCommandBufferBeginInfo { DeviceGroupCommandBufferBeginInfo { s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), device_mask: uint32_t::default(), } } @@ -9534,13 +9534,13 @@ impl ::std::default::Default for DeviceGroupSubmitInfo { fn default() -> DeviceGroupSubmitInfo { DeviceGroupSubmitInfo { s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), wait_semaphore_count: uint32_t::default(), - p_wait_semaphore_device_indices: unsafe { ::std::mem::zeroed() }, + p_wait_semaphore_device_indices: ::std::ptr::null(), command_buffer_count: uint32_t::default(), - p_command_buffer_device_masks: unsafe { ::std::mem::zeroed() }, + p_command_buffer_device_masks: ::std::ptr::null(), signal_semaphore_count: uint32_t::default(), - p_signal_semaphore_device_indices: unsafe { ::std::mem::zeroed() }, + p_signal_semaphore_device_indices: ::std::ptr::null(), } } } @@ -9556,7 +9556,7 @@ impl ::std::default::Default for DeviceGroupBindSparseInfo { fn default() -> DeviceGroupBindSparseInfo { DeviceGroupBindSparseInfo { s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), resource_device_index: uint32_t::default(), memory_device_index: uint32_t::default(), } @@ -9586,7 +9586,7 @@ impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { fn default() -> DeviceGroupPresentCapabilitiesKHR { DeviceGroupPresentCapabilitiesKHR { s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), present_mask: unsafe { ::std::mem::zeroed() }, modes: DeviceGroupPresentModeFlagsKHR::default(), } @@ -9603,7 +9603,7 @@ impl ::std::default::Default for ImageSwapchainCreateInfoKHR { fn default() -> ImageSwapchainCreateInfoKHR { ImageSwapchainCreateInfoKHR { s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), swapchain: SwapchainKHR::default(), } } @@ -9620,7 +9620,7 @@ impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { fn default() -> BindImageMemorySwapchainInfoKHR { BindImageMemorySwapchainInfoKHR { s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), swapchain: SwapchainKHR::default(), image_index: uint32_t::default(), } @@ -9641,7 +9641,7 @@ impl ::std::default::Default for AcquireNextImageInfoKHR { fn default() -> AcquireNextImageInfoKHR { AcquireNextImageInfoKHR { s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), swapchain: SwapchainKHR::default(), timeout: uint64_t::default(), semaphore: Semaphore::default(), @@ -9663,9 +9663,9 @@ impl ::std::default::Default for DeviceGroupPresentInfoKHR { fn default() -> DeviceGroupPresentInfoKHR { DeviceGroupPresentInfoKHR { s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), swapchain_count: uint32_t::default(), - p_device_masks: unsafe { ::std::mem::zeroed() }, + p_device_masks: ::std::ptr::null(), mode: DeviceGroupPresentModeFlagsKHR::default(), } } @@ -9682,9 +9682,9 @@ impl ::std::default::Default for DeviceGroupDeviceCreateInfo { fn default() -> DeviceGroupDeviceCreateInfo { DeviceGroupDeviceCreateInfo { s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), physical_device_count: uint32_t::default(), - p_physical_devices: unsafe { ::std::mem::zeroed() }, + p_physical_devices: ::std::ptr::null(), } } } @@ -9699,7 +9699,7 @@ impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR { fn default() -> DeviceGroupSwapchainCreateInfoKHR { DeviceGroupSwapchainCreateInfoKHR { s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), modes: DeviceGroupPresentModeFlagsKHR::default(), } } @@ -9732,10 +9732,10 @@ impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { fn default() -> DescriptorUpdateTemplateCreateInfo { DescriptorUpdateTemplateCreateInfo { s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), flags: DescriptorUpdateTemplateCreateFlags::default(), descriptor_update_entry_count: uint32_t::default(), - p_descriptor_update_entries: unsafe { ::std::mem::zeroed() }, + p_descriptor_update_entries: ::std::ptr::null(), template_type: DescriptorUpdateTemplateType::default(), descriptor_set_layout: DescriptorSetLayout::default(), pipeline_bind_point: PipelineBindPoint::default(), @@ -9768,7 +9768,7 @@ impl ::std::default::Default for HdrMetadataEXT { fn default() -> HdrMetadataEXT { HdrMetadataEXT { s_type: StructureType::HDR_METADATA_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), display_primary_red: XYColorEXT::default(), display_primary_green: XYColorEXT::default(), display_primary_blue: XYColorEXT::default(), @@ -9806,9 +9806,9 @@ impl ::std::default::Default for PresentTimesInfoGOOGLE { fn default() -> PresentTimesInfoGOOGLE { PresentTimesInfoGOOGLE { s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), swapchain_count: uint32_t::default(), - p_times: unsafe { ::std::mem::zeroed() }, + p_times: ::std::ptr::null(), } } } @@ -9830,9 +9830,9 @@ impl ::std::default::Default for IOSSurfaceCreateInfoMVK { fn default() -> IOSSurfaceCreateInfoMVK { IOSSurfaceCreateInfoMVK { s_type: StructureType::IOS_SURFACE_CREATE_INFO_M, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: IOSSurfaceCreateFlagsMVK::default(), - p_view: unsafe { ::std::mem::zeroed() }, + p_view: ::std::ptr::null(), } } } @@ -9848,9 +9848,9 @@ impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { fn default() -> MacOSSurfaceCreateInfoMVK { MacOSSurfaceCreateInfoMVK { s_type: StructureType::MACOS_SURFACE_CREATE_INFO_M, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: MacOSSurfaceCreateFlagsMVK::default(), - p_view: unsafe { ::std::mem::zeroed() }, + p_view: ::std::ptr::null(), } } } @@ -9873,10 +9873,10 @@ impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { fn default() -> PipelineViewportWScalingStateCreateInfoNV { PipelineViewportWScalingStateCreateInfoNV { s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), viewport_w_scaling_enable: Bool32::default(), viewport_count: uint32_t::default(), - p_viewport_w_scalings: unsafe { ::std::mem::zeroed() }, + p_viewport_w_scalings: ::std::ptr::null(), } } } @@ -9901,10 +9901,10 @@ impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { fn default() -> PipelineViewportSwizzleStateCreateInfoNV { PipelineViewportSwizzleStateCreateInfoNV { s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineViewportSwizzleStateCreateFlagsNV::default(), viewport_count: uint32_t::default(), - p_viewport_swizzles: unsafe { ::std::mem::zeroed() }, + p_viewport_swizzles: ::std::ptr::null(), } } } @@ -9919,7 +9919,7 @@ impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { fn default() -> PhysicalDeviceDiscardRectanglePropertiesEXT { PhysicalDeviceDiscardRectanglePropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_discard_rectangles: uint32_t::default(), } } @@ -9938,11 +9938,11 @@ impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { fn default() -> PipelineDiscardRectangleStateCreateInfoEXT { PipelineDiscardRectangleStateCreateInfoEXT { s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(), discard_rectangle_mode: DiscardRectangleModeEXT::default(), discard_rectangle_count: uint32_t::default(), - p_discard_rectangles: unsafe { ::std::mem::zeroed() }, + p_discard_rectangles: ::std::ptr::null(), } } } @@ -9957,7 +9957,7 @@ impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropert fn default() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), per_view_position_all_components: Bool32::default(), } } @@ -9981,9 +9981,9 @@ impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { fn default() -> RenderPassInputAttachmentAspectCreateInfo { RenderPassInputAttachmentAspectCreateInfo { s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), aspect_reference_count: uint32_t::default(), - p_aspect_references: unsafe { ::std::mem::zeroed() }, + p_aspect_references: ::std::ptr::null(), } } } @@ -9998,7 +9998,7 @@ impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR { fn default() -> PhysicalDeviceSurfaceInfo2KHR { PhysicalDeviceSurfaceInfo2KHR { s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), surface: SurfaceKHR::default(), } } @@ -10014,7 +10014,7 @@ impl ::std::default::Default for SurfaceCapabilities2KHR { fn default() -> SurfaceCapabilities2KHR { SurfaceCapabilities2KHR { s_type: StructureType::SURFACE_CAPABILITIES_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), surface_capabilities: SurfaceCapabilitiesKHR::default(), } } @@ -10030,7 +10030,7 @@ impl ::std::default::Default for SurfaceFormat2KHR { fn default() -> SurfaceFormat2KHR { SurfaceFormat2KHR { s_type: StructureType::SURFACE_FORMAT_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), surface_format: SurfaceFormatKHR::default(), } } @@ -10046,7 +10046,7 @@ impl ::std::default::Default for DisplayProperties2KHR { fn default() -> DisplayProperties2KHR { DisplayProperties2KHR { s_type: StructureType::DISPLAY_PROPERTIES_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), display_properties: DisplayPropertiesKHR::default(), } } @@ -10062,7 +10062,7 @@ impl ::std::default::Default for DisplayPlaneProperties2KHR { fn default() -> DisplayPlaneProperties2KHR { DisplayPlaneProperties2KHR { s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), display_plane_properties: DisplayPlanePropertiesKHR::default(), } } @@ -10078,7 +10078,7 @@ impl ::std::default::Default for DisplayModeProperties2KHR { fn default() -> DisplayModeProperties2KHR { DisplayModeProperties2KHR { s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), display_mode_properties: DisplayModePropertiesKHR::default(), } } @@ -10095,7 +10095,7 @@ impl ::std::default::Default for DisplayPlaneInfo2KHR { fn default() -> DisplayPlaneInfo2KHR { DisplayPlaneInfo2KHR { s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), mode: DisplayModeKHR::default(), plane_index: uint32_t::default(), } @@ -10112,7 +10112,7 @@ impl ::std::default::Default for DisplayPlaneCapabilities2KHR { fn default() -> DisplayPlaneCapabilities2KHR { DisplayPlaneCapabilities2KHR { s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), capabilities: DisplayPlaneCapabilitiesKHR::default(), } } @@ -10128,7 +10128,7 @@ impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { fn default() -> SharedPresentSurfaceCapabilitiesKHR { SharedPresentSurfaceCapabilitiesKHR { s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), shared_present_supported_usage_flags: ImageUsageFlags::default(), } } @@ -10147,7 +10147,7 @@ impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { fn default() -> PhysicalDevice16BitStorageFeatures { PhysicalDevice16BitStorageFeatures { s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), storage_buffer16_bit_access: Bool32::default(), uniform_and_storage_buffer16_bit_access: Bool32::default(), storage_push_constant16: Bool32::default(), @@ -10169,7 +10169,7 @@ impl ::std::default::Default for PhysicalDeviceSubgroupProperties { fn default() -> PhysicalDeviceSubgroupProperties { PhysicalDeviceSubgroupProperties { s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), subgroup_size: uint32_t::default(), supported_stages: ShaderStageFlags::default(), supported_operations: SubgroupFeatureFlags::default(), @@ -10188,7 +10188,7 @@ impl ::std::default::Default for BufferMemoryRequirementsInfo2 { fn default() -> BufferMemoryRequirementsInfo2 { BufferMemoryRequirementsInfo2 { s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), buffer: Buffer::default(), } } @@ -10204,7 +10204,7 @@ impl ::std::default::Default for ImageMemoryRequirementsInfo2 { fn default() -> ImageMemoryRequirementsInfo2 { ImageMemoryRequirementsInfo2 { s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), image: Image::default(), } } @@ -10220,7 +10220,7 @@ impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 { fn default() -> ImageSparseMemoryRequirementsInfo2 { ImageSparseMemoryRequirementsInfo2 { s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), image: Image::default(), } } @@ -10236,7 +10236,7 @@ impl ::std::default::Default for MemoryRequirements2 { fn default() -> MemoryRequirements2 { MemoryRequirements2 { s_type: StructureType::MEMORY_REQUIREMENTS_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), memory_requirements: MemoryRequirements::default(), } } @@ -10252,7 +10252,7 @@ impl ::std::default::Default for SparseImageMemoryRequirements2 { fn default() -> SparseImageMemoryRequirements2 { SparseImageMemoryRequirements2 { s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), memory_requirements: SparseImageMemoryRequirements::default(), } } @@ -10268,7 +10268,7 @@ impl ::std::default::Default for PhysicalDevicePointClippingProperties { fn default() -> PhysicalDevicePointClippingProperties { PhysicalDevicePointClippingProperties { s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), point_clipping_behavior: PointClippingBehavior::default(), } } @@ -10285,7 +10285,7 @@ impl ::std::default::Default for MemoryDedicatedRequirements { fn default() -> MemoryDedicatedRequirements { MemoryDedicatedRequirements { s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), prefers_dedicated_allocation: Bool32::default(), requires_dedicated_allocation: Bool32::default(), } @@ -10303,7 +10303,7 @@ impl ::std::default::Default for MemoryDedicatedAllocateInfo { fn default() -> MemoryDedicatedAllocateInfo { MemoryDedicatedAllocateInfo { s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), image: Image::default(), buffer: Buffer::default(), } @@ -10320,7 +10320,7 @@ impl ::std::default::Default for ImageViewUsageCreateInfo { fn default() -> ImageViewUsageCreateInfo { ImageViewUsageCreateInfo { s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), usage: ImageUsageFlags::default(), } } @@ -10336,7 +10336,7 @@ impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo fn default() -> PipelineTessellationDomainOriginStateCreateInfo { PipelineTessellationDomainOriginStateCreateInfo { s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), domain_origin: TessellationDomainOrigin::default(), } } @@ -10352,7 +10352,7 @@ impl ::std::default::Default for SamplerYcbcrConversionInfo { fn default() -> SamplerYcbcrConversionInfo { SamplerYcbcrConversionInfo { s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), conversion: SamplerYcbcrConversion::default(), } } @@ -10375,7 +10375,7 @@ impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { fn default() -> SamplerYcbcrConversionCreateInfo { SamplerYcbcrConversionCreateInfo { s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), format: Format::default(), ycbcr_model: SamplerYcbcrModelConversion::default(), ycbcr_range: SamplerYcbcrRange::default(), @@ -10398,7 +10398,7 @@ impl ::std::default::Default for BindImagePlaneMemoryInfo { fn default() -> BindImagePlaneMemoryInfo { BindImagePlaneMemoryInfo { s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), plane_aspect: ImageAspectFlags::default(), } } @@ -10414,7 +10414,7 @@ impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo { fn default() -> ImagePlaneMemoryRequirementsInfo { ImagePlaneMemoryRequirementsInfo { s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), plane_aspect: ImageAspectFlags::default(), } } @@ -10430,7 +10430,7 @@ impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { fn default() -> PhysicalDeviceSamplerYcbcrConversionFeatures { PhysicalDeviceSamplerYcbcrConversionFeatures { s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), sampler_ycbcr_conversion: Bool32::default(), } } @@ -10446,7 +10446,7 @@ impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { fn default() -> SamplerYcbcrConversionImageFormatProperties { SamplerYcbcrConversionImageFormatProperties { s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), combined_image_sampler_descriptor_count: uint32_t::default(), } } @@ -10462,7 +10462,7 @@ impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD { fn default() -> TextureLODGatherFormatPropertiesAMD { TextureLODGatherFormatPropertiesAMD { s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), supports_texture_gather_lod_bias_amd: Bool32::default(), } } @@ -10478,7 +10478,7 @@ impl ::std::default::Default for ProtectedSubmitInfo { fn default() -> ProtectedSubmitInfo { ProtectedSubmitInfo { s_type: StructureType::PROTECTED_SUBMIT_INFO, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), protected_submit: Bool32::default(), } } @@ -10494,7 +10494,7 @@ impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { fn default() -> PhysicalDeviceProtectedMemoryFeatures { PhysicalDeviceProtectedMemoryFeatures { s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), protected_memory: Bool32::default(), } } @@ -10510,7 +10510,7 @@ impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties { fn default() -> PhysicalDeviceProtectedMemoryProperties { PhysicalDeviceProtectedMemoryProperties { s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), protected_no_fault: Bool32::default(), } } @@ -10528,7 +10528,7 @@ impl ::std::default::Default for DeviceQueueInfo2 { fn default() -> DeviceQueueInfo2 { DeviceQueueInfo2 { s_type: StructureType::DEVICE_QUEUE_INFO_2, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DeviceQueueCreateFlags::default(), queue_family_index: uint32_t::default(), queue_index: uint32_t::default(), @@ -10548,7 +10548,7 @@ impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { fn default() -> PipelineCoverageToColorStateCreateInfoNV { PipelineCoverageToColorStateCreateInfoNV { s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineCoverageToColorStateCreateFlagsNV::default(), coverage_to_color_enable: Bool32::default(), coverage_to_color_location: uint32_t::default(), @@ -10567,7 +10567,7 @@ impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT fn default() -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), filter_minmax_single_component_formats: Bool32::default(), filter_minmax_image_component_mapping: Bool32::default(), } @@ -10593,11 +10593,11 @@ impl ::std::default::Default for SampleLocationsInfoEXT { fn default() -> SampleLocationsInfoEXT { SampleLocationsInfoEXT { s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), sample_locations_per_pixel: SampleCountFlags::default(), sample_location_grid_size: Extent2D::default(), sample_locations_count: uint32_t::default(), - p_sample_locations: unsafe { ::std::mem::zeroed() }, + p_sample_locations: ::std::ptr::null(), } } } @@ -10627,11 +10627,11 @@ impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { fn default() -> RenderPassSampleLocationsBeginInfoEXT { RenderPassSampleLocationsBeginInfoEXT { s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), attachment_initial_sample_locations_count: uint32_t::default(), - p_attachment_initial_sample_locations: unsafe { ::std::mem::zeroed() }, + p_attachment_initial_sample_locations: ::std::ptr::null(), post_subpass_sample_locations_count: uint32_t::default(), - p_post_subpass_sample_locations: unsafe { ::std::mem::zeroed() }, + p_post_subpass_sample_locations: ::std::ptr::null(), } } } @@ -10647,7 +10647,7 @@ impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { fn default() -> PipelineSampleLocationsStateCreateInfoEXT { PipelineSampleLocationsStateCreateInfoEXT { s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), sample_locations_enable: Bool32::default(), sample_locations_info: SampleLocationsInfoEXT::default(), } @@ -10694,7 +10694,7 @@ impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { fn default() -> PhysicalDeviceSampleLocationsPropertiesEXT { PhysicalDeviceSampleLocationsPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), sample_location_sample_counts: SampleCountFlags::default(), max_sample_location_grid_size: Extent2D::default(), sample_location_coordinate_range: unsafe { ::std::mem::zeroed() }, @@ -10714,7 +10714,7 @@ impl ::std::default::Default for MultisamplePropertiesEXT { fn default() -> MultisamplePropertiesEXT { MultisamplePropertiesEXT { s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_sample_location_grid_size: Extent2D::default(), } } @@ -10730,7 +10730,7 @@ impl ::std::default::Default for SamplerReductionModeCreateInfoEXT { fn default() -> SamplerReductionModeCreateInfoEXT { SamplerReductionModeCreateInfoEXT { s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), reduction_mode: SamplerReductionModeEXT::default(), } } @@ -10746,7 +10746,7 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT fn default() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT { PhysicalDeviceBlendOperationAdvancedFeaturesEXT { s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), advanced_blend_coherent_operations: Bool32::default(), } } @@ -10767,7 +10767,7 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesE fn default() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT { PhysicalDeviceBlendOperationAdvancedPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), advanced_blend_max_color_attachments: uint32_t::default(), advanced_blend_independent_blend: Bool32::default(), advanced_blend_non_premultiplied_src_color: Bool32::default(), @@ -10790,7 +10790,7 @@ impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT { fn default() -> PipelineColorBlendAdvancedStateCreateInfoEXT { PipelineColorBlendAdvancedStateCreateInfoEXT { s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), src_premultiplied: Bool32::default(), dst_premultiplied: Bool32::default(), blend_overlap: BlendOverlapEXT::default(), @@ -10812,12 +10812,12 @@ impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { fn default() -> PipelineCoverageModulationStateCreateInfoNV { PipelineCoverageModulationStateCreateInfoNV { s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineCoverageModulationStateCreateFlagsNV::default(), coverage_modulation_mode: CoverageModulationModeNV::default(), coverage_modulation_table_enable: Bool32::default(), coverage_modulation_table_count: uint32_t::default(), - p_coverage_modulation_table: unsafe { ::std::mem::zeroed() }, + p_coverage_modulation_table: ::std::ptr::null(), } } } @@ -10833,9 +10833,9 @@ impl ::std::default::Default for ImageFormatListCreateInfoKHR { fn default() -> ImageFormatListCreateInfoKHR { ImageFormatListCreateInfoKHR { s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO_KHR, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), view_format_count: uint32_t::default(), - p_view_formats: unsafe { ::std::mem::zeroed() }, + p_view_formats: ::std::ptr::null(), } } } @@ -10852,10 +10852,10 @@ impl ::std::default::Default for ValidationCacheCreateInfoEXT { fn default() -> ValidationCacheCreateInfoEXT { ValidationCacheCreateInfoEXT { s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: ValidationCacheCreateFlagsEXT::default(), initial_data_size: size_t::default(), - p_initial_data: unsafe { ::std::mem::zeroed() }, + p_initial_data: ::std::ptr::null(), } } } @@ -10870,7 +10870,7 @@ impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { fn default() -> ShaderModuleValidationCacheCreateInfoEXT { ShaderModuleValidationCacheCreateInfoEXT { s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), validation_cache: ValidationCacheEXT::default(), } } @@ -10887,7 +10887,7 @@ impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { fn default() -> PhysicalDeviceMaintenance3Properties { PhysicalDeviceMaintenance3Properties { s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_per_set_descriptors: uint32_t::default(), max_memory_allocation_size: DeviceSize::default(), } @@ -10904,7 +10904,7 @@ impl ::std::default::Default for DescriptorSetLayoutSupport { fn default() -> DescriptorSetLayoutSupport { DescriptorSetLayoutSupport { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), supported: Bool32::default(), } } @@ -10920,7 +10920,7 @@ impl ::std::default::Default for PhysicalDeviceShaderDrawParameterFeatures { fn default() -> PhysicalDeviceShaderDrawParameterFeatures { PhysicalDeviceShaderDrawParameterFeatures { s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), shader_draw_parameters: Bool32::default(), } } @@ -10939,8 +10939,8 @@ impl ::std::default::Default for NativeBufferANDROID { fn default() -> NativeBufferANDROID { NativeBufferANDROID { s_type: StructureType::NATIVE_BUFFER_ANDROID, - p_next: unsafe { ::std::mem::zeroed() }, - handle: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + handle: ::std::ptr::null(), stride: c_int::default(), format: c_int::default(), usage: c_int::default(), @@ -11006,7 +11006,7 @@ impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoEXT { fn default() -> DeviceQueueGlobalPriorityCreateInfoEXT { DeviceQueueGlobalPriorityCreateInfoEXT { s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), global_priority: QueueGlobalPriorityEXT::default(), } } @@ -11024,10 +11024,10 @@ impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { fn default() -> DebugUtilsObjectNameInfoEXT { DebugUtilsObjectNameInfoEXT { s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), object_type: ObjectType::default(), object_handle: uint64_t::default(), - p_object_name: unsafe { ::std::mem::zeroed() }, + p_object_name: ::std::ptr::null(), } } } @@ -11046,12 +11046,12 @@ impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { fn default() -> DebugUtilsObjectTagInfoEXT { DebugUtilsObjectTagInfoEXT { s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), object_type: ObjectType::default(), object_handle: uint64_t::default(), tag_name: uint64_t::default(), tag_size: size_t::default(), - p_tag: unsafe { ::std::mem::zeroed() }, + p_tag: ::std::ptr::null(), } } } @@ -11079,8 +11079,8 @@ impl ::std::default::Default for DebugUtilsLabelEXT { fn default() -> DebugUtilsLabelEXT { DebugUtilsLabelEXT { s_type: StructureType::DEBUG_UTILS_LABEL_EXT, - p_next: unsafe { ::std::mem::zeroed() }, - p_label_name: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + p_label_name: ::std::ptr::null(), color: unsafe { ::std::mem::zeroed() }, } } @@ -11113,12 +11113,12 @@ impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { fn default() -> DebugUtilsMessengerCreateInfoEXT { DebugUtilsMessengerCreateInfoEXT { s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DebugUtilsMessengerCreateFlagsEXT::default(), message_severity: DebugUtilsMessageSeverityFlagsEXT::default(), message_type: DebugUtilsMessageTypeFlagsEXT::default(), pfn_user_callback: unsafe { ::std::mem::zeroed() }, - p_user_data: unsafe { ::std::mem::zeroed() }, + p_user_data: ::std::ptr::null_mut(), } } } @@ -11142,17 +11142,17 @@ impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { fn default() -> DebugUtilsMessengerCallbackDataEXT { DebugUtilsMessengerCallbackDataEXT { s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(), - p_message_id_name: unsafe { ::std::mem::zeroed() }, + p_message_id_name: ::std::ptr::null(), message_id_number: int32_t::default(), - p_message: unsafe { ::std::mem::zeroed() }, + p_message: ::std::ptr::null(), queue_label_count: uint32_t::default(), - p_queue_labels: unsafe { ::std::mem::zeroed() }, + p_queue_labels: ::std::ptr::null_mut(), cmd_buf_label_count: uint32_t::default(), - p_cmd_buf_labels: unsafe { ::std::mem::zeroed() }, + p_cmd_buf_labels: ::std::ptr::null_mut(), object_count: uint32_t::default(), - p_objects: unsafe { ::std::mem::zeroed() }, + p_objects: ::std::ptr::null_mut(), } } } @@ -11168,9 +11168,9 @@ impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { fn default() -> ImportMemoryHostPointerInfoEXT { ImportMemoryHostPointerInfoEXT { s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), - p_host_pointer: unsafe { ::std::mem::zeroed() }, + p_host_pointer: ::std::ptr::null_mut(), } } } @@ -11185,7 +11185,7 @@ impl ::std::default::Default for MemoryHostPointerPropertiesEXT { fn default() -> MemoryHostPointerPropertiesEXT { MemoryHostPointerPropertiesEXT { s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), memory_type_bits: uint32_t::default(), } } @@ -11201,7 +11201,7 @@ impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { fn default() -> PhysicalDeviceExternalMemoryHostPropertiesEXT { PhysicalDeviceExternalMemoryHostPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), min_imported_host_pointer_alignment: DeviceSize::default(), } } @@ -11225,7 +11225,7 @@ impl ::std::default::Default for PhysicalDeviceConservativeRasterizationProperti fn default() -> PhysicalDeviceConservativeRasterizationPropertiesEXT { PhysicalDeviceConservativeRasterizationPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), primitive_overestimation_size: c_float::default(), max_extra_primitive_overestimation_size: c_float::default(), extra_primitive_overestimation_size_granularity: c_float::default(), @@ -11262,7 +11262,7 @@ impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { fn default() -> PhysicalDeviceShaderCorePropertiesAMD { PhysicalDeviceShaderCorePropertiesAMD { s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), shader_engine_count: uint32_t::default(), shader_arrays_per_engine_count: uint32_t::default(), compute_units_per_shader_array: uint32_t::default(), @@ -11293,7 +11293,7 @@ impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInf fn default() -> PipelineRasterizationConservativeStateCreateInfoEXT { PipelineRasterizationConservativeStateCreateInfoEXT { s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(), conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(), extra_primitive_overestimation_size: c_float::default(), @@ -11330,7 +11330,7 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeaturesEXT { fn default() -> PhysicalDeviceDescriptorIndexingFeaturesEXT { PhysicalDeviceDescriptorIndexingFeaturesEXT { s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), shader_input_attachment_array_dynamic_indexing: Bool32::default(), shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(), shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(), @@ -11387,7 +11387,7 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingPropertiesEXT { fn default() -> PhysicalDeviceDescriptorIndexingPropertiesEXT { PhysicalDeviceDescriptorIndexingPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_update_after_bind_descriptors_in_all_pools: uint32_t::default(), shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(), shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(), @@ -11426,9 +11426,9 @@ impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfoEXT { fn default() -> DescriptorSetLayoutBindingFlagsCreateInfoEXT { DescriptorSetLayoutBindingFlagsCreateInfoEXT { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), binding_count: uint32_t::default(), - p_binding_flags: unsafe { ::std::mem::zeroed() }, + p_binding_flags: ::std::ptr::null(), } } } @@ -11444,9 +11444,9 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInf fn default() -> DescriptorSetVariableDescriptorCountAllocateInfoEXT { DescriptorSetVariableDescriptorCountAllocateInfoEXT { s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), descriptor_set_count: uint32_t::default(), - p_descriptor_counts: unsafe { ::std::mem::zeroed() }, + p_descriptor_counts: ::std::ptr::null(), } } } @@ -11461,7 +11461,7 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSuppo fn default() -> DescriptorSetVariableDescriptorCountLayoutSupportEXT { DescriptorSetVariableDescriptorCountLayoutSupportEXT { s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_variable_descriptor_count: uint32_t::default(), } } @@ -11484,9 +11484,9 @@ impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { fn default() -> PipelineVertexInputDivisorStateCreateInfoEXT { PipelineVertexInputDivisorStateCreateInfoEXT { s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), vertex_binding_divisor_count: uint32_t::default(), - p_vertex_binding_divisors: unsafe { ::std::mem::zeroed() }, + p_vertex_binding_divisors: ::std::ptr::null(), } } } @@ -11501,7 +11501,7 @@ impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesE fn default() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { PhysicalDeviceVertexAttributeDivisorPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), max_vertex_attrib_divisor: uint32_t::default(), } } @@ -11517,8 +11517,8 @@ impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { fn default() -> ImportAndroidHardwareBufferInfoANDROID { ImportAndroidHardwareBufferInfoANDROID { s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, - p_next: unsafe { ::std::mem::zeroed() }, - buffer: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + buffer: ::std::ptr::null_mut(), } } } @@ -11533,7 +11533,7 @@ impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { fn default() -> AndroidHardwareBufferUsageANDROID { AndroidHardwareBufferUsageANDROID { s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), android_hardware_buffer_usage: uint64_t::default(), } } @@ -11550,7 +11550,7 @@ impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { fn default() -> AndroidHardwareBufferPropertiesANDROID { AndroidHardwareBufferPropertiesANDROID { s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), allocation_size: DeviceSize::default(), memory_type_bits: uint32_t::default(), } @@ -11567,7 +11567,7 @@ impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID { fn default() -> MemoryGetAndroidHardwareBufferInfoANDROID { MemoryGetAndroidHardwareBufferInfoANDROID { s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), memory: DeviceMemory::default(), } } @@ -11590,7 +11590,7 @@ impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { fn default() -> AndroidHardwareBufferFormatPropertiesANDROID { AndroidHardwareBufferFormatPropertiesANDROID { s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), format: Format::default(), external_format: uint64_t::default(), format_features: FormatFeatureFlags::default(), @@ -11613,7 +11613,7 @@ impl ::std::default::Default for ExternalFormatANDROID { fn default() -> ExternalFormatANDROID { ExternalFormatANDROID { s_type: StructureType::EXTERNAL_FORMAT_ANDROID, - p_next: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), external_format: uint64_t::default(), } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 47ea4ad..150904c 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1156,8 +1156,37 @@ pub fn derive_default(_struct: &vkxml::Struct) -> Option { #param_ident: unsafe { ::std::mem::zeroed() } } } - } else if field.reference.is_some() - || is_static_array(field) + } else if let Some(ref reference) = field.reference { + match reference { + vkxml::ReferenceType::Pointer => { + if field.is_const { + quote!{ + #param_ident: ::std::ptr::null() + } + } else { + quote!{ + #param_ident: ::std::ptr::null_mut() + } + } + } + vkxml::ReferenceType::PointerToPointer => { + quote!{ + #param_ident: ::std::ptr::null_mut() + } + } + vkxml::ReferenceType::PointerToConstPointer => { + if field.is_const { + quote!{ + #param_ident: ::std::ptr::null() + } + } else { + quote!{ + #param_ident: ::std::ptr::null_mut() + } + } + } + } + } else if is_static_array(field) || is_pfn(field) || handles.contains(&field.basetype.as_str()) { @@ -1610,7 +1639,7 @@ pub fn write_source_code(path: &Path) { }; acc }); - + let constants_code: Vec<_> = constants .iter() .map(|constant| generate_constant(constant, &mut const_cache)) From 53161660efb95f80f6fc02ea9240f9dd5172de40 Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Thu, 23 Aug 2018 10:22:06 +0300 Subject: [PATCH 084/122] Fix instance getters to support extensions This commit allows the user to pass in a chain of structures to be filled in by the Vulkan driver. --- ash/src/instance.rs | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 50c459a..8b3e6ff 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -108,16 +108,13 @@ pub trait InstanceV1_1: InstanceV1_0 { } } - fn get_physical_device_properties2( + unsafe fn get_physical_device_properties2( &self, physical_device: vk::PhysicalDevice, - ) -> vk::PhysicalDeviceProperties2 { - unsafe { - let mut prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_properties2(physical_device, &mut prop); - prop - } + prop: &mut vk::PhysicalDeviceProperties2, + ) { + self.fp_v1_1() + .get_physical_device_properties2(physical_device, prop); } fn get_physical_device_format_properties2( @@ -140,15 +137,15 @@ pub trait InstanceV1_1: InstanceV1_0 { &self, physical_device: vk::PhysicalDevice, format_info: &vk::PhysicalDeviceImageFormatInfo2, - ) -> VkResult { - let mut image_format_prop = mem::uninitialized(); + image_format_prop: &mut vk::ImageFormatProperties2 + ) -> VkResult<()> { let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( physical_device, format_info, - &mut image_format_prop, + image_format_prop, ); if err_code == vk::Result::SUCCESS { - Ok(image_format_prop) + Ok(()) } else { Err(err_code) } From a10935eaf701845abac26dc433b43aadf29e2565 Mon Sep 17 00:00:00 2001 From: Brian Merchant Date: Sun, 19 Aug 2018 00:18:30 -0700 Subject: [PATCH 085/122] bug fixes for VK_EXT_debug_utils wrapper --- ash/src/extensions/debug_report.rs | 2 +- ash/src/extensions/debug_utils.rs | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/ash/src/extensions/debug_report.rs b/ash/src/extensions/debug_report.rs index 35e00e5..fda418f 100644 --- a/ash/src/extensions/debug_report.rs +++ b/ash/src/extensions/debug_report.rs @@ -22,7 +22,7 @@ impl DebugReport { })?; Ok(DebugReport { handle: instance.handle(), - debug_report_fn: debug_report_fn, + debug_report_fn, }) } diff --git a/ash/src/extensions/debug_utils.rs b/ash/src/extensions/debug_utils.rs index dd8d2ea..836e0fb 100644 --- a/ash/src/extensions/debug_utils.rs +++ b/ash/src/extensions/debug_utils.rs @@ -2,24 +2,26 @@ use prelude::*; use std::ffi::CStr; use std::mem; -use version::{DeviceV1_0, InstanceV1_0}; +use version::{EntryV1_0, InstanceV1_0}; use {vk, RawPtr}; #[derive(Clone)] pub struct DebugUtils { + handle: vk::Instance, debug_utils_fn: vk::ExtDebugUtilsFn, } impl DebugUtils { - pub fn new( + pub fn new( + entry: &E, instance: &I, - device: &D, ) -> Result> { let debug_utils_fn = vk::ExtDebugUtilsFn::load(|name| unsafe { - mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) })?; Ok(DebugUtils { - debug_utils_fn: debug_utils_fn, + handle: instance.handle(), + debug_utils_fn, }) } @@ -98,13 +100,12 @@ impl DebugUtils { pub unsafe fn create_debug_utils_messenger_ext( &self, - instance: vk::Instance, create_info: &vk::DebugUtilsMessengerCreateInfoEXT, allocator: Option<&vk::AllocationCallbacks>, ) -> VkResult { let mut messenger = mem::uninitialized(); let err_code = self.debug_utils_fn.create_debug_utils_messenger_ext( - instance, + self.handle, create_info, allocator.as_raw_ptr(), &mut messenger, @@ -117,12 +118,11 @@ impl DebugUtils { pub unsafe fn destroy_debug_utils_messenger_ext( &self, - instance: vk::Instance, messenger: vk::DebugUtilsMessengerEXT, allocator: Option<&vk::AllocationCallbacks>, ) { self.debug_utils_fn.destroy_debug_utils_messenger_ext( - instance, + self.handle, messenger, allocator.as_raw_ptr(), ); From 0786d71b39d5a3eb980eba2d64615300d075afef Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Sat, 25 Aug 2018 10:48:49 +0300 Subject: [PATCH 086/122] Fix Vulkan version macros --- ash/src/vk.rs | 6 +++--- generator/src/lib.rs | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 3aa4054..eebf8a8 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -19,19 +19,19 @@ macro_rules! vk_make_version { #[macro_export] macro_rules! vk_version_major { ($major:expr) => { - ($major as uint32_t) >> 22 + ($major as u32) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { ($minor:expr) => { - (($minor as uint32_t) >> 12) & 0x3ff + (($minor as u32) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { ($minor:expr) => { - ($minor as uint32_t) & 0xfff + ($minor as u32) & 0xfff }; } pub type RROutput = c_ulong; diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 2257e24..d8efec8 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -163,21 +163,21 @@ pub fn vk_version_macros() -> Tokens { #[macro_export] macro_rules! vk_version_major { ($major:expr) => { - ($major as uint32_t) >> 22 + ($major as u32) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { ($minor:expr) => { - (($minor as uint32_t) >> 12) & 0x3ff + (($minor as u32) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { ($minor:expr) => { - ($minor as uint32_t) & 0xfff + ($minor as u32) & 0xfff }; } } From 86bdc3cecdcd67a11176b48e15b67548fca204ff Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Sat, 25 Aug 2018 11:06:30 +0300 Subject: [PATCH 087/122] Fix closing the examples --- examples/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index a197f4c..497e090 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -253,7 +253,7 @@ impl ExampleBase { ControlFlow::Continue } } - WindowEvent::Destroyed => winit::ControlFlow::Break, + WindowEvent::CloseRequested => winit::ControlFlow::Break, _ => ControlFlow::Continue, }, _ => ControlFlow::Continue, From 0c26422215ec59f98ac3166549ca4d8b19ec062f Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Sat, 25 Aug 2018 11:53:15 +0300 Subject: [PATCH 088/122] Separate getters for vectors into two functions One is safe, used to determine how many structures will be returned. The other is unsafe, and takes in a mutable reference to an array of structure chains. --- ash/src/instance.rs | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 8b3e6ff..51a378f 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -151,10 +151,10 @@ pub trait InstanceV1_1: InstanceV1_0 { } } - fn get_physical_device_queue_family_properties2( + fn get_physical_device_queue_family_properties2_len( &self, physical_device: vk::PhysicalDevice, - ) -> Vec { + ) -> usize { unsafe { let mut queue_count = 0; self.fp_v1_1().get_physical_device_queue_family_properties2( @@ -162,17 +162,23 @@ pub trait InstanceV1_1: InstanceV1_0 { &mut queue_count, ptr::null_mut(), ); - let mut queue_families_vec = Vec::with_capacity(queue_count as usize); - self.fp_v1_1().get_physical_device_queue_family_properties2( - physical_device, - &mut queue_count, - queue_families_vec.as_mut_ptr(), - ); - queue_families_vec.set_len(queue_count as usize); - queue_families_vec + queue_count as usize } } + unsafe fn get_physical_device_queue_family_properties2( + &self, + physical_device: vk::PhysicalDevice, + queue_family_props: &mut [vk::QueueFamilyProperties2] + ) { + let mut queue_count = queue_family_props.len() as u32; + self.fp_v1_1().get_physical_device_queue_family_properties2( + physical_device, + &mut queue_count, + queue_family_props.as_mut_ptr(), + ); + } + fn get_physical_device_memory_properties2( &self, physical_device: vk::PhysicalDevice, From b722b0f3a9ec22e080e2fcf56fe86909805448b9 Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Sat, 25 Aug 2018 14:09:44 +0300 Subject: [PATCH 089/122] Map all integer types to Rust types --- ash/src/vk.rs | 5203 +++++++++++++++++++++--------------------- generator/src/lib.rs | 11 +- 2 files changed, 2611 insertions(+), 2603 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index eebf8a8..5c548a2 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -183,7 +183,7 @@ macro_rules! handle_nondispatchable { ($name:ident, $ty:ident) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] - pub struct $name(uint64_t); + pub struct $name(u64); impl Handle for $name { const TYPE: ObjectType = ObjectType::$ty; fn as_raw(self) -> u64 { @@ -297,11 +297,11 @@ pub struct EntryFnV1_0 { enumerate_instance_extension_properties: extern "system" fn( p_layer_name: *const c_char, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result, enumerate_instance_layer_properties: - extern "system" fn(p_property_count: *mut uint32_t, p_properties: *mut LayerProperties) + extern "system" fn(p_property_count: *mut u32, p_properties: *mut LayerProperties) -> Result, } unsafe impl Send for EntryFnV1_0 {} @@ -367,14 +367,14 @@ impl EntryFnV1_0 { pub unsafe fn enumerate_instance_extension_properties( &self, p_layer_name: *const c_char, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result { (self.enumerate_instance_extension_properties)(p_layer_name, p_property_count, p_properties) } pub unsafe fn enumerate_instance_layer_properties( &self, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result { (self.enumerate_instance_layer_properties)(p_property_count, p_properties) @@ -385,7 +385,7 @@ pub struct InstanceFnV1_0 { extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks) -> c_void, enumerate_physical_devices: extern "system" fn( instance: Instance, - p_physical_device_count: *mut uint32_t, + p_physical_device_count: *mut u32, p_physical_devices: *mut PhysicalDevice, ) -> Result, get_physical_device_features: extern "system" fn( @@ -415,7 +415,7 @@ pub struct InstanceFnV1_0 { get_physical_device_queue_family_properties: extern "system" fn( physical_device: PhysicalDevice, - p_queue_family_property_count: *mut uint32_t, + p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void, get_physical_device_memory_properties: @@ -435,12 +435,12 @@ pub struct InstanceFnV1_0 { extern "system" fn( physical_device: PhysicalDevice, p_layer_name: *const c_char, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result, enumerate_device_layer_properties: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result, get_physical_device_sparse_image_format_properties: @@ -451,7 +451,7 @@ pub struct InstanceFnV1_0 { samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties, ) -> c_void, } @@ -620,7 +620,7 @@ impl InstanceFnV1_0 { pub unsafe fn enumerate_physical_devices( &self, instance: Instance, - p_physical_device_count: *mut uint32_t, + p_physical_device_count: *mut u32, p_physical_devices: *mut PhysicalDevice, ) -> Result { (self.enumerate_physical_devices)(instance, p_physical_device_count, p_physical_devices) @@ -670,7 +670,7 @@ impl InstanceFnV1_0 { pub unsafe fn get_physical_device_queue_family_properties( &self, physical_device: PhysicalDevice, - p_queue_family_property_count: *mut uint32_t, + p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void { (self.get_physical_device_queue_family_properties)( @@ -706,7 +706,7 @@ impl InstanceFnV1_0 { &self, physical_device: PhysicalDevice, p_layer_name: *const c_char, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result { (self.enumerate_device_extension_properties)( @@ -719,7 +719,7 @@ impl InstanceFnV1_0 { pub unsafe fn enumerate_device_layer_properties( &self, physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result { (self.enumerate_device_layer_properties)(physical_device, p_property_count, p_properties) @@ -732,7 +732,7 @@ impl InstanceFnV1_0 { samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties, ) -> c_void { (self.get_physical_device_sparse_image_format_properties)( @@ -752,13 +752,13 @@ pub struct DeviceFnV1_0 { extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks) -> c_void, get_device_queue: extern "system" fn( device: Device, - queue_family_index: uint32_t, - queue_index: uint32_t, + queue_family_index: u32, + queue_index: u32, p_queue: *mut Queue, ) -> c_void, queue_submit: extern "system" fn( queue: Queue, - submit_count: uint32_t, + submit_count: u32, p_submits: *const SubmitInfo, fence: Fence, ) -> Result, @@ -786,12 +786,12 @@ pub struct DeviceFnV1_0 { unmap_memory: extern "system" fn(device: Device, memory: DeviceMemory) -> c_void, flush_mapped_memory_ranges: extern "system" fn( device: Device, - memory_range_count: uint32_t, + memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result, invalidate_mapped_memory_ranges: extern "system" fn( device: Device, - memory_range_count: uint32_t, + memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result, get_device_memory_commitment: extern "system" fn( @@ -827,12 +827,12 @@ pub struct DeviceFnV1_0 { extern "system" fn( device: Device, image: Image, - p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void, queue_bind_sparse: extern "system" fn( queue: Queue, - bind_info_count: uint32_t, + bind_info_count: u32, p_bind_info: *const BindSparseInfo, fence: Fence, ) -> Result, @@ -846,14 +846,14 @@ pub struct DeviceFnV1_0 { extern "system" fn(device: Device, fence: Fence, p_allocator: *const AllocationCallbacks) -> c_void, reset_fences: - extern "system" fn(device: Device, fence_count: uint32_t, p_fences: *const Fence) -> Result, + extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result, get_fence_status: extern "system" fn(device: Device, fence: Fence) -> Result, wait_for_fences: extern "system" fn( device: Device, - fence_count: uint32_t, + fence_count: u32, p_fences: *const Fence, wait_all: Bool32, - timeout: uint64_t, + timeout: u64, ) -> Result, create_semaphore: extern "system" fn( device: Device, @@ -892,9 +892,9 @@ pub struct DeviceFnV1_0 { get_query_pool_results: extern "system" fn( device: Device, query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - data_size: size_t, + first_query: u32, + query_count: u32, + data_size: usize, p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, @@ -970,20 +970,20 @@ pub struct DeviceFnV1_0 { get_pipeline_cache_data: extern "system" fn( device: Device, pipeline_cache: PipelineCache, - p_data_size: *mut size_t, + p_data_size: *mut usize, p_data: *mut c_void, ) -> Result, merge_pipeline_caches: extern "system" fn( device: Device, dst_cache: PipelineCache, - src_cache_count: uint32_t, + src_cache_count: u32, p_src_caches: *const PipelineCache, ) -> Result, create_graphics_pipelines: extern "system" fn( device: Device, pipeline_cache: PipelineCache, - create_info_count: uint32_t, + create_info_count: u32, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, @@ -991,7 +991,7 @@ pub struct DeviceFnV1_0 { create_compute_pipelines: extern "system" fn( device: Device, pipeline_cache: PipelineCache, - create_info_count: uint32_t, + create_info_count: u32, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, @@ -1059,14 +1059,14 @@ pub struct DeviceFnV1_0 { free_descriptor_sets: extern "system" fn( device: Device, descriptor_pool: DescriptorPool, - descriptor_set_count: uint32_t, + descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, ) -> Result, update_descriptor_sets: extern "system" fn( device: Device, - descriptor_write_count: uint32_t, + descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, - descriptor_copy_count: uint32_t, + descriptor_copy_count: u32, p_descriptor_copies: *const CopyDescriptorSet, ) -> c_void, create_framebuffer: extern "system" fn( @@ -1116,7 +1116,7 @@ pub struct DeviceFnV1_0 { free_command_buffers: extern "system" fn( device: Device, command_pool: CommandPool, - command_buffer_count: uint32_t, + command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void, begin_command_buffer: extern "system" fn( @@ -1133,14 +1133,14 @@ pub struct DeviceFnV1_0 { ) -> c_void, cmd_set_viewport: extern "system" fn( command_buffer: CommandBuffer, - first_viewport: uint32_t, - viewport_count: uint32_t, + first_viewport: u32, + viewport_count: u32, p_viewports: *const Viewport, ) -> c_void, cmd_set_scissor: extern "system" fn( command_buffer: CommandBuffer, - first_scissor: uint32_t, - scissor_count: uint32_t, + first_scissor: u32, + scissor_count: u32, p_scissors: *const Rect2D, ) -> c_void, cmd_set_line_width: @@ -1161,27 +1161,27 @@ pub struct DeviceFnV1_0 { cmd_set_stencil_compare_mask: extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, - compare_mask: uint32_t, + compare_mask: u32, ) -> c_void, cmd_set_stencil_write_mask: extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, - write_mask: uint32_t, + write_mask: u32, ) -> c_void, cmd_set_stencil_reference: extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, - reference: uint32_t, + reference: u32, ) -> c_void, cmd_bind_descriptor_sets: extern "system" fn( command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, - first_set: uint32_t, - descriptor_set_count: uint32_t, + first_set: u32, + descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, - dynamic_offset_count: uint32_t, - p_dynamic_offsets: *const uint32_t, + dynamic_offset_count: u32, + p_dynamic_offsets: *const u32, ) -> c_void, cmd_bind_index_buffer: extern "system" fn( command_buffer: CommandBuffer, @@ -1191,45 +1191,45 @@ pub struct DeviceFnV1_0 { ) -> c_void, cmd_bind_vertex_buffers: extern "system" fn( command_buffer: CommandBuffer, - first_binding: uint32_t, - binding_count: uint32_t, + first_binding: u32, + binding_count: u32, p_buffers: *const Buffer, p_offsets: *const DeviceSize, ) -> c_void, cmd_draw: extern "system" fn( command_buffer: CommandBuffer, - vertex_count: uint32_t, - instance_count: uint32_t, - first_vertex: uint32_t, - first_instance: uint32_t, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, ) -> c_void, cmd_draw_indexed: extern "system" fn( command_buffer: CommandBuffer, - index_count: uint32_t, - instance_count: uint32_t, - first_index: uint32_t, - vertex_offset: int32_t, - first_instance: uint32_t, + index_count: u32, + instance_count: u32, + first_index: u32, + vertex_offset: i32, + first_instance: u32, ) -> c_void, cmd_draw_indirect: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, + draw_count: u32, + stride: u32, ) -> c_void, cmd_draw_indexed_indirect: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, + draw_count: u32, + stride: u32, ) -> c_void, cmd_dispatch: extern "system" fn( command_buffer: CommandBuffer, - group_count_x: uint32_t, - group_count_y: uint32_t, - group_count_z: uint32_t, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, ) -> c_void, cmd_dispatch_indirect: extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize) @@ -1238,7 +1238,7 @@ pub struct DeviceFnV1_0 { command_buffer: CommandBuffer, src_buffer: Buffer, dst_buffer: Buffer, - region_count: uint32_t, + region_count: u32, p_regions: *const BufferCopy, ) -> c_void, cmd_copy_image: extern "system" fn( @@ -1247,7 +1247,7 @@ pub struct DeviceFnV1_0 { src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const ImageCopy, ) -> c_void, cmd_blit_image: extern "system" fn( @@ -1256,7 +1256,7 @@ pub struct DeviceFnV1_0 { src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const ImageBlit, filter: Filter, ) -> c_void, @@ -1265,7 +1265,7 @@ pub struct DeviceFnV1_0 { src_buffer: Buffer, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void, cmd_copy_image_to_buffer: extern "system" fn( @@ -1273,7 +1273,7 @@ pub struct DeviceFnV1_0 { src_image: Image, src_image_layout: ImageLayout, dst_buffer: Buffer, - region_count: uint32_t, + region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void, cmd_update_buffer: extern "system" fn( @@ -1288,14 +1288,14 @@ pub struct DeviceFnV1_0 { dst_buffer: Buffer, dst_offset: DeviceSize, size: DeviceSize, - data: uint32_t, + data: u32, ) -> c_void, cmd_clear_color_image: extern "system" fn( command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_color: *const ClearColorValue, - range_count: uint32_t, + range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void, cmd_clear_depth_stencil_image: @@ -1304,14 +1304,14 @@ pub struct DeviceFnV1_0 { image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, - range_count: uint32_t, + range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void, cmd_clear_attachments: extern "system" fn( command_buffer: CommandBuffer, - attachment_count: uint32_t, + attachment_count: u32, p_attachments: *const ClearAttachment, - rect_count: uint32_t, + rect_count: u32, p_rects: *const ClearRect, ) -> c_void, cmd_resolve_image: extern "system" fn( @@ -1320,7 +1320,7 @@ pub struct DeviceFnV1_0 { src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const ImageResolve, ) -> c_void, cmd_set_event: extern "system" fn( @@ -1335,15 +1335,15 @@ pub struct DeviceFnV1_0 { ) -> c_void, cmd_wait_events: extern "system" fn( command_buffer: CommandBuffer, - event_count: uint32_t, + event_count: u32, p_events: *const Event, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, - memory_barrier_count: uint32_t, + memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, + buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, + image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void, cmd_pipeline_barrier: extern "system" fn( @@ -1351,39 +1351,39 @@ pub struct DeviceFnV1_0 { src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, dependency_flags: DependencyFlags, - memory_barrier_count: uint32_t, + memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, + buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, + image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void, cmd_begin_query: extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, - query: uint32_t, + query: u32, flags: QueryControlFlags, ) -> c_void, cmd_end_query: - extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: uint32_t) + extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32) -> c_void, cmd_reset_query_pool: extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, + first_query: u32, + query_count: u32, ) -> c_void, cmd_write_timestamp: extern "system" fn( command_buffer: CommandBuffer, pipeline_stage: PipelineStageFlags, query_pool: QueryPool, - query: uint32_t, + query: u32, ) -> c_void, cmd_copy_query_pool_results: extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, + first_query: u32, + query_count: u32, dst_buffer: Buffer, dst_offset: DeviceSize, stride: DeviceSize, @@ -1393,8 +1393,8 @@ pub struct DeviceFnV1_0 { command_buffer: CommandBuffer, layout: PipelineLayout, stage_flags: ShaderStageFlags, - offset: uint32_t, - size: uint32_t, + offset: u32, + size: u32, p_values: *const c_void, ) -> c_void, cmd_begin_render_pass: extern "system" fn( @@ -1407,7 +1407,7 @@ pub struct DeviceFnV1_0 { cmd_end_render_pass: extern "system" fn(command_buffer: CommandBuffer) -> c_void, cmd_execute_commands: extern "system" fn( command_buffer: CommandBuffer, - command_buffer_count: uint32_t, + command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void, } @@ -2643,8 +2643,8 @@ impl DeviceFnV1_0 { pub unsafe fn get_device_queue( &self, device: Device, - queue_family_index: uint32_t, - queue_index: uint32_t, + queue_family_index: u32, + queue_index: u32, p_queue: *mut Queue, ) -> c_void { (self.get_device_queue)(device, queue_family_index, queue_index, p_queue) @@ -2652,7 +2652,7 @@ impl DeviceFnV1_0 { pub unsafe fn queue_submit( &self, queue: Queue, - submit_count: uint32_t, + submit_count: u32, p_submits: *const SubmitInfo, fence: Fence, ) -> Result { @@ -2698,7 +2698,7 @@ impl DeviceFnV1_0 { pub unsafe fn flush_mapped_memory_ranges( &self, device: Device, - memory_range_count: uint32_t, + memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result { (self.flush_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) @@ -2706,7 +2706,7 @@ impl DeviceFnV1_0 { pub unsafe fn invalidate_mapped_memory_ranges( &self, device: Device, - memory_range_count: uint32_t, + memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result { (self.invalidate_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) @@ -2757,7 +2757,7 @@ impl DeviceFnV1_0 { &self, device: Device, image: Image, - p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void { (self.get_image_sparse_memory_requirements)( @@ -2770,7 +2770,7 @@ impl DeviceFnV1_0 { pub unsafe fn queue_bind_sparse( &self, queue: Queue, - bind_info_count: uint32_t, + bind_info_count: u32, p_bind_info: *const BindSparseInfo, fence: Fence, ) -> Result { @@ -2796,7 +2796,7 @@ impl DeviceFnV1_0 { pub unsafe fn reset_fences( &self, device: Device, - fence_count: uint32_t, + fence_count: u32, p_fences: *const Fence, ) -> Result { (self.reset_fences)(device, fence_count, p_fences) @@ -2807,10 +2807,10 @@ impl DeviceFnV1_0 { pub unsafe fn wait_for_fences( &self, device: Device, - fence_count: uint32_t, + fence_count: u32, p_fences: *const Fence, wait_all: Bool32, - timeout: uint64_t, + timeout: u64, ) -> Result { (self.wait_for_fences)(device, fence_count, p_fences, wait_all, timeout) } @@ -2878,9 +2878,9 @@ impl DeviceFnV1_0 { &self, device: Device, query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, - data_size: size_t, + first_query: u32, + query_count: u32, + data_size: usize, p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, @@ -3011,7 +3011,7 @@ impl DeviceFnV1_0 { &self, device: Device, pipeline_cache: PipelineCache, - p_data_size: *mut size_t, + p_data_size: *mut usize, p_data: *mut c_void, ) -> Result { (self.get_pipeline_cache_data)(device, pipeline_cache, p_data_size, p_data) @@ -3020,7 +3020,7 @@ impl DeviceFnV1_0 { &self, device: Device, dst_cache: PipelineCache, - src_cache_count: uint32_t, + src_cache_count: u32, p_src_caches: *const PipelineCache, ) -> Result { (self.merge_pipeline_caches)(device, dst_cache, src_cache_count, p_src_caches) @@ -3029,7 +3029,7 @@ impl DeviceFnV1_0 { &self, device: Device, pipeline_cache: PipelineCache, - create_info_count: uint32_t, + create_info_count: u32, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, @@ -3047,7 +3047,7 @@ impl DeviceFnV1_0 { &self, device: Device, pipeline_cache: PipelineCache, - create_info_count: uint32_t, + create_info_count: u32, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, @@ -3157,7 +3157,7 @@ impl DeviceFnV1_0 { &self, device: Device, descriptor_pool: DescriptorPool, - descriptor_set_count: uint32_t, + descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, ) -> Result { (self.free_descriptor_sets)( @@ -3170,9 +3170,9 @@ impl DeviceFnV1_0 { pub unsafe fn update_descriptor_sets( &self, device: Device, - descriptor_write_count: uint32_t, + descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, - descriptor_copy_count: uint32_t, + descriptor_copy_count: u32, p_descriptor_copies: *const CopyDescriptorSet, ) -> c_void { (self.update_descriptor_sets)( @@ -3262,7 +3262,7 @@ impl DeviceFnV1_0 { &self, device: Device, command_pool: CommandPool, - command_buffer_count: uint32_t, + command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void { (self.free_command_buffers)( @@ -3300,8 +3300,8 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_set_viewport( &self, command_buffer: CommandBuffer, - first_viewport: uint32_t, - viewport_count: uint32_t, + first_viewport: u32, + viewport_count: u32, p_viewports: *const Viewport, ) -> c_void { (self.cmd_set_viewport)(command_buffer, first_viewport, viewport_count, p_viewports) @@ -3309,8 +3309,8 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_set_scissor( &self, command_buffer: CommandBuffer, - first_scissor: uint32_t, - scissor_count: uint32_t, + first_scissor: u32, + scissor_count: u32, p_scissors: *const Rect2D, ) -> c_void { (self.cmd_set_scissor)(command_buffer, first_scissor, scissor_count, p_scissors) @@ -3355,7 +3355,7 @@ impl DeviceFnV1_0 { &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, - compare_mask: uint32_t, + compare_mask: u32, ) -> c_void { (self.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask) } @@ -3363,7 +3363,7 @@ impl DeviceFnV1_0 { &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, - write_mask: uint32_t, + write_mask: u32, ) -> c_void { (self.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask) } @@ -3371,7 +3371,7 @@ impl DeviceFnV1_0 { &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, - reference: uint32_t, + reference: u32, ) -> c_void { (self.cmd_set_stencil_reference)(command_buffer, face_mask, reference) } @@ -3380,11 +3380,11 @@ impl DeviceFnV1_0 { command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, - first_set: uint32_t, - descriptor_set_count: uint32_t, + first_set: u32, + descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, - dynamic_offset_count: uint32_t, - p_dynamic_offsets: *const uint32_t, + dynamic_offset_count: u32, + p_dynamic_offsets: *const u32, ) -> c_void { (self.cmd_bind_descriptor_sets)( command_buffer, @@ -3409,8 +3409,8 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_bind_vertex_buffers( &self, command_buffer: CommandBuffer, - first_binding: uint32_t, - binding_count: uint32_t, + first_binding: u32, + binding_count: u32, p_buffers: *const Buffer, p_offsets: *const DeviceSize, ) -> c_void { @@ -3425,10 +3425,10 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_draw( &self, command_buffer: CommandBuffer, - vertex_count: uint32_t, - instance_count: uint32_t, - first_vertex: uint32_t, - first_instance: uint32_t, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, ) -> c_void { (self.cmd_draw)( command_buffer, @@ -3441,11 +3441,11 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_draw_indexed( &self, command_buffer: CommandBuffer, - index_count: uint32_t, - instance_count: uint32_t, - first_index: uint32_t, - vertex_offset: int32_t, - first_instance: uint32_t, + index_count: u32, + instance_count: u32, + first_index: u32, + vertex_offset: i32, + first_instance: u32, ) -> c_void { (self.cmd_draw_indexed)( command_buffer, @@ -3461,8 +3461,8 @@ impl DeviceFnV1_0 { command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, + draw_count: u32, + stride: u32, ) -> c_void { (self.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride) } @@ -3471,17 +3471,17 @@ impl DeviceFnV1_0 { command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, - draw_count: uint32_t, - stride: uint32_t, + draw_count: u32, + stride: u32, ) -> c_void { (self.cmd_draw_indexed_indirect)(command_buffer, buffer, offset, draw_count, stride) } pub unsafe fn cmd_dispatch( &self, command_buffer: CommandBuffer, - group_count_x: uint32_t, - group_count_y: uint32_t, - group_count_z: uint32_t, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, ) -> c_void { (self.cmd_dispatch)(command_buffer, group_count_x, group_count_y, group_count_z) } @@ -3498,7 +3498,7 @@ impl DeviceFnV1_0 { command_buffer: CommandBuffer, src_buffer: Buffer, dst_buffer: Buffer, - region_count: uint32_t, + region_count: u32, p_regions: *const BufferCopy, ) -> c_void { (self.cmd_copy_buffer)( @@ -3516,7 +3516,7 @@ impl DeviceFnV1_0 { src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const ImageCopy, ) -> c_void { (self.cmd_copy_image)( @@ -3536,7 +3536,7 @@ impl DeviceFnV1_0 { src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const ImageBlit, filter: Filter, ) -> c_void { @@ -3557,7 +3557,7 @@ impl DeviceFnV1_0 { src_buffer: Buffer, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void { (self.cmd_copy_buffer_to_image)( @@ -3575,7 +3575,7 @@ impl DeviceFnV1_0 { src_image: Image, src_image_layout: ImageLayout, dst_buffer: Buffer, - region_count: uint32_t, + region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void { (self.cmd_copy_image_to_buffer)( @@ -3603,7 +3603,7 @@ impl DeviceFnV1_0 { dst_buffer: Buffer, dst_offset: DeviceSize, size: DeviceSize, - data: uint32_t, + data: u32, ) -> c_void { (self.cmd_fill_buffer)(command_buffer, dst_buffer, dst_offset, size, data) } @@ -3613,7 +3613,7 @@ impl DeviceFnV1_0 { image: Image, image_layout: ImageLayout, p_color: *const ClearColorValue, - range_count: uint32_t, + range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void { (self.cmd_clear_color_image)( @@ -3631,7 +3631,7 @@ impl DeviceFnV1_0 { image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, - range_count: uint32_t, + range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void { (self.cmd_clear_depth_stencil_image)( @@ -3646,9 +3646,9 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_clear_attachments( &self, command_buffer: CommandBuffer, - attachment_count: uint32_t, + attachment_count: u32, p_attachments: *const ClearAttachment, - rect_count: uint32_t, + rect_count: u32, p_rects: *const ClearRect, ) -> c_void { (self.cmd_clear_attachments)( @@ -3666,7 +3666,7 @@ impl DeviceFnV1_0 { src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, - region_count: uint32_t, + region_count: u32, p_regions: *const ImageResolve, ) -> c_void { (self.cmd_resolve_image)( @@ -3698,15 +3698,15 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_wait_events( &self, command_buffer: CommandBuffer, - event_count: uint32_t, + event_count: u32, p_events: *const Event, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, - memory_barrier_count: uint32_t, + memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, + buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, + image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { (self.cmd_wait_events)( @@ -3729,11 +3729,11 @@ impl DeviceFnV1_0 { src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, dependency_flags: DependencyFlags, - memory_barrier_count: uint32_t, + memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, - buffer_memory_barrier_count: uint32_t, + buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, - image_memory_barrier_count: uint32_t, + image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { (self.cmd_pipeline_barrier)( @@ -3753,7 +3753,7 @@ impl DeviceFnV1_0 { &self, command_buffer: CommandBuffer, query_pool: QueryPool, - query: uint32_t, + query: u32, flags: QueryControlFlags, ) -> c_void { (self.cmd_begin_query)(command_buffer, query_pool, query, flags) @@ -3762,7 +3762,7 @@ impl DeviceFnV1_0 { &self, command_buffer: CommandBuffer, query_pool: QueryPool, - query: uint32_t, + query: u32, ) -> c_void { (self.cmd_end_query)(command_buffer, query_pool, query) } @@ -3770,8 +3770,8 @@ impl DeviceFnV1_0 { &self, command_buffer: CommandBuffer, query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, + first_query: u32, + query_count: u32, ) -> c_void { (self.cmd_reset_query_pool)(command_buffer, query_pool, first_query, query_count) } @@ -3780,7 +3780,7 @@ impl DeviceFnV1_0 { command_buffer: CommandBuffer, pipeline_stage: PipelineStageFlags, query_pool: QueryPool, - query: uint32_t, + query: u32, ) -> c_void { (self.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query) } @@ -3788,8 +3788,8 @@ impl DeviceFnV1_0 { &self, command_buffer: CommandBuffer, query_pool: QueryPool, - first_query: uint32_t, - query_count: uint32_t, + first_query: u32, + query_count: u32, dst_buffer: Buffer, dst_offset: DeviceSize, stride: DeviceSize, @@ -3811,8 +3811,8 @@ impl DeviceFnV1_0 { command_buffer: CommandBuffer, layout: PipelineLayout, stage_flags: ShaderStageFlags, - offset: uint32_t, - size: uint32_t, + offset: u32, + size: u32, p_values: *const c_void, ) -> c_void { (self.cmd_push_constants)(command_buffer, layout, stage_flags, offset, size, p_values) @@ -3838,14 +3838,14 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_execute_commands( &self, command_buffer: CommandBuffer, - command_buffer_count: uint32_t, + command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void { (self.cmd_execute_commands)(command_buffer, command_buffer_count, p_command_buffers) } } pub struct EntryFnV1_1 { - enumerate_instance_version: extern "system" fn(p_api_version: *mut uint32_t) -> Result, + enumerate_instance_version: extern "system" fn(p_api_version: *mut u32) -> Result, } unsafe impl Send for EntryFnV1_1 {} unsafe impl Sync for EntryFnV1_1 {} @@ -3879,7 +3879,7 @@ impl EntryFnV1_1 { Err(_err_str) } } - pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut uint32_t) -> Result { + pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut u32) -> Result { (self.enumerate_instance_version)(p_api_version) } } @@ -3887,7 +3887,7 @@ pub struct InstanceFnV1_1 { enumerate_physical_device_groups: extern "system" fn( instance: Instance, - p_physical_device_group_count: *mut uint32_t, + p_physical_device_group_count: *mut u32, p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result, get_physical_device_features2: extern "system" fn( @@ -3914,7 +3914,7 @@ pub struct InstanceFnV1_1 { get_physical_device_queue_family_properties2: extern "system" fn( physical_device: PhysicalDevice, - p_queue_family_property_count: *mut uint32_t, + p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties2, ) -> c_void, get_physical_device_memory_properties2: @@ -3926,7 +3926,7 @@ pub struct InstanceFnV1_1 { extern "system" fn( physical_device: PhysicalDevice, p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties2, ) -> c_void, get_physical_device_external_buffer_properties: @@ -4089,7 +4089,7 @@ impl InstanceFnV1_1 { pub unsafe fn enumerate_physical_device_groups( &self, instance: Instance, - p_physical_device_group_count: *mut uint32_t, + p_physical_device_group_count: *mut u32, p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result { (self.enumerate_physical_device_groups)( @@ -4135,7 +4135,7 @@ impl InstanceFnV1_1 { pub unsafe fn get_physical_device_queue_family_properties2( &self, physical_device: PhysicalDevice, - p_queue_family_property_count: *mut uint32_t, + p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties2, ) -> c_void { (self.get_physical_device_queue_family_properties2)( @@ -4155,7 +4155,7 @@ impl InstanceFnV1_1 { &self, physical_device: PhysicalDevice, p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties2, ) -> c_void { (self.get_physical_device_sparse_image_format_properties2)( @@ -4205,32 +4205,32 @@ impl InstanceFnV1_1 { pub struct DeviceFnV1_1 { bind_buffer_memory2: extern "system" fn( device: Device, - bind_info_count: uint32_t, + bind_info_count: u32, p_bind_infos: *const BindBufferMemoryInfo, ) -> Result, bind_image_memory2: extern "system" fn( device: Device, - bind_info_count: uint32_t, + bind_info_count: u32, p_bind_infos: *const BindImageMemoryInfo, ) -> Result, get_device_group_peer_memory_features: extern "system" fn( device: Device, - heap_index: uint32_t, - local_device_index: uint32_t, - remote_device_index: uint32_t, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void, cmd_set_device_mask: - extern "system" fn(command_buffer: CommandBuffer, device_mask: uint32_t) -> c_void, + extern "system" fn(command_buffer: CommandBuffer, device_mask: u32) -> c_void, cmd_dispatch_base: extern "system" fn( command_buffer: CommandBuffer, - base_group_x: uint32_t, - base_group_y: uint32_t, - base_group_z: uint32_t, - group_count_x: uint32_t, - group_count_y: uint32_t, - group_count_z: uint32_t, + base_group_x: u32, + base_group_y: u32, + base_group_z: u32, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, ) -> c_void, get_image_memory_requirements2: extern "system" fn( @@ -4248,7 +4248,7 @@ pub struct DeviceFnV1_1 { extern "system" fn( device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, - p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void, trim_command_pool: @@ -4483,7 +4483,7 @@ impl DeviceFnV1_1 { pub unsafe fn bind_buffer_memory2( &self, device: Device, - bind_info_count: uint32_t, + bind_info_count: u32, p_bind_infos: *const BindBufferMemoryInfo, ) -> Result { (self.bind_buffer_memory2)(device, bind_info_count, p_bind_infos) @@ -4491,7 +4491,7 @@ impl DeviceFnV1_1 { pub unsafe fn bind_image_memory2( &self, device: Device, - bind_info_count: uint32_t, + bind_info_count: u32, p_bind_infos: *const BindImageMemoryInfo, ) -> Result { (self.bind_image_memory2)(device, bind_info_count, p_bind_infos) @@ -4499,9 +4499,9 @@ impl DeviceFnV1_1 { pub unsafe fn get_device_group_peer_memory_features( &self, device: Device, - heap_index: uint32_t, - local_device_index: uint32_t, - remote_device_index: uint32_t, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void { (self.get_device_group_peer_memory_features)( @@ -4515,19 +4515,19 @@ impl DeviceFnV1_1 { pub unsafe fn cmd_set_device_mask( &self, command_buffer: CommandBuffer, - device_mask: uint32_t, + device_mask: u32, ) -> c_void { (self.cmd_set_device_mask)(command_buffer, device_mask) } pub unsafe fn cmd_dispatch_base( &self, command_buffer: CommandBuffer, - base_group_x: uint32_t, - base_group_y: uint32_t, - base_group_z: uint32_t, - group_count_x: uint32_t, - group_count_y: uint32_t, - group_count_z: uint32_t, + base_group_x: u32, + base_group_y: u32, + base_group_z: u32, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, ) -> c_void { (self.cmd_dispatch_base)( command_buffer, @@ -4559,7 +4559,7 @@ impl DeviceFnV1_1 { &self, device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, - p_sparse_memory_requirement_count: *mut uint32_t, + p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void { (self.get_image_sparse_memory_requirements2)( @@ -4652,10 +4652,10 @@ impl DeviceFnV1_1 { (self.get_descriptor_set_layout_support)(device, p_create_info, p_support) } } -pub type SampleMask = uint32_t; -pub type Bool32 = uint32_t; -pub type Flags = uint32_t; -pub type DeviceSize = uint64_t; +pub type SampleMask = u32; +pub type Bool32 = u32; +pub type Flags = u32; +pub type DeviceSize = u64; #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct FramebufferCreateFlags(Flags); @@ -4884,7 +4884,7 @@ handle_nondispatchable!(DebugUtilsMessengerEXT, DEBUG_UTILS_MESSENGER_EXT); pub type PFN_vkInternalAllocationNotification = unsafe extern "system" fn( p_user_data: *mut c_void, - size: size_t, + size: usize, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationScope, ) -> c_void; @@ -4892,7 +4892,7 @@ pub type PFN_vkInternalAllocationNotification = pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn( p_user_data: *mut c_void, - size: size_t, + size: usize, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationScope, ) -> c_void; @@ -4901,16 +4901,16 @@ pub type PFN_vkReallocationFunction = unsafe extern "system" fn( p_user_data: *mut c_void, p_original: *mut c_void, - size: size_t, - alignment: size_t, + size: usize, + alignment: usize, allocation_scope: SystemAllocationScope, ) -> *mut c_void; #[allow(non_camel_case_types)] pub type PFN_vkAllocationFunction = unsafe extern "system" fn( p_user_data: *mut c_void, - size: size_t, - alignment: size_t, + size: usize, + alignment: usize, allocation_scope: SystemAllocationScope, ) -> *mut c_void; #[allow(non_camel_case_types)] @@ -4923,9 +4923,9 @@ pub type PFN_vkDebugReportCallbackEXT = unsafe extern "system" fn( flags: DebugReportFlagsEXT, object_type: DebugReportObjectTypeEXT, - object: uint64_t, - location: size_t, - message_code: int32_t, + object: u64, + location: usize, + message_code: i32, p_layer_prefix: *const c_char, p_message: *const c_char, p_user_data: *mut c_void, @@ -4969,28 +4969,28 @@ impl ::std::default::Default for BaseInStructure { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Offset2D { - pub x: int32_t, - pub y: int32_t, + pub x: i32, + pub y: i32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Offset3D { - pub x: int32_t, - pub y: int32_t, - pub z: int32_t, + pub x: i32, + pub y: i32, + pub z: i32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Extent2D { - pub width: uint32_t, - pub height: uint32_t, + pub width: u32, + pub height: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)] pub struct Extent3D { - pub width: uint32_t, - pub height: uint32_t, - pub depth: uint32_t, + pub width: u32, + pub height: u32, + pub depth: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] @@ -5012,8 +5012,8 @@ pub struct Rect2D { #[derive(Copy, Clone, Default, Debug)] pub struct ClearRect { pub rect: Rect2D, - pub base_array_layer: uint32_t, - pub layer_count: uint32_t, + pub base_array_layer: u32, + pub layer_count: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] @@ -5026,13 +5026,13 @@ pub struct ComponentMapping { #[repr(C)] #[derive(Copy, Clone)] pub struct PhysicalDeviceProperties { - pub api_version: uint32_t, - pub driver_version: uint32_t, - pub vendor_id: uint32_t, - pub device_id: uint32_t, + pub api_version: u32, + pub driver_version: u32, + pub vendor_id: u32, + pub device_id: u32, pub device_type: PhysicalDeviceType, pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE], - pub pipeline_cache_uuid: [uint8_t; UUID_SIZE], + pub pipeline_cache_uuid: [u8; UUID_SIZE], pub limits: PhysicalDeviceLimits, pub sparse_properties: PhysicalDeviceSparseProperties, } @@ -5058,10 +5058,10 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { impl ::std::default::Default for PhysicalDeviceProperties { fn default() -> PhysicalDeviceProperties { PhysicalDeviceProperties { - api_version: uint32_t::default(), - driver_version: uint32_t::default(), - vendor_id: uint32_t::default(), - device_id: uint32_t::default(), + api_version: u32::default(), + driver_version: u32::default(), + vendor_id: u32::default(), + device_id: u32::default(), device_type: PhysicalDeviceType::default(), device_name: unsafe { ::std::mem::zeroed() }, pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, @@ -5074,7 +5074,7 @@ impl ::std::default::Default for PhysicalDeviceProperties { #[derive(Copy, Clone)] pub struct ExtensionProperties { pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], - pub spec_version: uint32_t, + pub spec_version: u32, } impl ::std::fmt::Debug for ExtensionProperties { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { @@ -5090,7 +5090,7 @@ impl ::std::default::Default for ExtensionProperties { fn default() -> ExtensionProperties { ExtensionProperties { extension_name: unsafe { ::std::mem::zeroed() }, - spec_version: uint32_t::default(), + spec_version: u32::default(), } } } @@ -5098,8 +5098,8 @@ impl ::std::default::Default for ExtensionProperties { #[derive(Copy, Clone)] pub struct LayerProperties { pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE], - pub spec_version: uint32_t, - pub implementation_version: uint32_t, + pub spec_version: u32, + pub implementation_version: u32, pub description: [c_char; MAX_DESCRIPTION_SIZE], } impl ::std::fmt::Debug for LayerProperties { @@ -5120,8 +5120,8 @@ impl ::std::default::Default for LayerProperties { fn default() -> LayerProperties { LayerProperties { layer_name: unsafe { ::std::mem::zeroed() }, - spec_version: uint32_t::default(), - implementation_version: uint32_t::default(), + spec_version: u32::default(), + implementation_version: u32::default(), description: unsafe { ::std::mem::zeroed() }, } } @@ -5132,10 +5132,10 @@ pub struct ApplicationInfo { pub s_type: StructureType, pub p_next: *const c_void, pub p_application_name: *const c_char, - pub application_version: uint32_t, + pub application_version: u32, pub p_engine_name: *const c_char, - pub engine_version: uint32_t, - pub api_version: uint32_t, + pub engine_version: u32, + pub api_version: u32, } impl ::std::default::Default for ApplicationInfo { fn default() -> ApplicationInfo { @@ -5143,10 +5143,10 @@ impl ::std::default::Default for ApplicationInfo { s_type: StructureType::APPLICATION_INFO, p_next: ::std::ptr::null(), p_application_name: ::std::ptr::null(), - application_version: uint32_t::default(), + application_version: u32::default(), p_engine_name: ::std::ptr::null(), - engine_version: uint32_t::default(), - api_version: uint32_t::default(), + engine_version: u32::default(), + api_version: u32::default(), } } } @@ -5193,8 +5193,8 @@ pub struct DeviceQueueCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceQueueCreateFlags, - pub queue_family_index: uint32_t, - pub queue_count: uint32_t, + pub queue_family_index: u32, + pub queue_count: u32, pub p_queue_priorities: *const c_float, } impl ::std::default::Default for DeviceQueueCreateInfo { @@ -5203,8 +5203,8 @@ impl ::std::default::Default for DeviceQueueCreateInfo { s_type: StructureType::DEVICE_QUEUE_CREATE_INFO, p_next: ::std::ptr::null(), flags: DeviceQueueCreateFlags::default(), - queue_family_index: uint32_t::default(), - queue_count: uint32_t::default(), + queue_family_index: u32::default(), + queue_count: u32::default(), p_queue_priorities: ::std::ptr::null(), } } @@ -5215,11 +5215,11 @@ pub struct DeviceCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceCreateFlags, - pub queue_create_info_count: uint32_t, + pub queue_create_info_count: u32, pub p_queue_create_infos: *const DeviceQueueCreateInfo, - pub enabled_layer_count: uint32_t, + pub enabled_layer_count: u32, pub pp_enabled_layer_names: *const *const c_char, - pub enabled_extension_count: uint32_t, + pub enabled_extension_count: u32, pub pp_enabled_extension_names: *const *const c_char, pub p_enabled_features: *const PhysicalDeviceFeatures, } @@ -5229,11 +5229,11 @@ impl ::std::default::Default for DeviceCreateInfo { s_type: StructureType::DEVICE_CREATE_INFO, p_next: ::std::ptr::null(), flags: DeviceCreateFlags::default(), - queue_create_info_count: uint32_t::default(), + queue_create_info_count: u32::default(), p_queue_create_infos: ::std::ptr::null(), - enabled_layer_count: uint32_t::default(), + enabled_layer_count: u32::default(), pp_enabled_layer_names: ::std::ptr::null(), - enabled_extension_count: uint32_t::default(), + enabled_extension_count: u32::default(), pp_enabled_extension_names: ::std::ptr::null(), p_enabled_features: ::std::ptr::null(), } @@ -5246,9 +5246,9 @@ pub struct InstanceCreateInfo { pub p_next: *const c_void, pub flags: InstanceCreateFlags, pub p_application_info: *const ApplicationInfo, - pub enabled_layer_count: uint32_t, + pub enabled_layer_count: u32, pub pp_enabled_layer_names: *const *const c_char, - pub enabled_extension_count: uint32_t, + pub enabled_extension_count: u32, pub pp_enabled_extension_names: *const *const c_char, } impl ::std::default::Default for InstanceCreateInfo { @@ -5258,9 +5258,9 @@ impl ::std::default::Default for InstanceCreateInfo { p_next: ::std::ptr::null(), flags: InstanceCreateFlags::default(), p_application_info: ::std::ptr::null(), - enabled_layer_count: uint32_t::default(), + enabled_layer_count: u32::default(), pp_enabled_layer_names: ::std::ptr::null(), - enabled_extension_count: uint32_t::default(), + enabled_extension_count: u32::default(), pp_enabled_extension_names: ::std::ptr::null(), } } @@ -5269,16 +5269,16 @@ impl ::std::default::Default for InstanceCreateInfo { #[derive(Copy, Clone, Default, Debug)] pub struct QueueFamilyProperties { pub queue_flags: QueueFlags, - pub queue_count: uint32_t, - pub timestamp_valid_bits: uint32_t, + pub queue_count: u32, + pub timestamp_valid_bits: u32, pub min_image_transfer_granularity: Extent3D, } #[repr(C)] #[derive(Copy, Clone)] pub struct PhysicalDeviceMemoryProperties { - pub memory_type_count: uint32_t, + pub memory_type_count: u32, pub memory_types: [MemoryType; MAX_MEMORY_TYPES], - pub memory_heap_count: uint32_t, + pub memory_heap_count: u32, pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], } impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { @@ -5298,9 +5298,9 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { impl ::std::default::Default for PhysicalDeviceMemoryProperties { fn default() -> PhysicalDeviceMemoryProperties { PhysicalDeviceMemoryProperties { - memory_type_count: uint32_t::default(), + memory_type_count: u32::default(), memory_types: unsafe { ::std::mem::zeroed() }, - memory_heap_count: uint32_t::default(), + memory_heap_count: u32::default(), memory_heaps: unsafe { ::std::mem::zeroed() }, } } @@ -5311,7 +5311,7 @@ pub struct MemoryAllocateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub allocation_size: DeviceSize, - pub memory_type_index: uint32_t, + pub memory_type_index: u32, } impl ::std::default::Default for MemoryAllocateInfo { fn default() -> MemoryAllocateInfo { @@ -5319,7 +5319,7 @@ impl ::std::default::Default for MemoryAllocateInfo { s_type: StructureType::MEMORY_ALLOCATE_INFO, p_next: ::std::ptr::null(), allocation_size: DeviceSize::default(), - memory_type_index: uint32_t::default(), + memory_type_index: u32::default(), } } } @@ -5328,7 +5328,7 @@ impl ::std::default::Default for MemoryAllocateInfo { pub struct MemoryRequirements { pub size: DeviceSize, pub alignment: DeviceSize, - pub memory_type_bits: uint32_t, + pub memory_type_bits: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] @@ -5341,7 +5341,7 @@ pub struct SparseImageFormatProperties { #[derive(Copy, Clone, Default, Debug)] pub struct SparseImageMemoryRequirements { pub format_properties: SparseImageFormatProperties, - pub image_mip_tail_first_lod: uint32_t, + pub image_mip_tail_first_lod: u32, pub image_mip_tail_size: DeviceSize, pub image_mip_tail_offset: DeviceSize, pub image_mip_tail_stride: DeviceSize, @@ -5350,7 +5350,7 @@ pub struct SparseImageMemoryRequirements { #[derive(Copy, Clone, Default, Debug)] pub struct MemoryType { pub property_flags: MemoryPropertyFlags, - pub heap_index: uint32_t, + pub heap_index: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] @@ -5389,8 +5389,8 @@ pub struct FormatProperties { #[derive(Copy, Clone, Default, Debug)] pub struct ImageFormatProperties { pub max_extent: Extent3D, - pub max_mip_levels: uint32_t, - pub max_array_layers: uint32_t, + pub max_mip_levels: u32, + pub max_array_layers: u32, pub sample_counts: SampleCountFlags, pub max_resource_size: DeviceSize, } @@ -5414,9 +5414,9 @@ pub struct WriteDescriptorSet { pub s_type: StructureType, pub p_next: *const c_void, pub dst_set: DescriptorSet, - pub dst_binding: uint32_t, - pub dst_array_element: uint32_t, - pub descriptor_count: uint32_t, + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, pub descriptor_type: DescriptorType, pub p_image_info: *const DescriptorImageInfo, pub p_buffer_info: *const DescriptorBufferInfo, @@ -5428,9 +5428,9 @@ impl ::std::default::Default for WriteDescriptorSet { s_type: StructureType::WRITE_DESCRIPTOR_SET, p_next: ::std::ptr::null(), dst_set: DescriptorSet::default(), - dst_binding: uint32_t::default(), - dst_array_element: uint32_t::default(), - descriptor_count: uint32_t::default(), + dst_binding: u32::default(), + dst_array_element: u32::default(), + descriptor_count: u32::default(), descriptor_type: DescriptorType::default(), p_image_info: ::std::ptr::null(), p_buffer_info: ::std::ptr::null(), @@ -5444,12 +5444,12 @@ pub struct CopyDescriptorSet { pub s_type: StructureType, pub p_next: *const c_void, pub src_set: DescriptorSet, - pub src_binding: uint32_t, - pub src_array_element: uint32_t, + pub src_binding: u32, + pub src_array_element: u32, pub dst_set: DescriptorSet, - pub dst_binding: uint32_t, - pub dst_array_element: uint32_t, - pub descriptor_count: uint32_t, + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, } impl ::std::default::Default for CopyDescriptorSet { fn default() -> CopyDescriptorSet { @@ -5457,12 +5457,12 @@ impl ::std::default::Default for CopyDescriptorSet { s_type: StructureType::COPY_DESCRIPTOR_SET, p_next: ::std::ptr::null(), src_set: DescriptorSet::default(), - src_binding: uint32_t::default(), - src_array_element: uint32_t::default(), + src_binding: u32::default(), + src_array_element: u32::default(), dst_set: DescriptorSet::default(), - dst_binding: uint32_t::default(), - dst_array_element: uint32_t::default(), - descriptor_count: uint32_t::default(), + dst_binding: u32::default(), + dst_array_element: u32::default(), + descriptor_count: u32::default(), } } } @@ -5475,8 +5475,8 @@ pub struct BufferCreateInfo { pub size: DeviceSize, pub usage: BufferUsageFlags, pub sharing_mode: SharingMode, - pub queue_family_index_count: uint32_t, - pub p_queue_family_indices: *const uint32_t, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, } impl ::std::default::Default for BufferCreateInfo { fn default() -> BufferCreateInfo { @@ -5487,7 +5487,7 @@ impl ::std::default::Default for BufferCreateInfo { size: DeviceSize::default(), usage: BufferUsageFlags::default(), sharing_mode: SharingMode::default(), - queue_family_index_count: uint32_t::default(), + queue_family_index_count: u32::default(), p_queue_family_indices: ::std::ptr::null(), } } @@ -5520,25 +5520,25 @@ impl ::std::default::Default for BufferViewCreateInfo { #[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresource { pub aspect_mask: ImageAspectFlags, - pub mip_level: uint32_t, - pub array_layer: uint32_t, + pub mip_level: u32, + pub array_layer: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresourceLayers { pub aspect_mask: ImageAspectFlags, - pub mip_level: uint32_t, - pub base_array_layer: uint32_t, - pub layer_count: uint32_t, + pub mip_level: u32, + pub base_array_layer: u32, + pub layer_count: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresourceRange { pub aspect_mask: ImageAspectFlags, - pub base_mip_level: uint32_t, - pub level_count: uint32_t, - pub base_array_layer: uint32_t, - pub layer_count: uint32_t, + pub base_mip_level: u32, + pub level_count: u32, + pub base_array_layer: u32, + pub layer_count: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -5565,8 +5565,8 @@ pub struct BufferMemoryBarrier { pub p_next: *const c_void, pub src_access_mask: AccessFlags, pub dst_access_mask: AccessFlags, - pub src_queue_family_index: uint32_t, - pub dst_queue_family_index: uint32_t, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, pub buffer: Buffer, pub offset: DeviceSize, pub size: DeviceSize, @@ -5578,8 +5578,8 @@ impl ::std::default::Default for BufferMemoryBarrier { p_next: ::std::ptr::null(), src_access_mask: AccessFlags::default(), dst_access_mask: AccessFlags::default(), - src_queue_family_index: uint32_t::default(), - dst_queue_family_index: uint32_t::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), buffer: Buffer::default(), offset: DeviceSize::default(), size: DeviceSize::default(), @@ -5595,8 +5595,8 @@ pub struct ImageMemoryBarrier { pub dst_access_mask: AccessFlags, pub old_layout: ImageLayout, pub new_layout: ImageLayout, - pub src_queue_family_index: uint32_t, - pub dst_queue_family_index: uint32_t, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, pub image: Image, pub subresource_range: ImageSubresourceRange, } @@ -5609,8 +5609,8 @@ impl ::std::default::Default for ImageMemoryBarrier { dst_access_mask: AccessFlags::default(), old_layout: ImageLayout::default(), new_layout: ImageLayout::default(), - src_queue_family_index: uint32_t::default(), - dst_queue_family_index: uint32_t::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), image: Image::default(), subresource_range: ImageSubresourceRange::default(), } @@ -5625,14 +5625,14 @@ pub struct ImageCreateInfo { pub image_type: ImageType, pub format: Format, pub extent: Extent3D, - pub mip_levels: uint32_t, - pub array_layers: uint32_t, + pub mip_levels: u32, + pub array_layers: u32, pub samples: SampleCountFlags, pub tiling: ImageTiling, pub usage: ImageUsageFlags, pub sharing_mode: SharingMode, - pub queue_family_index_count: uint32_t, - pub p_queue_family_indices: *const uint32_t, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, pub initial_layout: ImageLayout, } impl ::std::default::Default for ImageCreateInfo { @@ -5644,13 +5644,13 @@ impl ::std::default::Default for ImageCreateInfo { image_type: ImageType::default(), format: Format::default(), extent: Extent3D::default(), - mip_levels: uint32_t::default(), - array_layers: uint32_t::default(), + mip_levels: u32::default(), + array_layers: u32::default(), samples: SampleCountFlags::default(), tiling: ImageTiling::default(), usage: ImageUsageFlags::default(), sharing_mode: SharingMode::default(), - queue_family_index_count: uint32_t::default(), + queue_family_index_count: u32::default(), p_queue_family_indices: ::std::ptr::null(), initial_layout: ImageLayout::default(), } @@ -5721,14 +5721,14 @@ pub struct SparseImageMemoryBind { #[derive(Copy, Clone, Debug)] pub struct SparseBufferMemoryBindInfo { pub buffer: Buffer, - pub bind_count: uint32_t, + pub bind_count: u32, pub p_binds: *const SparseMemoryBind, } impl ::std::default::Default for SparseBufferMemoryBindInfo { fn default() -> SparseBufferMemoryBindInfo { SparseBufferMemoryBindInfo { buffer: Buffer::default(), - bind_count: uint32_t::default(), + bind_count: u32::default(), p_binds: ::std::ptr::null(), } } @@ -5737,14 +5737,14 @@ impl ::std::default::Default for SparseBufferMemoryBindInfo { #[derive(Copy, Clone, Debug)] pub struct SparseImageOpaqueMemoryBindInfo { pub image: Image, - pub bind_count: uint32_t, + pub bind_count: u32, pub p_binds: *const SparseMemoryBind, } impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { fn default() -> SparseImageOpaqueMemoryBindInfo { SparseImageOpaqueMemoryBindInfo { image: Image::default(), - bind_count: uint32_t::default(), + bind_count: u32::default(), p_binds: ::std::ptr::null(), } } @@ -5753,14 +5753,14 @@ impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { #[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryBindInfo { pub image: Image, - pub bind_count: uint32_t, + pub bind_count: u32, pub p_binds: *const SparseImageMemoryBind, } impl ::std::default::Default for SparseImageMemoryBindInfo { fn default() -> SparseImageMemoryBindInfo { SparseImageMemoryBindInfo { image: Image::default(), - bind_count: uint32_t::default(), + bind_count: u32::default(), p_binds: ::std::ptr::null(), } } @@ -5770,15 +5770,15 @@ impl ::std::default::Default for SparseImageMemoryBindInfo { pub struct BindSparseInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub wait_semaphore_count: uint32_t, + pub wait_semaphore_count: u32, pub p_wait_semaphores: *const Semaphore, - pub buffer_bind_count: uint32_t, + pub buffer_bind_count: u32, pub p_buffer_binds: *const SparseBufferMemoryBindInfo, - pub image_opaque_bind_count: uint32_t, + pub image_opaque_bind_count: u32, pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo, - pub image_bind_count: uint32_t, + pub image_bind_count: u32, pub p_image_binds: *const SparseImageMemoryBindInfo, - pub signal_semaphore_count: uint32_t, + pub signal_semaphore_count: u32, pub p_signal_semaphores: *const Semaphore, } impl ::std::default::Default for BindSparseInfo { @@ -5786,15 +5786,15 @@ impl ::std::default::Default for BindSparseInfo { BindSparseInfo { s_type: StructureType::BIND_SPARSE_INFO, p_next: ::std::ptr::null(), - wait_semaphore_count: uint32_t::default(), + wait_semaphore_count: u32::default(), p_wait_semaphores: ::std::ptr::null(), - buffer_bind_count: uint32_t::default(), + buffer_bind_count: u32::default(), p_buffer_binds: ::std::ptr::null(), - image_opaque_bind_count: uint32_t::default(), + image_opaque_bind_count: u32::default(), p_image_opaque_binds: ::std::ptr::null(), - image_bind_count: uint32_t::default(), + image_bind_count: u32::default(), p_image_binds: ::std::ptr::null(), - signal_semaphore_count: uint32_t::default(), + signal_semaphore_count: u32::default(), p_signal_semaphores: ::std::ptr::null(), } } @@ -5844,8 +5844,8 @@ impl ::std::default::Default for ImageBlit { #[derive(Copy, Clone, Default, Debug)] pub struct BufferImageCopy { pub buffer_offset: DeviceSize, - pub buffer_row_length: uint32_t, - pub buffer_image_height: uint32_t, + pub buffer_row_length: u32, + pub buffer_image_height: u32, pub image_subresource: ImageSubresourceLayers, pub image_offset: Offset3D, pub image_extent: Extent3D, @@ -5865,8 +5865,8 @@ pub struct ShaderModuleCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ShaderModuleCreateFlags, - pub code_size: size_t, - pub p_code: *const uint32_t, + pub code_size: usize, + pub p_code: *const u32, } impl ::std::default::Default for ShaderModuleCreateInfo { fn default() -> ShaderModuleCreateInfo { @@ -5874,7 +5874,7 @@ impl ::std::default::Default for ShaderModuleCreateInfo { s_type: StructureType::SHADER_MODULE_CREATE_INFO, p_next: ::std::ptr::null(), flags: ShaderModuleCreateFlags::default(), - code_size: size_t::default(), + code_size: usize::default(), p_code: ::std::ptr::null(), } } @@ -5882,18 +5882,18 @@ impl ::std::default::Default for ShaderModuleCreateInfo { #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutBinding { - pub binding: uint32_t, + pub binding: u32, pub descriptor_type: DescriptorType, - pub descriptor_count: uint32_t, + pub descriptor_count: u32, pub stage_flags: ShaderStageFlags, pub p_immutable_samplers: *const Sampler, } impl ::std::default::Default for DescriptorSetLayoutBinding { fn default() -> DescriptorSetLayoutBinding { DescriptorSetLayoutBinding { - binding: uint32_t::default(), + binding: u32::default(), descriptor_type: DescriptorType::default(), - descriptor_count: uint32_t::default(), + descriptor_count: u32::default(), stage_flags: ShaderStageFlags::default(), p_immutable_samplers: ::std::ptr::null(), } @@ -5905,7 +5905,7 @@ pub struct DescriptorSetLayoutCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DescriptorSetLayoutCreateFlags, - pub binding_count: uint32_t, + pub binding_count: u32, pub p_bindings: *const DescriptorSetLayoutBinding, } impl ::std::default::Default for DescriptorSetLayoutCreateInfo { @@ -5914,7 +5914,7 @@ impl ::std::default::Default for DescriptorSetLayoutCreateInfo { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, p_next: ::std::ptr::null(), flags: DescriptorSetLayoutCreateFlags::default(), - binding_count: uint32_t::default(), + binding_count: u32::default(), p_bindings: ::std::ptr::null(), } } @@ -5923,7 +5923,7 @@ impl ::std::default::Default for DescriptorSetLayoutCreateInfo { #[derive(Copy, Clone, Default, Debug)] pub struct DescriptorPoolSize { pub ty: DescriptorType, - pub descriptor_count: uint32_t, + pub descriptor_count: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -5931,8 +5931,8 @@ pub struct DescriptorPoolCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DescriptorPoolCreateFlags, - pub max_sets: uint32_t, - pub pool_size_count: uint32_t, + pub max_sets: u32, + pub pool_size_count: u32, pub p_pool_sizes: *const DescriptorPoolSize, } impl ::std::default::Default for DescriptorPoolCreateInfo { @@ -5941,8 +5941,8 @@ impl ::std::default::Default for DescriptorPoolCreateInfo { s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO, p_next: ::std::ptr::null(), flags: DescriptorPoolCreateFlags::default(), - max_sets: uint32_t::default(), - pool_size_count: uint32_t::default(), + max_sets: u32::default(), + pool_size_count: u32::default(), p_pool_sizes: ::std::ptr::null(), } } @@ -5953,7 +5953,7 @@ pub struct DescriptorSetAllocateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub descriptor_pool: DescriptorPool, - pub descriptor_set_count: uint32_t, + pub descriptor_set_count: u32, pub p_set_layouts: *const DescriptorSetLayout, } impl ::std::default::Default for DescriptorSetAllocateInfo { @@ -5962,7 +5962,7 @@ impl ::std::default::Default for DescriptorSetAllocateInfo { s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, p_next: ::std::ptr::null(), descriptor_pool: DescriptorPool::default(), - descriptor_set_count: uint32_t::default(), + descriptor_set_count: u32::default(), p_set_layouts: ::std::ptr::null(), } } @@ -5970,24 +5970,24 @@ impl ::std::default::Default for DescriptorSetAllocateInfo { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SpecializationMapEntry { - pub constant_id: uint32_t, - pub offset: uint32_t, - pub size: size_t, + pub constant_id: u32, + pub offset: u32, + pub size: usize, } #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SpecializationInfo { - pub map_entry_count: uint32_t, + pub map_entry_count: u32, pub p_map_entries: *const SpecializationMapEntry, - pub data_size: size_t, + pub data_size: usize, pub p_data: *const c_void, } impl ::std::default::Default for SpecializationInfo { fn default() -> SpecializationInfo { SpecializationInfo { - map_entry_count: uint32_t::default(), + map_entry_count: u32::default(), p_map_entries: ::std::ptr::null(), - data_size: size_t::default(), + data_size: usize::default(), p_data: ::std::ptr::null(), } } @@ -6025,7 +6025,7 @@ pub struct ComputePipelineCreateInfo { pub stage: PipelineShaderStageCreateInfo, pub layout: PipelineLayout, pub base_pipeline_handle: Pipeline, - pub base_pipeline_index: int32_t, + pub base_pipeline_index: i32, } impl ::std::default::Default for ComputePipelineCreateInfo { fn default() -> ComputePipelineCreateInfo { @@ -6036,24 +6036,24 @@ impl ::std::default::Default for ComputePipelineCreateInfo { stage: PipelineShaderStageCreateInfo::default(), layout: PipelineLayout::default(), base_pipeline_handle: Pipeline::default(), - base_pipeline_index: int32_t::default(), + base_pipeline_index: i32::default(), } } } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct VertexInputBindingDescription { - pub binding: uint32_t, - pub stride: uint32_t, + pub binding: u32, + pub stride: u32, pub input_rate: VertexInputRate, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct VertexInputAttributeDescription { - pub location: uint32_t, - pub binding: uint32_t, + pub location: u32, + pub binding: u32, pub format: Format, - pub offset: uint32_t, + pub offset: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6061,9 +6061,9 @@ pub struct PipelineVertexInputStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineVertexInputStateCreateFlags, - pub vertex_binding_description_count: uint32_t, + pub vertex_binding_description_count: u32, pub p_vertex_binding_descriptions: *const VertexInputBindingDescription, - pub vertex_attribute_description_count: uint32_t, + pub vertex_attribute_description_count: u32, pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, } impl ::std::default::Default for PipelineVertexInputStateCreateInfo { @@ -6072,9 +6072,9 @@ impl ::std::default::Default for PipelineVertexInputStateCreateInfo { s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineVertexInputStateCreateFlags::default(), - vertex_binding_description_count: uint32_t::default(), + vertex_binding_description_count: u32::default(), p_vertex_binding_descriptions: ::std::ptr::null(), - vertex_attribute_description_count: uint32_t::default(), + vertex_attribute_description_count: u32::default(), p_vertex_attribute_descriptions: ::std::ptr::null(), } } @@ -6105,7 +6105,7 @@ pub struct PipelineTessellationStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineTessellationStateCreateFlags, - pub patch_control_points: uint32_t, + pub patch_control_points: u32, } impl ::std::default::Default for PipelineTessellationStateCreateInfo { fn default() -> PipelineTessellationStateCreateInfo { @@ -6113,7 +6113,7 @@ impl ::std::default::Default for PipelineTessellationStateCreateInfo { s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineTessellationStateCreateFlags::default(), - patch_control_points: uint32_t::default(), + patch_control_points: u32::default(), } } } @@ -6123,9 +6123,9 @@ pub struct PipelineViewportStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineViewportStateCreateFlags, - pub viewport_count: uint32_t, + pub viewport_count: u32, pub p_viewports: *const Viewport, - pub scissor_count: uint32_t, + pub scissor_count: u32, pub p_scissors: *const Rect2D, } impl ::std::default::Default for PipelineViewportStateCreateInfo { @@ -6134,9 +6134,9 @@ impl ::std::default::Default for PipelineViewportStateCreateInfo { s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineViewportStateCreateFlags::default(), - viewport_count: uint32_t::default(), + viewport_count: u32::default(), p_viewports: ::std::ptr::null(), - scissor_count: uint32_t::default(), + scissor_count: u32::default(), p_scissors: ::std::ptr::null(), } } @@ -6225,7 +6225,7 @@ pub struct PipelineColorBlendStateCreateInfo { pub flags: PipelineColorBlendStateCreateFlags, pub logic_op_enable: Bool32, pub logic_op: LogicOp, - pub attachment_count: uint32_t, + pub attachment_count: u32, pub p_attachments: *const PipelineColorBlendAttachmentState, pub blend_constants: [c_float; 4], } @@ -6253,7 +6253,7 @@ impl ::std::default::Default for PipelineColorBlendStateCreateInfo { flags: PipelineColorBlendStateCreateFlags::default(), logic_op_enable: Bool32::default(), logic_op: LogicOp::default(), - attachment_count: uint32_t::default(), + attachment_count: u32::default(), p_attachments: ::std::ptr::null(), blend_constants: unsafe { ::std::mem::zeroed() }, } @@ -6265,7 +6265,7 @@ pub struct PipelineDynamicStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineDynamicStateCreateFlags, - pub dynamic_state_count: uint32_t, + pub dynamic_state_count: u32, pub p_dynamic_states: *const DynamicState, } impl ::std::default::Default for PipelineDynamicStateCreateInfo { @@ -6274,7 +6274,7 @@ impl ::std::default::Default for PipelineDynamicStateCreateInfo { s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineDynamicStateCreateFlags::default(), - dynamic_state_count: uint32_t::default(), + dynamic_state_count: u32::default(), p_dynamic_states: ::std::ptr::null(), } } @@ -6286,9 +6286,9 @@ pub struct StencilOpState { pub pass_op: StencilOp, pub depth_fail_op: StencilOp, pub compare_op: CompareOp, - pub compare_mask: uint32_t, - pub write_mask: uint32_t, - pub reference: uint32_t, + pub compare_mask: u32, + pub write_mask: u32, + pub reference: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6330,7 +6330,7 @@ pub struct GraphicsPipelineCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCreateFlags, - pub stage_count: uint32_t, + pub stage_count: u32, pub p_stages: *const PipelineShaderStageCreateInfo, pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo, @@ -6343,9 +6343,9 @@ pub struct GraphicsPipelineCreateInfo { pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, pub layout: PipelineLayout, pub render_pass: RenderPass, - pub subpass: uint32_t, + pub subpass: u32, pub base_pipeline_handle: Pipeline, - pub base_pipeline_index: int32_t, + pub base_pipeline_index: i32, } impl ::std::default::Default for GraphicsPipelineCreateInfo { fn default() -> GraphicsPipelineCreateInfo { @@ -6353,7 +6353,7 @@ impl ::std::default::Default for GraphicsPipelineCreateInfo { s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineCreateFlags::default(), - stage_count: uint32_t::default(), + stage_count: u32::default(), p_stages: ::std::ptr::null(), p_vertex_input_state: ::std::ptr::null(), p_input_assembly_state: ::std::ptr::null(), @@ -6366,9 +6366,9 @@ impl ::std::default::Default for GraphicsPipelineCreateInfo { p_dynamic_state: ::std::ptr::null(), layout: PipelineLayout::default(), render_pass: RenderPass::default(), - subpass: uint32_t::default(), + subpass: u32::default(), base_pipeline_handle: Pipeline::default(), - base_pipeline_index: int32_t::default(), + base_pipeline_index: i32::default(), } } } @@ -6378,7 +6378,7 @@ pub struct PipelineCacheCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCacheCreateFlags, - pub initial_data_size: size_t, + pub initial_data_size: usize, pub p_initial_data: *const c_void, } impl ::std::default::Default for PipelineCacheCreateInfo { @@ -6387,7 +6387,7 @@ impl ::std::default::Default for PipelineCacheCreateInfo { s_type: StructureType::PIPELINE_CACHE_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineCacheCreateFlags::default(), - initial_data_size: size_t::default(), + initial_data_size: usize::default(), p_initial_data: ::std::ptr::null(), } } @@ -6396,8 +6396,8 @@ impl ::std::default::Default for PipelineCacheCreateInfo { #[derive(Copy, Clone, Default, Debug)] pub struct PushConstantRange { pub stage_flags: ShaderStageFlags, - pub offset: uint32_t, - pub size: uint32_t, + pub offset: u32, + pub size: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -6405,9 +6405,9 @@ pub struct PipelineLayoutCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineLayoutCreateFlags, - pub set_layout_count: uint32_t, + pub set_layout_count: u32, pub p_set_layouts: *const DescriptorSetLayout, - pub push_constant_range_count: uint32_t, + pub push_constant_range_count: u32, pub p_push_constant_ranges: *const PushConstantRange, } impl ::std::default::Default for PipelineLayoutCreateInfo { @@ -6416,9 +6416,9 @@ impl ::std::default::Default for PipelineLayoutCreateInfo { s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineLayoutCreateFlags::default(), - set_layout_count: uint32_t::default(), + set_layout_count: u32::default(), p_set_layouts: ::std::ptr::null(), - push_constant_range_count: uint32_t::default(), + push_constant_range_count: u32::default(), p_push_constant_ranges: ::std::ptr::null(), } } @@ -6475,7 +6475,7 @@ pub struct CommandPoolCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: CommandPoolCreateFlags, - pub queue_family_index: uint32_t, + pub queue_family_index: u32, } impl ::std::default::Default for CommandPoolCreateInfo { fn default() -> CommandPoolCreateInfo { @@ -6483,7 +6483,7 @@ impl ::std::default::Default for CommandPoolCreateInfo { s_type: StructureType::COMMAND_POOL_CREATE_INFO, p_next: ::std::ptr::null(), flags: CommandPoolCreateFlags::default(), - queue_family_index: uint32_t::default(), + queue_family_index: u32::default(), } } } @@ -6494,7 +6494,7 @@ pub struct CommandBufferAllocateInfo { pub p_next: *const c_void, pub command_pool: CommandPool, pub level: CommandBufferLevel, - pub command_buffer_count: uint32_t, + pub command_buffer_count: u32, } impl ::std::default::Default for CommandBufferAllocateInfo { fn default() -> CommandBufferAllocateInfo { @@ -6503,7 +6503,7 @@ impl ::std::default::Default for CommandBufferAllocateInfo { p_next: ::std::ptr::null(), command_pool: CommandPool::default(), level: CommandBufferLevel::default(), - command_buffer_count: uint32_t::default(), + command_buffer_count: u32::default(), } } } @@ -6513,7 +6513,7 @@ pub struct CommandBufferInheritanceInfo { pub s_type: StructureType, pub p_next: *const c_void, pub render_pass: RenderPass, - pub subpass: uint32_t, + pub subpass: u32, pub framebuffer: Framebuffer, pub occlusion_query_enable: Bool32, pub query_flags: QueryControlFlags, @@ -6525,7 +6525,7 @@ impl ::std::default::Default for CommandBufferInheritanceInfo { s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO, p_next: ::std::ptr::null(), render_pass: RenderPass::default(), - subpass: uint32_t::default(), + subpass: u32::default(), framebuffer: Framebuffer::default(), occlusion_query_enable: Bool32::default(), query_flags: QueryControlFlags::default(), @@ -6559,7 +6559,7 @@ pub struct RenderPassBeginInfo { pub render_pass: RenderPass, pub framebuffer: Framebuffer, pub render_area: Rect2D, - pub clear_value_count: uint32_t, + pub clear_value_count: u32, pub p_clear_values: *const ClearValue, } impl ::std::fmt::Debug for RenderPassBeginInfo { @@ -6583,7 +6583,7 @@ impl ::std::default::Default for RenderPassBeginInfo { render_pass: RenderPass::default(), framebuffer: Framebuffer::default(), render_area: Rect2D::default(), - clear_value_count: uint32_t::default(), + clear_value_count: u32::default(), p_clear_values: ::std::ptr::null(), } } @@ -6592,8 +6592,8 @@ impl ::std::default::Default for RenderPassBeginInfo { #[derive(Copy, Clone)] pub union ClearColorValue { pub float32: [c_float; 4], - pub int32: [int32_t; 4], - pub uint32: [uint32_t; 4], + pub int32: [i32; 4], + pub uint32: [u32; 4], } impl ::std::default::Default for ClearColorValue { fn default() -> ClearColorValue { @@ -6604,7 +6604,7 @@ impl ::std::default::Default for ClearColorValue { #[derive(Copy, Clone, Default, Debug)] pub struct ClearDepthStencilValue { pub depth: c_float, - pub stencil: uint32_t, + pub stencil: u32, } #[repr(C)] #[derive(Copy, Clone)] @@ -6621,7 +6621,7 @@ impl ::std::default::Default for ClearValue { #[derive(Copy, Clone, Default)] pub struct ClearAttachment { pub aspect_mask: ImageAspectFlags, - pub color_attachment: uint32_t, + pub color_attachment: u32, pub clear_value: ClearValue, } impl ::std::fmt::Debug for ClearAttachment { @@ -6649,7 +6649,7 @@ pub struct AttachmentDescription { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct AttachmentReference { - pub attachment: uint32_t, + pub attachment: u32, pub layout: ImageLayout, } #[repr(C)] @@ -6657,27 +6657,27 @@ pub struct AttachmentReference { pub struct SubpassDescription { pub flags: SubpassDescriptionFlags, pub pipeline_bind_point: PipelineBindPoint, - pub input_attachment_count: uint32_t, + pub input_attachment_count: u32, pub p_input_attachments: *const AttachmentReference, - pub color_attachment_count: uint32_t, + pub color_attachment_count: u32, pub p_color_attachments: *const AttachmentReference, pub p_resolve_attachments: *const AttachmentReference, pub p_depth_stencil_attachment: *const AttachmentReference, - pub preserve_attachment_count: uint32_t, - pub p_preserve_attachments: *const uint32_t, + pub preserve_attachment_count: u32, + pub p_preserve_attachments: *const u32, } impl ::std::default::Default for SubpassDescription { fn default() -> SubpassDescription { SubpassDescription { flags: SubpassDescriptionFlags::default(), pipeline_bind_point: PipelineBindPoint::default(), - input_attachment_count: uint32_t::default(), + input_attachment_count: u32::default(), p_input_attachments: ::std::ptr::null(), - color_attachment_count: uint32_t::default(), + color_attachment_count: u32::default(), p_color_attachments: ::std::ptr::null(), p_resolve_attachments: ::std::ptr::null(), p_depth_stencil_attachment: ::std::ptr::null(), - preserve_attachment_count: uint32_t::default(), + preserve_attachment_count: u32::default(), p_preserve_attachments: ::std::ptr::null(), } } @@ -6685,8 +6685,8 @@ impl ::std::default::Default for SubpassDescription { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SubpassDependency { - pub src_subpass: uint32_t, - pub dst_subpass: uint32_t, + pub src_subpass: u32, + pub dst_subpass: u32, pub src_stage_mask: PipelineStageFlags, pub dst_stage_mask: PipelineStageFlags, pub src_access_mask: AccessFlags, @@ -6699,11 +6699,11 @@ pub struct RenderPassCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: RenderPassCreateFlags, - pub attachment_count: uint32_t, + pub attachment_count: u32, pub p_attachments: *const AttachmentDescription, - pub subpass_count: uint32_t, + pub subpass_count: u32, pub p_subpasses: *const SubpassDescription, - pub dependency_count: uint32_t, + pub dependency_count: u32, pub p_dependencies: *const SubpassDependency, } impl ::std::default::Default for RenderPassCreateInfo { @@ -6712,11 +6712,11 @@ impl ::std::default::Default for RenderPassCreateInfo { s_type: StructureType::RENDER_PASS_CREATE_INFO, p_next: ::std::ptr::null(), flags: RenderPassCreateFlags::default(), - attachment_count: uint32_t::default(), + attachment_count: u32::default(), p_attachments: ::std::ptr::null(), - subpass_count: uint32_t::default(), + subpass_count: u32::default(), p_subpasses: ::std::ptr::null(), - dependency_count: uint32_t::default(), + dependency_count: u32::default(), p_dependencies: ::std::ptr::null(), } } @@ -6824,103 +6824,103 @@ pub struct PhysicalDeviceSparseProperties { #[repr(C)] #[derive(Copy, Clone)] pub struct PhysicalDeviceLimits { - pub max_image_dimension1_d: uint32_t, - pub max_image_dimension2_d: uint32_t, - pub max_image_dimension3_d: uint32_t, - pub max_image_dimension_cube: uint32_t, - pub max_image_array_layers: uint32_t, - pub max_texel_buffer_elements: uint32_t, - pub max_uniform_buffer_range: uint32_t, - pub max_storage_buffer_range: uint32_t, - pub max_push_constants_size: uint32_t, - pub max_memory_allocation_count: uint32_t, - pub max_sampler_allocation_count: uint32_t, + pub max_image_dimension1_d: u32, + pub max_image_dimension2_d: u32, + pub max_image_dimension3_d: u32, + pub max_image_dimension_cube: u32, + pub max_image_array_layers: u32, + pub max_texel_buffer_elements: u32, + pub max_uniform_buffer_range: u32, + pub max_storage_buffer_range: u32, + pub max_push_constants_size: u32, + pub max_memory_allocation_count: u32, + pub max_sampler_allocation_count: u32, pub buffer_image_granularity: DeviceSize, pub sparse_address_space_size: DeviceSize, - pub max_bound_descriptor_sets: uint32_t, - pub max_per_stage_descriptor_samplers: uint32_t, - pub max_per_stage_descriptor_uniform_buffers: uint32_t, - pub max_per_stage_descriptor_storage_buffers: uint32_t, - pub max_per_stage_descriptor_sampled_images: uint32_t, - pub max_per_stage_descriptor_storage_images: uint32_t, - pub max_per_stage_descriptor_input_attachments: uint32_t, - pub max_per_stage_resources: uint32_t, - pub max_descriptor_set_samplers: uint32_t, - pub max_descriptor_set_uniform_buffers: uint32_t, - pub max_descriptor_set_uniform_buffers_dynamic: uint32_t, - pub max_descriptor_set_storage_buffers: uint32_t, - pub max_descriptor_set_storage_buffers_dynamic: uint32_t, - pub max_descriptor_set_sampled_images: uint32_t, - pub max_descriptor_set_storage_images: uint32_t, - pub max_descriptor_set_input_attachments: uint32_t, - pub max_vertex_input_attributes: uint32_t, - pub max_vertex_input_bindings: uint32_t, - pub max_vertex_input_attribute_offset: uint32_t, - pub max_vertex_input_binding_stride: uint32_t, - pub max_vertex_output_components: uint32_t, - pub max_tessellation_generation_level: uint32_t, - pub max_tessellation_patch_size: uint32_t, - pub max_tessellation_control_per_vertex_input_components: uint32_t, - pub max_tessellation_control_per_vertex_output_components: uint32_t, - pub max_tessellation_control_per_patch_output_components: uint32_t, - pub max_tessellation_control_total_output_components: uint32_t, - pub max_tessellation_evaluation_input_components: uint32_t, - pub max_tessellation_evaluation_output_components: uint32_t, - pub max_geometry_shader_invocations: uint32_t, - pub max_geometry_input_components: uint32_t, - pub max_geometry_output_components: uint32_t, - pub max_geometry_output_vertices: uint32_t, - pub max_geometry_total_output_components: uint32_t, - pub max_fragment_input_components: uint32_t, - pub max_fragment_output_attachments: uint32_t, - pub max_fragment_dual_src_attachments: uint32_t, - pub max_fragment_combined_output_resources: uint32_t, - pub max_compute_shared_memory_size: uint32_t, - pub max_compute_work_group_count: [uint32_t; 3], - pub max_compute_work_group_invocations: uint32_t, - pub max_compute_work_group_size: [uint32_t; 3], - pub sub_pixel_precision_bits: uint32_t, - pub sub_texel_precision_bits: uint32_t, - pub mipmap_precision_bits: uint32_t, - pub max_draw_indexed_index_value: uint32_t, - pub max_draw_indirect_count: uint32_t, + pub max_bound_descriptor_sets: u32, + pub max_per_stage_descriptor_samplers: u32, + pub max_per_stage_descriptor_uniform_buffers: u32, + pub max_per_stage_descriptor_storage_buffers: u32, + pub max_per_stage_descriptor_sampled_images: u32, + pub max_per_stage_descriptor_storage_images: u32, + pub max_per_stage_descriptor_input_attachments: u32, + pub max_per_stage_resources: u32, + pub max_descriptor_set_samplers: u32, + pub max_descriptor_set_uniform_buffers: u32, + pub max_descriptor_set_uniform_buffers_dynamic: u32, + pub max_descriptor_set_storage_buffers: u32, + pub max_descriptor_set_storage_buffers_dynamic: u32, + pub max_descriptor_set_sampled_images: u32, + pub max_descriptor_set_storage_images: u32, + pub max_descriptor_set_input_attachments: u32, + pub max_vertex_input_attributes: u32, + pub max_vertex_input_bindings: u32, + pub max_vertex_input_attribute_offset: u32, + pub max_vertex_input_binding_stride: u32, + pub max_vertex_output_components: u32, + pub max_tessellation_generation_level: u32, + pub max_tessellation_patch_size: u32, + pub max_tessellation_control_per_vertex_input_components: u32, + pub max_tessellation_control_per_vertex_output_components: u32, + pub max_tessellation_control_per_patch_output_components: u32, + pub max_tessellation_control_total_output_components: u32, + pub max_tessellation_evaluation_input_components: u32, + pub max_tessellation_evaluation_output_components: u32, + pub max_geometry_shader_invocations: u32, + pub max_geometry_input_components: u32, + pub max_geometry_output_components: u32, + pub max_geometry_output_vertices: u32, + pub max_geometry_total_output_components: u32, + pub max_fragment_input_components: u32, + pub max_fragment_output_attachments: u32, + pub max_fragment_dual_src_attachments: u32, + pub max_fragment_combined_output_resources: u32, + pub max_compute_shared_memory_size: u32, + pub max_compute_work_group_count: [u32; 3], + pub max_compute_work_group_invocations: u32, + pub max_compute_work_group_size: [u32; 3], + pub sub_pixel_precision_bits: u32, + pub sub_texel_precision_bits: u32, + pub mipmap_precision_bits: u32, + pub max_draw_indexed_index_value: u32, + pub max_draw_indirect_count: u32, pub max_sampler_lod_bias: c_float, pub max_sampler_anisotropy: c_float, - pub max_viewports: uint32_t, - pub max_viewport_dimensions: [uint32_t; 2], + pub max_viewports: u32, + pub max_viewport_dimensions: [u32; 2], pub viewport_bounds_range: [c_float; 2], - pub viewport_sub_pixel_bits: uint32_t, - pub min_memory_map_alignment: size_t, + pub viewport_sub_pixel_bits: u32, + pub min_memory_map_alignment: usize, pub min_texel_buffer_offset_alignment: DeviceSize, pub min_uniform_buffer_offset_alignment: DeviceSize, pub min_storage_buffer_offset_alignment: DeviceSize, - pub min_texel_offset: int32_t, - pub max_texel_offset: uint32_t, - pub min_texel_gather_offset: int32_t, - pub max_texel_gather_offset: uint32_t, + pub min_texel_offset: i32, + pub max_texel_offset: u32, + pub min_texel_gather_offset: i32, + pub max_texel_gather_offset: u32, pub min_interpolation_offset: c_float, pub max_interpolation_offset: c_float, - pub sub_pixel_interpolation_offset_bits: uint32_t, - pub max_framebuffer_width: uint32_t, - pub max_framebuffer_height: uint32_t, - pub max_framebuffer_layers: uint32_t, + pub sub_pixel_interpolation_offset_bits: u32, + pub max_framebuffer_width: u32, + pub max_framebuffer_height: u32, + pub max_framebuffer_layers: u32, pub framebuffer_color_sample_counts: SampleCountFlags, pub framebuffer_depth_sample_counts: SampleCountFlags, pub framebuffer_stencil_sample_counts: SampleCountFlags, pub framebuffer_no_attachments_sample_counts: SampleCountFlags, - pub max_color_attachments: uint32_t, + pub max_color_attachments: u32, pub sampled_image_color_sample_counts: SampleCountFlags, pub sampled_image_integer_sample_counts: SampleCountFlags, pub sampled_image_depth_sample_counts: SampleCountFlags, pub sampled_image_stencil_sample_counts: SampleCountFlags, pub storage_image_sample_counts: SampleCountFlags, - pub max_sample_mask_words: uint32_t, + pub max_sample_mask_words: u32, pub timestamp_compute_and_graphics: Bool32, pub timestamp_period: c_float, - pub max_clip_distances: uint32_t, - pub max_cull_distances: uint32_t, - pub max_combined_clip_and_cull_distances: uint32_t, - pub discrete_queue_priorities: uint32_t, + pub max_clip_distances: u32, + pub max_cull_distances: u32, + pub max_combined_clip_and_cull_distances: u32, + pub discrete_queue_priorities: u32, pub point_size_range: [c_float; 2], pub line_width_range: [c_float; 2], pub point_size_granularity: c_float, @@ -7229,103 +7229,103 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { impl ::std::default::Default for PhysicalDeviceLimits { fn default() -> PhysicalDeviceLimits { PhysicalDeviceLimits { - max_image_dimension1_d: uint32_t::default(), - max_image_dimension2_d: uint32_t::default(), - max_image_dimension3_d: uint32_t::default(), - max_image_dimension_cube: uint32_t::default(), - max_image_array_layers: uint32_t::default(), - max_texel_buffer_elements: uint32_t::default(), - max_uniform_buffer_range: uint32_t::default(), - max_storage_buffer_range: uint32_t::default(), - max_push_constants_size: uint32_t::default(), - max_memory_allocation_count: uint32_t::default(), - max_sampler_allocation_count: uint32_t::default(), + max_image_dimension1_d: u32::default(), + max_image_dimension2_d: u32::default(), + max_image_dimension3_d: u32::default(), + max_image_dimension_cube: u32::default(), + max_image_array_layers: u32::default(), + max_texel_buffer_elements: u32::default(), + max_uniform_buffer_range: u32::default(), + max_storage_buffer_range: u32::default(), + max_push_constants_size: u32::default(), + max_memory_allocation_count: u32::default(), + max_sampler_allocation_count: u32::default(), buffer_image_granularity: DeviceSize::default(), sparse_address_space_size: DeviceSize::default(), - max_bound_descriptor_sets: uint32_t::default(), - max_per_stage_descriptor_samplers: uint32_t::default(), - max_per_stage_descriptor_uniform_buffers: uint32_t::default(), - max_per_stage_descriptor_storage_buffers: uint32_t::default(), - max_per_stage_descriptor_sampled_images: uint32_t::default(), - max_per_stage_descriptor_storage_images: uint32_t::default(), - max_per_stage_descriptor_input_attachments: uint32_t::default(), - max_per_stage_resources: uint32_t::default(), - max_descriptor_set_samplers: uint32_t::default(), - max_descriptor_set_uniform_buffers: uint32_t::default(), - max_descriptor_set_uniform_buffers_dynamic: uint32_t::default(), - max_descriptor_set_storage_buffers: uint32_t::default(), - max_descriptor_set_storage_buffers_dynamic: uint32_t::default(), - max_descriptor_set_sampled_images: uint32_t::default(), - max_descriptor_set_storage_images: uint32_t::default(), - max_descriptor_set_input_attachments: uint32_t::default(), - max_vertex_input_attributes: uint32_t::default(), - max_vertex_input_bindings: uint32_t::default(), - max_vertex_input_attribute_offset: uint32_t::default(), - max_vertex_input_binding_stride: uint32_t::default(), - max_vertex_output_components: uint32_t::default(), - max_tessellation_generation_level: uint32_t::default(), - max_tessellation_patch_size: uint32_t::default(), - max_tessellation_control_per_vertex_input_components: uint32_t::default(), - max_tessellation_control_per_vertex_output_components: uint32_t::default(), - max_tessellation_control_per_patch_output_components: uint32_t::default(), - max_tessellation_control_total_output_components: uint32_t::default(), - max_tessellation_evaluation_input_components: uint32_t::default(), - max_tessellation_evaluation_output_components: uint32_t::default(), - max_geometry_shader_invocations: uint32_t::default(), - max_geometry_input_components: uint32_t::default(), - max_geometry_output_components: uint32_t::default(), - max_geometry_output_vertices: uint32_t::default(), - max_geometry_total_output_components: uint32_t::default(), - max_fragment_input_components: uint32_t::default(), - max_fragment_output_attachments: uint32_t::default(), - max_fragment_dual_src_attachments: uint32_t::default(), - max_fragment_combined_output_resources: uint32_t::default(), - max_compute_shared_memory_size: uint32_t::default(), + max_bound_descriptor_sets: u32::default(), + max_per_stage_descriptor_samplers: u32::default(), + max_per_stage_descriptor_uniform_buffers: u32::default(), + max_per_stage_descriptor_storage_buffers: u32::default(), + max_per_stage_descriptor_sampled_images: u32::default(), + max_per_stage_descriptor_storage_images: u32::default(), + max_per_stage_descriptor_input_attachments: u32::default(), + max_per_stage_resources: u32::default(), + max_descriptor_set_samplers: u32::default(), + max_descriptor_set_uniform_buffers: u32::default(), + max_descriptor_set_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_storage_buffers: u32::default(), + max_descriptor_set_storage_buffers_dynamic: u32::default(), + max_descriptor_set_sampled_images: u32::default(), + max_descriptor_set_storage_images: u32::default(), + max_descriptor_set_input_attachments: u32::default(), + max_vertex_input_attributes: u32::default(), + max_vertex_input_bindings: u32::default(), + max_vertex_input_attribute_offset: u32::default(), + max_vertex_input_binding_stride: u32::default(), + max_vertex_output_components: u32::default(), + max_tessellation_generation_level: u32::default(), + max_tessellation_patch_size: u32::default(), + max_tessellation_control_per_vertex_input_components: u32::default(), + max_tessellation_control_per_vertex_output_components: u32::default(), + max_tessellation_control_per_patch_output_components: u32::default(), + max_tessellation_control_total_output_components: u32::default(), + max_tessellation_evaluation_input_components: u32::default(), + max_tessellation_evaluation_output_components: u32::default(), + max_geometry_shader_invocations: u32::default(), + max_geometry_input_components: u32::default(), + max_geometry_output_components: u32::default(), + max_geometry_output_vertices: u32::default(), + max_geometry_total_output_components: u32::default(), + max_fragment_input_components: u32::default(), + max_fragment_output_attachments: u32::default(), + max_fragment_dual_src_attachments: u32::default(), + max_fragment_combined_output_resources: u32::default(), + max_compute_shared_memory_size: u32::default(), max_compute_work_group_count: unsafe { ::std::mem::zeroed() }, - max_compute_work_group_invocations: uint32_t::default(), + max_compute_work_group_invocations: u32::default(), max_compute_work_group_size: unsafe { ::std::mem::zeroed() }, - sub_pixel_precision_bits: uint32_t::default(), - sub_texel_precision_bits: uint32_t::default(), - mipmap_precision_bits: uint32_t::default(), - max_draw_indexed_index_value: uint32_t::default(), - max_draw_indirect_count: uint32_t::default(), + sub_pixel_precision_bits: u32::default(), + sub_texel_precision_bits: u32::default(), + mipmap_precision_bits: u32::default(), + max_draw_indexed_index_value: u32::default(), + max_draw_indirect_count: u32::default(), max_sampler_lod_bias: c_float::default(), max_sampler_anisotropy: c_float::default(), - max_viewports: uint32_t::default(), + max_viewports: u32::default(), max_viewport_dimensions: unsafe { ::std::mem::zeroed() }, viewport_bounds_range: unsafe { ::std::mem::zeroed() }, - viewport_sub_pixel_bits: uint32_t::default(), - min_memory_map_alignment: size_t::default(), + viewport_sub_pixel_bits: u32::default(), + min_memory_map_alignment: usize::default(), min_texel_buffer_offset_alignment: DeviceSize::default(), min_uniform_buffer_offset_alignment: DeviceSize::default(), min_storage_buffer_offset_alignment: DeviceSize::default(), - min_texel_offset: int32_t::default(), - max_texel_offset: uint32_t::default(), - min_texel_gather_offset: int32_t::default(), - max_texel_gather_offset: uint32_t::default(), + min_texel_offset: i32::default(), + max_texel_offset: u32::default(), + min_texel_gather_offset: i32::default(), + max_texel_gather_offset: u32::default(), min_interpolation_offset: c_float::default(), max_interpolation_offset: c_float::default(), - sub_pixel_interpolation_offset_bits: uint32_t::default(), - max_framebuffer_width: uint32_t::default(), - max_framebuffer_height: uint32_t::default(), - max_framebuffer_layers: uint32_t::default(), + sub_pixel_interpolation_offset_bits: u32::default(), + max_framebuffer_width: u32::default(), + max_framebuffer_height: u32::default(), + max_framebuffer_layers: u32::default(), framebuffer_color_sample_counts: SampleCountFlags::default(), framebuffer_depth_sample_counts: SampleCountFlags::default(), framebuffer_stencil_sample_counts: SampleCountFlags::default(), framebuffer_no_attachments_sample_counts: SampleCountFlags::default(), - max_color_attachments: uint32_t::default(), + max_color_attachments: u32::default(), sampled_image_color_sample_counts: SampleCountFlags::default(), sampled_image_integer_sample_counts: SampleCountFlags::default(), sampled_image_depth_sample_counts: SampleCountFlags::default(), sampled_image_stencil_sample_counts: SampleCountFlags::default(), storage_image_sample_counts: SampleCountFlags::default(), - max_sample_mask_words: uint32_t::default(), + max_sample_mask_words: u32::default(), timestamp_compute_and_graphics: Bool32::default(), timestamp_period: c_float::default(), - max_clip_distances: uint32_t::default(), - max_cull_distances: uint32_t::default(), - max_combined_clip_and_cull_distances: uint32_t::default(), - discrete_queue_priorities: uint32_t::default(), + max_clip_distances: u32::default(), + max_cull_distances: u32::default(), + max_combined_clip_and_cull_distances: u32::default(), + discrete_queue_priorities: u32::default(), point_size_range: unsafe { ::std::mem::zeroed() }, line_width_range: unsafe { ::std::mem::zeroed() }, point_size_granularity: c_float::default(), @@ -7361,7 +7361,7 @@ pub struct QueryPoolCreateInfo { pub p_next: *const c_void, pub flags: QueryPoolCreateFlags, pub query_type: QueryType, - pub query_count: uint32_t, + pub query_count: u32, pub pipeline_statistics: QueryPipelineStatisticFlags, } impl ::std::default::Default for QueryPoolCreateInfo { @@ -7371,7 +7371,7 @@ impl ::std::default::Default for QueryPoolCreateInfo { p_next: ::std::ptr::null(), flags: QueryPoolCreateFlags::default(), query_type: QueryType::default(), - query_count: uint32_t::default(), + query_count: u32::default(), pipeline_statistics: QueryPipelineStatisticFlags::default(), } } @@ -7383,11 +7383,11 @@ pub struct FramebufferCreateInfo { pub p_next: *const c_void, pub flags: FramebufferCreateFlags, pub render_pass: RenderPass, - pub attachment_count: uint32_t, + pub attachment_count: u32, pub p_attachments: *const ImageView, - pub width: uint32_t, - pub height: uint32_t, - pub layers: uint32_t, + pub width: u32, + pub height: u32, + pub layers: u32, } impl ::std::default::Default for FramebufferCreateInfo { fn default() -> FramebufferCreateInfo { @@ -7396,49 +7396,49 @@ impl ::std::default::Default for FramebufferCreateInfo { p_next: ::std::ptr::null(), flags: FramebufferCreateFlags::default(), render_pass: RenderPass::default(), - attachment_count: uint32_t::default(), + attachment_count: u32::default(), p_attachments: ::std::ptr::null(), - width: uint32_t::default(), - height: uint32_t::default(), - layers: uint32_t::default(), + width: u32::default(), + height: u32::default(), + layers: u32::default(), } } } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DrawIndirectCommand { - pub vertex_count: uint32_t, - pub instance_count: uint32_t, - pub first_vertex: uint32_t, - pub first_instance: uint32_t, + pub vertex_count: u32, + pub instance_count: u32, + pub first_vertex: u32, + pub first_instance: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DrawIndexedIndirectCommand { - pub index_count: uint32_t, - pub instance_count: uint32_t, - pub first_index: uint32_t, - pub vertex_offset: int32_t, - pub first_instance: uint32_t, + pub index_count: u32, + pub instance_count: u32, + pub first_index: u32, + pub vertex_offset: i32, + pub first_instance: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DispatchIndirectCommand { - pub x: uint32_t, - pub y: uint32_t, - pub z: uint32_t, + pub x: u32, + pub y: u32, + pub z: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SubmitInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub wait_semaphore_count: uint32_t, + pub wait_semaphore_count: u32, pub p_wait_semaphores: *const Semaphore, pub p_wait_dst_stage_mask: *const PipelineStageFlags, - pub command_buffer_count: uint32_t, + pub command_buffer_count: u32, pub p_command_buffers: *const CommandBuffer, - pub signal_semaphore_count: uint32_t, + pub signal_semaphore_count: u32, pub p_signal_semaphores: *const Semaphore, } impl ::std::default::Default for SubmitInfo { @@ -7446,12 +7446,12 @@ impl ::std::default::Default for SubmitInfo { SubmitInfo { s_type: StructureType::SUBMIT_INFO, p_next: ::std::ptr::null(), - wait_semaphore_count: uint32_t::default(), + wait_semaphore_count: u32::default(), p_wait_semaphores: ::std::ptr::null(), p_wait_dst_stage_mask: ::std::ptr::null(), - command_buffer_count: uint32_t::default(), + command_buffer_count: u32::default(), p_command_buffers: ::std::ptr::null(), - signal_semaphore_count: uint32_t::default(), + signal_semaphore_count: u32::default(), p_signal_semaphores: ::std::ptr::null(), } } @@ -7484,13 +7484,13 @@ impl ::std::default::Default for DisplayPropertiesKHR { #[derive(Copy, Clone, Default, Debug)] pub struct DisplayPlanePropertiesKHR { pub current_display: DisplayKHR, - pub current_stack_index: uint32_t, + pub current_stack_index: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DisplayModeParametersKHR { pub visible_region: Extent2D, - pub refresh_rate: uint32_t, + pub refresh_rate: u32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] @@ -7536,8 +7536,8 @@ pub struct DisplaySurfaceCreateInfoKHR { pub p_next: *const c_void, pub flags: DisplaySurfaceCreateFlagsKHR, pub display_mode: DisplayModeKHR, - pub plane_index: uint32_t, - pub plane_stack_index: uint32_t, + pub plane_index: u32, + pub plane_stack_index: u32, pub transform: SurfaceTransformFlagsKHR, pub global_alpha: c_float, pub alpha_mode: DisplayPlaneAlphaFlagsKHR, @@ -7550,8 +7550,8 @@ impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { p_next: ::std::ptr::null(), flags: DisplaySurfaceCreateFlagsKHR::default(), display_mode: DisplayModeKHR::default(), - plane_index: uint32_t::default(), - plane_stack_index: uint32_t::default(), + plane_index: u32::default(), + plane_stack_index: u32::default(), transform: SurfaceTransformFlagsKHR::default(), global_alpha: c_float::default(), alpha_mode: DisplayPlaneAlphaFlagsKHR::default(), @@ -7582,12 +7582,12 @@ impl ::std::default::Default for DisplayPresentInfoKHR { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SurfaceCapabilitiesKHR { - pub min_image_count: uint32_t, - pub max_image_count: uint32_t, + pub min_image_count: u32, + pub max_image_count: u32, pub current_extent: Extent2D, pub min_image_extent: Extent2D, pub max_image_extent: Extent2D, - pub max_image_array_layers: uint32_t, + pub max_image_array_layers: u32, pub supported_transforms: SurfaceTransformFlagsKHR, pub current_transform: SurfaceTransformFlagsKHR, pub supported_composite_alpha: CompositeAlphaFlagsKHR, @@ -7742,15 +7742,15 @@ pub struct SwapchainCreateInfoKHR { pub p_next: *const c_void, pub flags: SwapchainCreateFlagsKHR, pub surface: SurfaceKHR, - pub min_image_count: uint32_t, + pub min_image_count: u32, pub image_format: Format, pub image_color_space: ColorSpaceKHR, pub image_extent: Extent2D, - pub image_array_layers: uint32_t, + pub image_array_layers: u32, pub image_usage: ImageUsageFlags, pub image_sharing_mode: SharingMode, - pub queue_family_index_count: uint32_t, - pub p_queue_family_indices: *const uint32_t, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, pub pre_transform: SurfaceTransformFlagsKHR, pub composite_alpha: CompositeAlphaFlagsKHR, pub present_mode: PresentModeKHR, @@ -7764,14 +7764,14 @@ impl ::std::default::Default for SwapchainCreateInfoKHR { p_next: ::std::ptr::null(), flags: SwapchainCreateFlagsKHR::default(), surface: SurfaceKHR::default(), - min_image_count: uint32_t::default(), + min_image_count: u32::default(), image_format: Format::default(), image_color_space: ColorSpaceKHR::default(), image_extent: Extent2D::default(), - image_array_layers: uint32_t::default(), + image_array_layers: u32::default(), image_usage: ImageUsageFlags::default(), image_sharing_mode: SharingMode::default(), - queue_family_index_count: uint32_t::default(), + queue_family_index_count: u32::default(), p_queue_family_indices: ::std::ptr::null(), pre_transform: SurfaceTransformFlagsKHR::default(), composite_alpha: CompositeAlphaFlagsKHR::default(), @@ -7786,11 +7786,11 @@ impl ::std::default::Default for SwapchainCreateInfoKHR { pub struct PresentInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub wait_semaphore_count: uint32_t, + pub wait_semaphore_count: u32, pub p_wait_semaphores: *const Semaphore, - pub swapchain_count: uint32_t, + pub swapchain_count: u32, pub p_swapchains: *const SwapchainKHR, - pub p_image_indices: *const uint32_t, + pub p_image_indices: *const u32, pub p_results: *mut Result, } impl ::std::default::Default for PresentInfoKHR { @@ -7798,9 +7798,9 @@ impl ::std::default::Default for PresentInfoKHR { PresentInfoKHR { s_type: StructureType::PRESENT_INFO_KHR, p_next: ::std::ptr::null(), - wait_semaphore_count: uint32_t::default(), + wait_semaphore_count: u32::default(), p_wait_semaphores: ::std::ptr::null(), - swapchain_count: uint32_t::default(), + swapchain_count: u32::default(), p_swapchains: ::std::ptr::null(), p_image_indices: ::std::ptr::null(), p_results: ::std::ptr::null_mut(), @@ -7843,7 +7843,7 @@ impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { pub struct ValidationFlagsEXT { pub s_type: StructureType, pub p_next: *const c_void, - pub disabled_validation_check_count: uint32_t, + pub disabled_validation_check_count: u32, pub p_disabled_validation_checks: *mut ValidationCheckEXT, } impl ::std::default::Default for ValidationFlagsEXT { @@ -7851,7 +7851,7 @@ impl ::std::default::Default for ValidationFlagsEXT { ValidationFlagsEXT { s_type: StructureType::VALIDATION_FLAGS_EXT, p_next: ::std::ptr::null(), - disabled_validation_check_count: uint32_t::default(), + disabled_validation_check_count: u32::default(), p_disabled_validation_checks: ::std::ptr::null_mut(), } } @@ -7878,7 +7878,7 @@ pub struct DebugMarkerObjectNameInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: DebugReportObjectTypeEXT, - pub object: uint64_t, + pub object: u64, pub p_object_name: *const c_char, } impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { @@ -7887,7 +7887,7 @@ impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT, p_next: ::std::ptr::null(), object_type: DebugReportObjectTypeEXT::default(), - object: uint64_t::default(), + object: u64::default(), p_object_name: ::std::ptr::null(), } } @@ -7898,9 +7898,9 @@ pub struct DebugMarkerObjectTagInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: DebugReportObjectTypeEXT, - pub object: uint64_t, - pub tag_name: uint64_t, - pub tag_size: size_t, + pub object: u64, + pub tag_name: u64, + pub tag_size: usize, pub p_tag: *const c_void, } impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { @@ -7909,9 +7909,9 @@ impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT, p_next: ::std::ptr::null(), object_type: DebugReportObjectTypeEXT::default(), - object: uint64_t::default(), - tag_name: uint64_t::default(), - tag_size: size_t::default(), + object: u64::default(), + tag_name: u64::default(), + tag_size: usize::default(), p_tag: ::std::ptr::null(), } } @@ -8077,24 +8077,24 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoNV { pub struct Win32KeyedMutexAcquireReleaseInfoNV { pub s_type: StructureType, pub p_next: *const c_void, - pub acquire_count: uint32_t, + pub acquire_count: u32, pub p_acquire_syncs: *const DeviceMemory, - pub p_acquire_keys: *const uint64_t, - pub p_acquire_timeout_milliseconds: *const uint32_t, - pub release_count: uint32_t, + pub p_acquire_keys: *const u64, + pub p_acquire_timeout_milliseconds: *const u32, + pub release_count: u32, pub p_release_syncs: *const DeviceMemory, - pub p_release_keys: *const uint64_t, + pub p_release_keys: *const u64, } impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { fn default() -> Win32KeyedMutexAcquireReleaseInfoNV { Win32KeyedMutexAcquireReleaseInfoNV { s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, p_next: ::std::ptr::null(), - acquire_count: uint32_t::default(), + acquire_count: u32::default(), p_acquire_syncs: ::std::ptr::null(), p_acquire_keys: ::std::ptr::null(), p_acquire_timeout_milliseconds: ::std::ptr::null(), - release_count: uint32_t::default(), + release_count: u32::default(), p_release_syncs: ::std::ptr::null(), p_release_keys: ::std::ptr::null(), } @@ -8121,22 +8121,22 @@ impl ::std::default::Default for DeviceGeneratedCommandsFeaturesNVX { pub struct DeviceGeneratedCommandsLimitsNVX { pub s_type: StructureType, pub p_next: *const c_void, - pub max_indirect_commands_layout_token_count: uint32_t, - pub max_object_entry_counts: uint32_t, - pub min_sequence_count_buffer_offset_alignment: uint32_t, - pub min_sequence_index_buffer_offset_alignment: uint32_t, - pub min_commands_token_buffer_offset_alignment: uint32_t, + pub max_indirect_commands_layout_token_count: u32, + pub max_object_entry_counts: u32, + pub min_sequence_count_buffer_offset_alignment: u32, + pub min_sequence_index_buffer_offset_alignment: u32, + pub min_commands_token_buffer_offset_alignment: u32, } impl ::std::default::Default for DeviceGeneratedCommandsLimitsNVX { fn default() -> DeviceGeneratedCommandsLimitsNVX { DeviceGeneratedCommandsLimitsNVX { s_type: StructureType::DEVICE_GENERATED_COMMANDS_LIMITS_NVX, p_next: ::std::ptr::null(), - max_indirect_commands_layout_token_count: uint32_t::default(), - max_object_entry_counts: uint32_t::default(), - min_sequence_count_buffer_offset_alignment: uint32_t::default(), - min_sequence_index_buffer_offset_alignment: uint32_t::default(), - min_commands_token_buffer_offset_alignment: uint32_t::default(), + max_indirect_commands_layout_token_count: u32::default(), + max_object_entry_counts: u32::default(), + min_sequence_count_buffer_offset_alignment: u32::default(), + min_sequence_index_buffer_offset_alignment: u32::default(), + min_commands_token_buffer_offset_alignment: u32::default(), } } } @@ -8151,9 +8151,9 @@ pub struct IndirectCommandsTokenNVX { #[derive(Copy, Clone, Default, Debug)] pub struct IndirectCommandsLayoutTokenNVX { pub token_type: IndirectCommandsTokenTypeNVX, - pub binding_unit: uint32_t, - pub dynamic_count: uint32_t, - pub divisor: uint32_t, + pub binding_unit: u32, + pub dynamic_count: u32, + pub divisor: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8162,7 +8162,7 @@ pub struct IndirectCommandsLayoutCreateInfoNVX { pub p_next: *const c_void, pub pipeline_bind_point: PipelineBindPoint, pub flags: IndirectCommandsLayoutUsageFlagsNVX, - pub token_count: uint32_t, + pub token_count: u32, pub p_tokens: *const IndirectCommandsLayoutTokenNVX, } impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNVX { @@ -8172,7 +8172,7 @@ impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNVX { p_next: ::std::ptr::null(), pipeline_bind_point: PipelineBindPoint::default(), flags: IndirectCommandsLayoutUsageFlagsNVX::default(), - token_count: uint32_t::default(), + token_count: u32::default(), p_tokens: ::std::ptr::null(), } } @@ -8184,9 +8184,9 @@ pub struct CmdProcessCommandsInfoNVX { pub p_next: *const c_void, pub object_table: ObjectTableNVX, pub indirect_commands_layout: IndirectCommandsLayoutNVX, - pub indirect_commands_token_count: uint32_t, + pub indirect_commands_token_count: u32, pub p_indirect_commands_tokens: *const IndirectCommandsTokenNVX, - pub max_sequences_count: uint32_t, + pub max_sequences_count: u32, pub target_command_buffer: CommandBuffer, pub sequences_count_buffer: Buffer, pub sequences_count_offset: DeviceSize, @@ -8200,9 +8200,9 @@ impl ::std::default::Default for CmdProcessCommandsInfoNVX { p_next: ::std::ptr::null(), object_table: ObjectTableNVX::default(), indirect_commands_layout: IndirectCommandsLayoutNVX::default(), - indirect_commands_token_count: uint32_t::default(), + indirect_commands_token_count: u32::default(), p_indirect_commands_tokens: ::std::ptr::null(), - max_sequences_count: uint32_t::default(), + max_sequences_count: u32::default(), target_command_buffer: CommandBuffer::default(), sequences_count_buffer: Buffer::default(), sequences_count_offset: DeviceSize::default(), @@ -8218,7 +8218,7 @@ pub struct CmdReserveSpaceForCommandsInfoNVX { pub p_next: *const c_void, pub object_table: ObjectTableNVX, pub indirect_commands_layout: IndirectCommandsLayoutNVX, - pub max_sequences_count: uint32_t, + pub max_sequences_count: u32, } impl ::std::default::Default for CmdReserveSpaceForCommandsInfoNVX { fn default() -> CmdReserveSpaceForCommandsInfoNVX { @@ -8227,7 +8227,7 @@ impl ::std::default::Default for CmdReserveSpaceForCommandsInfoNVX { p_next: ::std::ptr::null(), object_table: ObjectTableNVX::default(), indirect_commands_layout: IndirectCommandsLayoutNVX::default(), - max_sequences_count: uint32_t::default(), + max_sequences_count: u32::default(), } } } @@ -8236,30 +8236,30 @@ impl ::std::default::Default for CmdReserveSpaceForCommandsInfoNVX { pub struct ObjectTableCreateInfoNVX { pub s_type: StructureType, pub p_next: *const c_void, - pub object_count: uint32_t, + pub object_count: u32, pub p_object_entry_types: *const ObjectEntryTypeNVX, - pub p_object_entry_counts: *const uint32_t, + pub p_object_entry_counts: *const u32, pub p_object_entry_usage_flags: *const ObjectEntryUsageFlagsNVX, - pub max_uniform_buffers_per_descriptor: uint32_t, - pub max_storage_buffers_per_descriptor: uint32_t, - pub max_storage_images_per_descriptor: uint32_t, - pub max_sampled_images_per_descriptor: uint32_t, - pub max_pipeline_layouts: uint32_t, + pub max_uniform_buffers_per_descriptor: u32, + pub max_storage_buffers_per_descriptor: u32, + pub max_storage_images_per_descriptor: u32, + pub max_sampled_images_per_descriptor: u32, + pub max_pipeline_layouts: u32, } impl ::std::default::Default for ObjectTableCreateInfoNVX { fn default() -> ObjectTableCreateInfoNVX { ObjectTableCreateInfoNVX { s_type: StructureType::OBJECT_TABLE_CREATE_INFO_NVX, p_next: ::std::ptr::null(), - object_count: uint32_t::default(), + object_count: u32::default(), p_object_entry_types: ::std::ptr::null(), p_object_entry_counts: ::std::ptr::null(), p_object_entry_usage_flags: ::std::ptr::null(), - max_uniform_buffers_per_descriptor: uint32_t::default(), - max_storage_buffers_per_descriptor: uint32_t::default(), - max_storage_images_per_descriptor: uint32_t::default(), - max_sampled_images_per_descriptor: uint32_t::default(), - max_pipeline_layouts: uint32_t::default(), + max_uniform_buffers_per_descriptor: u32::default(), + max_storage_buffers_per_descriptor: u32::default(), + max_storage_images_per_descriptor: u32::default(), + max_sampled_images_per_descriptor: u32::default(), + max_pipeline_layouts: u32::default(), } } } @@ -8472,14 +8472,14 @@ impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { pub struct PhysicalDevicePushDescriptorPropertiesKHR { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_push_descriptors: uint32_t, + pub max_push_descriptors: u32, } impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { fn default() -> PhysicalDevicePushDescriptorPropertiesKHR { PhysicalDevicePushDescriptorPropertiesKHR { s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), - max_push_descriptors: uint32_t::default(), + max_push_descriptors: u32::default(), } } } @@ -8488,7 +8488,7 @@ impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { pub struct PresentRegionsKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub swapchain_count: uint32_t, + pub swapchain_count: u32, pub p_regions: *const PresentRegionKHR, } impl ::std::default::Default for PresentRegionsKHR { @@ -8496,7 +8496,7 @@ impl ::std::default::Default for PresentRegionsKHR { PresentRegionsKHR { s_type: StructureType::PRESENT_REGIONS_KHR, p_next: ::std::ptr::null(), - swapchain_count: uint32_t::default(), + swapchain_count: u32::default(), p_regions: ::std::ptr::null(), } } @@ -8504,13 +8504,13 @@ impl ::std::default::Default for PresentRegionsKHR { #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentRegionKHR { - pub rectangle_count: uint32_t, + pub rectangle_count: u32, pub p_rectangles: *const RectLayerKHR, } impl ::std::default::Default for PresentRegionKHR { fn default() -> PresentRegionKHR { PresentRegionKHR { - rectangle_count: uint32_t::default(), + rectangle_count: u32::default(), p_rectangles: ::std::ptr::null(), } } @@ -8520,7 +8520,7 @@ impl ::std::default::Default for PresentRegionKHR { pub struct RectLayerKHR { pub offset: Offset2D, pub extent: Extent2D, - pub layer: uint32_t, + pub layer: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -8620,10 +8620,10 @@ impl ::std::default::Default for ExternalBufferProperties { pub struct PhysicalDeviceIDProperties { pub s_type: StructureType, pub p_next: *mut c_void, - pub device_uuid: [uint8_t; UUID_SIZE], - pub driver_uuid: [uint8_t; UUID_SIZE], - pub device_luid: [uint8_t; LUID_SIZE], - pub device_node_mask: uint32_t, + pub device_uuid: [u8; UUID_SIZE], + pub driver_uuid: [u8; UUID_SIZE], + pub device_luid: [u8; LUID_SIZE], + pub device_node_mask: u32, pub device_luid_valid: Bool32, } impl ::std::fmt::Debug for PhysicalDeviceIDProperties { @@ -8653,7 +8653,7 @@ impl ::std::default::Default for PhysicalDeviceIDProperties { device_uuid: unsafe { ::std::mem::zeroed() }, driver_uuid: unsafe { ::std::mem::zeroed() }, device_luid: unsafe { ::std::mem::zeroed() }, - device_node_mask: uint32_t::default(), + device_node_mask: u32::default(), device_luid_valid: Bool32::default(), } } @@ -8751,14 +8751,14 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { pub struct MemoryWin32HandlePropertiesKHR { pub s_type: StructureType, pub p_next: *mut c_void, - pub memory_type_bits: uint32_t, + pub memory_type_bits: u32, } impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { fn default() -> MemoryWin32HandlePropertiesKHR { MemoryWin32HandlePropertiesKHR { s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), - memory_type_bits: uint32_t::default(), + memory_type_bits: u32::default(), } } } @@ -8803,14 +8803,14 @@ impl ::std::default::Default for ImportMemoryFdInfoKHR { pub struct MemoryFdPropertiesKHR { pub s_type: StructureType, pub p_next: *mut c_void, - pub memory_type_bits: uint32_t, + pub memory_type_bits: u32, } impl ::std::default::Default for MemoryFdPropertiesKHR { fn default() -> MemoryFdPropertiesKHR { MemoryFdPropertiesKHR { s_type: StructureType::MEMORY_FD_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), - memory_type_bits: uint32_t::default(), + memory_type_bits: u32::default(), } } } @@ -8837,24 +8837,24 @@ impl ::std::default::Default for MemoryGetFdInfoKHR { pub struct Win32KeyedMutexAcquireReleaseInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub acquire_count: uint32_t, + pub acquire_count: u32, pub p_acquire_syncs: *const DeviceMemory, - pub p_acquire_keys: *const uint64_t, - pub p_acquire_timeouts: *const uint32_t, - pub release_count: uint32_t, + pub p_acquire_keys: *const u64, + pub p_acquire_timeouts: *const u32, + pub release_count: u32, pub p_release_syncs: *const DeviceMemory, - pub p_release_keys: *const uint64_t, + pub p_release_keys: *const u64, } impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { fn default() -> Win32KeyedMutexAcquireReleaseInfoKHR { Win32KeyedMutexAcquireReleaseInfoKHR { s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, p_next: ::std::ptr::null(), - acquire_count: uint32_t::default(), + acquire_count: u32::default(), p_acquire_syncs: ::std::ptr::null(), p_acquire_keys: ::std::ptr::null(), p_acquire_timeouts: ::std::ptr::null(), - release_count: uint32_t::default(), + release_count: u32::default(), p_release_syncs: ::std::ptr::null(), p_release_keys: ::std::ptr::null(), } @@ -8961,19 +8961,19 @@ impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { pub struct D3D12FenceSubmitInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub wait_semaphore_values_count: uint32_t, - pub p_wait_semaphore_values: *const uint64_t, - pub signal_semaphore_values_count: uint32_t, - pub p_signal_semaphore_values: *const uint64_t, + pub wait_semaphore_values_count: u32, + pub p_wait_semaphore_values: *const u64, + pub signal_semaphore_values_count: u32, + pub p_signal_semaphore_values: *const u64, } impl ::std::default::Default for D3D12FenceSubmitInfoKHR { fn default() -> D3D12FenceSubmitInfoKHR { D3D12FenceSubmitInfoKHR { s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR, p_next: ::std::ptr::null(), - wait_semaphore_values_count: uint32_t::default(), + wait_semaphore_values_count: u32::default(), p_wait_semaphore_values: ::std::ptr::null(), - signal_semaphore_values_count: uint32_t::default(), + signal_semaphore_values_count: u32::default(), p_signal_semaphore_values: ::std::ptr::null(), } } @@ -9215,16 +9215,16 @@ impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { pub struct PhysicalDeviceMultiviewProperties { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_multiview_view_count: uint32_t, - pub max_multiview_instance_index: uint32_t, + pub max_multiview_view_count: u32, + pub max_multiview_instance_index: u32, } impl ::std::default::Default for PhysicalDeviceMultiviewProperties { fn default() -> PhysicalDeviceMultiviewProperties { PhysicalDeviceMultiviewProperties { s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, p_next: ::std::ptr::null_mut(), - max_multiview_view_count: uint32_t::default(), - max_multiview_instance_index: uint32_t::default(), + max_multiview_view_count: u32::default(), + max_multiview_instance_index: u32::default(), } } } @@ -9233,23 +9233,23 @@ impl ::std::default::Default for PhysicalDeviceMultiviewProperties { pub struct RenderPassMultiviewCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub subpass_count: uint32_t, - pub p_view_masks: *const uint32_t, - pub dependency_count: uint32_t, - pub p_view_offsets: *const int32_t, - pub correlation_mask_count: uint32_t, - pub p_correlation_masks: *const uint32_t, + pub subpass_count: u32, + pub p_view_masks: *const u32, + pub dependency_count: u32, + pub p_view_offsets: *const i32, + pub correlation_mask_count: u32, + pub p_correlation_masks: *const u32, } impl ::std::default::Default for RenderPassMultiviewCreateInfo { fn default() -> RenderPassMultiviewCreateInfo { RenderPassMultiviewCreateInfo { s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO, p_next: ::std::ptr::null(), - subpass_count: uint32_t::default(), + subpass_count: u32::default(), p_view_masks: ::std::ptr::null(), - dependency_count: uint32_t::default(), + dependency_count: u32::default(), p_view_offsets: ::std::ptr::null(), - correlation_mask_count: uint32_t::default(), + correlation_mask_count: u32::default(), p_correlation_masks: ::std::ptr::null(), } } @@ -9259,12 +9259,12 @@ impl ::std::default::Default for RenderPassMultiviewCreateInfo { pub struct SurfaceCapabilities2EXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub min_image_count: uint32_t, - pub max_image_count: uint32_t, + pub min_image_count: u32, + pub max_image_count: u32, pub current_extent: Extent2D, pub min_image_extent: Extent2D, pub max_image_extent: Extent2D, - pub max_image_array_layers: uint32_t, + pub max_image_array_layers: u32, pub supported_transforms: SurfaceTransformFlagsKHR, pub current_transform: SurfaceTransformFlagsKHR, pub supported_composite_alpha: CompositeAlphaFlagsKHR, @@ -9276,12 +9276,12 @@ impl ::std::default::Default for SurfaceCapabilities2EXT { SurfaceCapabilities2EXT { s_type: StructureType::SURFACE_CAPABILITIES_2_EXT, p_next: ::std::ptr::null_mut(), - min_image_count: uint32_t::default(), - max_image_count: uint32_t::default(), + min_image_count: u32::default(), + max_image_count: u32::default(), current_extent: Extent2D::default(), min_image_extent: Extent2D::default(), max_image_extent: Extent2D::default(), - max_image_array_layers: uint32_t::default(), + max_image_array_layers: u32::default(), supported_transforms: SurfaceTransformFlagsKHR::default(), current_transform: SurfaceTransformFlagsKHR::default(), supported_composite_alpha: CompositeAlphaFlagsKHR::default(), @@ -9359,7 +9359,7 @@ impl ::std::default::Default for SwapchainCounterCreateInfoEXT { pub struct PhysicalDeviceGroupProperties { pub s_type: StructureType, pub p_next: *mut c_void, - pub physical_device_count: uint32_t, + pub physical_device_count: u32, pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, } @@ -9381,7 +9381,7 @@ impl ::std::default::Default for PhysicalDeviceGroupProperties { PhysicalDeviceGroupProperties { s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES, p_next: ::std::ptr::null_mut(), - physical_device_count: uint32_t::default(), + physical_device_count: u32::default(), physical_devices: unsafe { ::std::mem::zeroed() }, subset_allocation: Bool32::default(), } @@ -9393,7 +9393,7 @@ pub struct MemoryAllocateFlagsInfo { pub s_type: StructureType, pub p_next: *const c_void, pub flags: MemoryAllocateFlags, - pub device_mask: uint32_t, + pub device_mask: u32, } impl ::std::default::Default for MemoryAllocateFlagsInfo { fn default() -> MemoryAllocateFlagsInfo { @@ -9401,7 +9401,7 @@ impl ::std::default::Default for MemoryAllocateFlagsInfo { s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO, p_next: ::std::ptr::null(), flags: MemoryAllocateFlags::default(), - device_mask: uint32_t::default(), + device_mask: u32::default(), } } } @@ -9430,15 +9430,15 @@ impl ::std::default::Default for BindBufferMemoryInfo { pub struct BindBufferMemoryDeviceGroupInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub device_index_count: uint32_t, - pub p_device_indices: *const uint32_t, + pub device_index_count: u32, + pub p_device_indices: *const u32, } impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { fn default() -> BindBufferMemoryDeviceGroupInfo { BindBufferMemoryDeviceGroupInfo { s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, p_next: ::std::ptr::null(), - device_index_count: uint32_t::default(), + device_index_count: u32::default(), p_device_indices: ::std::ptr::null(), } } @@ -9468,9 +9468,9 @@ impl ::std::default::Default for BindImageMemoryInfo { pub struct BindImageMemoryDeviceGroupInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub device_index_count: uint32_t, - pub p_device_indices: *const uint32_t, - pub split_instance_bind_region_count: uint32_t, + pub device_index_count: u32, + pub p_device_indices: *const u32, + pub split_instance_bind_region_count: u32, pub p_split_instance_bind_regions: *const Rect2D, } impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { @@ -9478,9 +9478,9 @@ impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { BindImageMemoryDeviceGroupInfo { s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, p_next: ::std::ptr::null(), - device_index_count: uint32_t::default(), + device_index_count: u32::default(), p_device_indices: ::std::ptr::null(), - split_instance_bind_region_count: uint32_t::default(), + split_instance_bind_region_count: u32::default(), p_split_instance_bind_regions: ::std::ptr::null(), } } @@ -9490,8 +9490,8 @@ impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { pub struct DeviceGroupRenderPassBeginInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub device_mask: uint32_t, - pub device_render_area_count: uint32_t, + pub device_mask: u32, + pub device_render_area_count: u32, pub p_device_render_areas: *const Rect2D, } impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { @@ -9499,8 +9499,8 @@ impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { DeviceGroupRenderPassBeginInfo { s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, p_next: ::std::ptr::null(), - device_mask: uint32_t::default(), - device_render_area_count: uint32_t::default(), + device_mask: u32::default(), + device_render_area_count: u32::default(), p_device_render_areas: ::std::ptr::null(), } } @@ -9510,14 +9510,14 @@ impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { pub struct DeviceGroupCommandBufferBeginInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub device_mask: uint32_t, + pub device_mask: u32, } impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { fn default() -> DeviceGroupCommandBufferBeginInfo { DeviceGroupCommandBufferBeginInfo { s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, p_next: ::std::ptr::null(), - device_mask: uint32_t::default(), + device_mask: u32::default(), } } } @@ -9526,23 +9526,23 @@ impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { pub struct DeviceGroupSubmitInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub wait_semaphore_count: uint32_t, - pub p_wait_semaphore_device_indices: *const uint32_t, - pub command_buffer_count: uint32_t, - pub p_command_buffer_device_masks: *const uint32_t, - pub signal_semaphore_count: uint32_t, - pub p_signal_semaphore_device_indices: *const uint32_t, + pub wait_semaphore_count: u32, + pub p_wait_semaphore_device_indices: *const u32, + pub command_buffer_count: u32, + pub p_command_buffer_device_masks: *const u32, + pub signal_semaphore_count: u32, + pub p_signal_semaphore_device_indices: *const u32, } impl ::std::default::Default for DeviceGroupSubmitInfo { fn default() -> DeviceGroupSubmitInfo { DeviceGroupSubmitInfo { s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO, p_next: ::std::ptr::null(), - wait_semaphore_count: uint32_t::default(), + wait_semaphore_count: u32::default(), p_wait_semaphore_device_indices: ::std::ptr::null(), - command_buffer_count: uint32_t::default(), + command_buffer_count: u32::default(), p_command_buffer_device_masks: ::std::ptr::null(), - signal_semaphore_count: uint32_t::default(), + signal_semaphore_count: u32::default(), p_signal_semaphore_device_indices: ::std::ptr::null(), } } @@ -9552,16 +9552,16 @@ impl ::std::default::Default for DeviceGroupSubmitInfo { pub struct DeviceGroupBindSparseInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub resource_device_index: uint32_t, - pub memory_device_index: uint32_t, + pub resource_device_index: u32, + pub memory_device_index: u32, } impl ::std::default::Default for DeviceGroupBindSparseInfo { fn default() -> DeviceGroupBindSparseInfo { DeviceGroupBindSparseInfo { s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO, p_next: ::std::ptr::null(), - resource_device_index: uint32_t::default(), - memory_device_index: uint32_t::default(), + resource_device_index: u32::default(), + memory_device_index: u32::default(), } } } @@ -9570,7 +9570,7 @@ impl ::std::default::Default for DeviceGroupBindSparseInfo { pub struct DeviceGroupPresentCapabilitiesKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub present_mask: [uint32_t; MAX_DEVICE_GROUP_SIZE], + pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE], pub modes: DeviceGroupPresentModeFlagsKHR, } impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { @@ -9617,7 +9617,7 @@ pub struct BindImageMemorySwapchainInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain: SwapchainKHR, - pub image_index: uint32_t, + pub image_index: u32, } impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { fn default() -> BindImageMemorySwapchainInfoKHR { @@ -9625,7 +9625,7 @@ impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, p_next: ::std::ptr::null(), swapchain: SwapchainKHR::default(), - image_index: uint32_t::default(), + image_index: u32::default(), } } } @@ -9635,10 +9635,10 @@ pub struct AcquireNextImageInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain: SwapchainKHR, - pub timeout: uint64_t, + pub timeout: u64, pub semaphore: Semaphore, pub fence: Fence, - pub device_mask: uint32_t, + pub device_mask: u32, } impl ::std::default::Default for AcquireNextImageInfoKHR { fn default() -> AcquireNextImageInfoKHR { @@ -9646,10 +9646,10 @@ impl ::std::default::Default for AcquireNextImageInfoKHR { s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR, p_next: ::std::ptr::null(), swapchain: SwapchainKHR::default(), - timeout: uint64_t::default(), + timeout: u64::default(), semaphore: Semaphore::default(), fence: Fence::default(), - device_mask: uint32_t::default(), + device_mask: u32::default(), } } } @@ -9658,8 +9658,8 @@ impl ::std::default::Default for AcquireNextImageInfoKHR { pub struct DeviceGroupPresentInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub swapchain_count: uint32_t, - pub p_device_masks: *const uint32_t, + pub swapchain_count: u32, + pub p_device_masks: *const u32, pub mode: DeviceGroupPresentModeFlagsKHR, } impl ::std::default::Default for DeviceGroupPresentInfoKHR { @@ -9667,7 +9667,7 @@ impl ::std::default::Default for DeviceGroupPresentInfoKHR { DeviceGroupPresentInfoKHR { s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR, p_next: ::std::ptr::null(), - swapchain_count: uint32_t::default(), + swapchain_count: u32::default(), p_device_masks: ::std::ptr::null(), mode: DeviceGroupPresentModeFlagsKHR::default(), } @@ -9678,7 +9678,7 @@ impl ::std::default::Default for DeviceGroupPresentInfoKHR { pub struct DeviceGroupDeviceCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub physical_device_count: uint32_t, + pub physical_device_count: u32, pub p_physical_devices: *const PhysicalDevice, } impl ::std::default::Default for DeviceGroupDeviceCreateInfo { @@ -9686,7 +9686,7 @@ impl ::std::default::Default for DeviceGroupDeviceCreateInfo { DeviceGroupDeviceCreateInfo { s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO, p_next: ::std::ptr::null(), - physical_device_count: uint32_t::default(), + physical_device_count: u32::default(), p_physical_devices: ::std::ptr::null(), } } @@ -9710,12 +9710,12 @@ impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DescriptorUpdateTemplateEntry { - pub dst_binding: uint32_t, - pub dst_array_element: uint32_t, - pub descriptor_count: uint32_t, + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, pub descriptor_type: DescriptorType, - pub offset: size_t, - pub stride: size_t, + pub offset: usize, + pub stride: usize, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -9723,13 +9723,13 @@ pub struct DescriptorUpdateTemplateCreateInfo { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: DescriptorUpdateTemplateCreateFlags, - pub descriptor_update_entry_count: uint32_t, + pub descriptor_update_entry_count: u32, pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry, pub template_type: DescriptorUpdateTemplateType, pub descriptor_set_layout: DescriptorSetLayout, pub pipeline_bind_point: PipelineBindPoint, pub pipeline_layout: PipelineLayout, - pub set: uint32_t, + pub set: u32, } impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { fn default() -> DescriptorUpdateTemplateCreateInfo { @@ -9737,13 +9737,13 @@ impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, p_next: ::std::ptr::null_mut(), flags: DescriptorUpdateTemplateCreateFlags::default(), - descriptor_update_entry_count: uint32_t::default(), + descriptor_update_entry_count: u32::default(), p_descriptor_update_entries: ::std::ptr::null(), template_type: DescriptorUpdateTemplateType::default(), descriptor_set_layout: DescriptorSetLayout::default(), pipeline_bind_point: PipelineBindPoint::default(), pipeline_layout: PipelineLayout::default(), - set: uint32_t::default(), + set: u32::default(), } } } @@ -9786,23 +9786,23 @@ impl ::std::default::Default for HdrMetadataEXT { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct RefreshCycleDurationGOOGLE { - pub refresh_duration: uint64_t, + pub refresh_duration: u64, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PastPresentationTimingGOOGLE { - pub present_id: uint32_t, - pub desired_present_time: uint64_t, - pub actual_present_time: uint64_t, - pub earliest_present_time: uint64_t, - pub present_margin: uint64_t, + pub present_id: u32, + pub desired_present_time: u64, + pub actual_present_time: u64, + pub earliest_present_time: u64, + pub present_margin: u64, } #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentTimesInfoGOOGLE { pub s_type: StructureType, pub p_next: *const c_void, - pub swapchain_count: uint32_t, + pub swapchain_count: u32, pub p_times: *const PresentTimeGOOGLE, } impl ::std::default::Default for PresentTimesInfoGOOGLE { @@ -9810,7 +9810,7 @@ impl ::std::default::Default for PresentTimesInfoGOOGLE { PresentTimesInfoGOOGLE { s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE, p_next: ::std::ptr::null(), - swapchain_count: uint32_t::default(), + swapchain_count: u32::default(), p_times: ::std::ptr::null(), } } @@ -9818,8 +9818,8 @@ impl ::std::default::Default for PresentTimesInfoGOOGLE { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PresentTimeGOOGLE { - pub present_id: uint32_t, - pub desired_present_time: uint64_t, + pub present_id: u32, + pub desired_present_time: u64, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -9869,7 +9869,7 @@ pub struct PipelineViewportWScalingStateCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, pub viewport_w_scaling_enable: Bool32, - pub viewport_count: uint32_t, + pub viewport_count: u32, pub p_viewport_w_scalings: *const ViewportWScalingNV, } impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { @@ -9878,7 +9878,7 @@ impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, p_next: ::std::ptr::null(), viewport_w_scaling_enable: Bool32::default(), - viewport_count: uint32_t::default(), + viewport_count: u32::default(), p_viewport_w_scalings: ::std::ptr::null(), } } @@ -9897,7 +9897,7 @@ pub struct PipelineViewportSwizzleStateCreateInfoNV { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineViewportSwizzleStateCreateFlagsNV, - pub viewport_count: uint32_t, + pub viewport_count: u32, pub p_viewport_swizzles: *const ViewportSwizzleNV, } impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { @@ -9906,7 +9906,7 @@ impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, p_next: ::std::ptr::null(), flags: PipelineViewportSwizzleStateCreateFlagsNV::default(), - viewport_count: uint32_t::default(), + viewport_count: u32::default(), p_viewport_swizzles: ::std::ptr::null(), } } @@ -9916,14 +9916,14 @@ impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_discard_rectangles: uint32_t, + pub max_discard_rectangles: u32, } impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { fn default() -> PhysicalDeviceDiscardRectanglePropertiesEXT { PhysicalDeviceDiscardRectanglePropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), - max_discard_rectangles: uint32_t::default(), + max_discard_rectangles: u32::default(), } } } @@ -9934,7 +9934,7 @@ pub struct PipelineDiscardRectangleStateCreateInfoEXT { pub p_next: *const c_void, pub flags: PipelineDiscardRectangleStateCreateFlagsEXT, pub discard_rectangle_mode: DiscardRectangleModeEXT, - pub discard_rectangle_count: uint32_t, + pub discard_rectangle_count: u32, pub p_discard_rectangles: *const Rect2D, } impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { @@ -9944,7 +9944,7 @@ impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { p_next: ::std::ptr::null(), flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(), discard_rectangle_mode: DiscardRectangleModeEXT::default(), - discard_rectangle_count: uint32_t::default(), + discard_rectangle_count: u32::default(), p_discard_rectangles: ::std::ptr::null(), } } @@ -9968,8 +9968,8 @@ impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropert #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct InputAttachmentAspectReference { - pub subpass: uint32_t, - pub input_attachment_index: uint32_t, + pub subpass: u32, + pub input_attachment_index: u32, pub aspect_mask: ImageAspectFlags, } #[repr(C)] @@ -9977,7 +9977,7 @@ pub struct InputAttachmentAspectReference { pub struct RenderPassInputAttachmentAspectCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, - pub aspect_reference_count: uint32_t, + pub aspect_reference_count: u32, pub p_aspect_references: *const InputAttachmentAspectReference, } impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { @@ -9985,7 +9985,7 @@ impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { RenderPassInputAttachmentAspectCreateInfo { s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, p_next: ::std::ptr::null(), - aspect_reference_count: uint32_t::default(), + aspect_reference_count: u32::default(), p_aspect_references: ::std::ptr::null(), } } @@ -10092,7 +10092,7 @@ pub struct DisplayPlaneInfo2KHR { pub s_type: StructureType, pub p_next: *const c_void, pub mode: DisplayModeKHR, - pub plane_index: uint32_t, + pub plane_index: u32, } impl ::std::default::Default for DisplayPlaneInfo2KHR { fn default() -> DisplayPlaneInfo2KHR { @@ -10100,7 +10100,7 @@ impl ::std::default::Default for DisplayPlaneInfo2KHR { s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR, p_next: ::std::ptr::null(), mode: DisplayModeKHR::default(), - plane_index: uint32_t::default(), + plane_index: u32::default(), } } } @@ -10163,7 +10163,7 @@ impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { pub struct PhysicalDeviceSubgroupProperties { pub s_type: StructureType, pub p_next: *mut c_void, - pub subgroup_size: uint32_t, + pub subgroup_size: u32, pub supported_stages: ShaderStageFlags, pub supported_operations: SubgroupFeatureFlags, pub quad_operations_in_all_stages: Bool32, @@ -10173,7 +10173,7 @@ impl ::std::default::Default for PhysicalDeviceSubgroupProperties { PhysicalDeviceSubgroupProperties { s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, p_next: ::std::ptr::null_mut(), - subgroup_size: uint32_t::default(), + subgroup_size: u32::default(), supported_stages: ShaderStageFlags::default(), supported_operations: SubgroupFeatureFlags::default(), quad_operations_in_all_stages: Bool32::default(), @@ -10443,14 +10443,14 @@ impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { pub struct SamplerYcbcrConversionImageFormatProperties { pub s_type: StructureType, pub p_next: *mut c_void, - pub combined_image_sampler_descriptor_count: uint32_t, + pub combined_image_sampler_descriptor_count: u32, } impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { fn default() -> SamplerYcbcrConversionImageFormatProperties { SamplerYcbcrConversionImageFormatProperties { s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, p_next: ::std::ptr::null_mut(), - combined_image_sampler_descriptor_count: uint32_t::default(), + combined_image_sampler_descriptor_count: u32::default(), } } } @@ -10524,8 +10524,8 @@ pub struct DeviceQueueInfo2 { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceQueueCreateFlags, - pub queue_family_index: uint32_t, - pub queue_index: uint32_t, + pub queue_family_index: u32, + pub queue_index: u32, } impl ::std::default::Default for DeviceQueueInfo2 { fn default() -> DeviceQueueInfo2 { @@ -10533,8 +10533,8 @@ impl ::std::default::Default for DeviceQueueInfo2 { s_type: StructureType::DEVICE_QUEUE_INFO_2, p_next: ::std::ptr::null(), flags: DeviceQueueCreateFlags::default(), - queue_family_index: uint32_t::default(), - queue_index: uint32_t::default(), + queue_family_index: u32::default(), + queue_index: u32::default(), } } } @@ -10545,7 +10545,7 @@ pub struct PipelineCoverageToColorStateCreateInfoNV { pub p_next: *const c_void, pub flags: PipelineCoverageToColorStateCreateFlagsNV, pub coverage_to_color_enable: Bool32, - pub coverage_to_color_location: uint32_t, + pub coverage_to_color_location: u32, } impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { fn default() -> PipelineCoverageToColorStateCreateInfoNV { @@ -10554,7 +10554,7 @@ impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { p_next: ::std::ptr::null(), flags: PipelineCoverageToColorStateCreateFlagsNV::default(), coverage_to_color_enable: Bool32::default(), - coverage_to_color_location: uint32_t::default(), + coverage_to_color_location: u32::default(), } } } @@ -10589,7 +10589,7 @@ pub struct SampleLocationsInfoEXT { pub p_next: *const c_void, pub sample_locations_per_pixel: SampleCountFlags, pub sample_location_grid_size: Extent2D, - pub sample_locations_count: uint32_t, + pub sample_locations_count: u32, pub p_sample_locations: *const SampleLocationEXT, } impl ::std::default::Default for SampleLocationsInfoEXT { @@ -10599,7 +10599,7 @@ impl ::std::default::Default for SampleLocationsInfoEXT { p_next: ::std::ptr::null(), sample_locations_per_pixel: SampleCountFlags::default(), sample_location_grid_size: Extent2D::default(), - sample_locations_count: uint32_t::default(), + sample_locations_count: u32::default(), p_sample_locations: ::std::ptr::null(), } } @@ -10607,13 +10607,13 @@ impl ::std::default::Default for SampleLocationsInfoEXT { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct AttachmentSampleLocationsEXT { - pub attachment_index: uint32_t, + pub attachment_index: u32, pub sample_locations_info: SampleLocationsInfoEXT, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SubpassSampleLocationsEXT { - pub subpass_index: uint32_t, + pub subpass_index: u32, pub sample_locations_info: SampleLocationsInfoEXT, } #[repr(C)] @@ -10621,9 +10621,9 @@ pub struct SubpassSampleLocationsEXT { pub struct RenderPassSampleLocationsBeginInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, - pub attachment_initial_sample_locations_count: uint32_t, + pub attachment_initial_sample_locations_count: u32, pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT, - pub post_subpass_sample_locations_count: uint32_t, + pub post_subpass_sample_locations_count: u32, pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT, } impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { @@ -10631,9 +10631,9 @@ impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { RenderPassSampleLocationsBeginInfoEXT { s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, p_next: ::std::ptr::null(), - attachment_initial_sample_locations_count: uint32_t::default(), + attachment_initial_sample_locations_count: u32::default(), p_attachment_initial_sample_locations: ::std::ptr::null(), - post_subpass_sample_locations_count: uint32_t::default(), + post_subpass_sample_locations_count: u32::default(), p_post_subpass_sample_locations: ::std::ptr::null(), } } @@ -10664,7 +10664,7 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub sample_location_sample_counts: SampleCountFlags, pub max_sample_location_grid_size: Extent2D, pub sample_location_coordinate_range: [c_float; 2], - pub sample_location_sub_pixel_bits: uint32_t, + pub sample_location_sub_pixel_bits: u32, pub variable_sample_locations: Bool32, } impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { @@ -10701,7 +10701,7 @@ impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { sample_location_sample_counts: SampleCountFlags::default(), max_sample_location_grid_size: Extent2D::default(), sample_location_coordinate_range: unsafe { ::std::mem::zeroed() }, - sample_location_sub_pixel_bits: uint32_t::default(), + sample_location_sub_pixel_bits: u32::default(), variable_sample_locations: Bool32::default(), } } @@ -10759,7 +10759,7 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub advanced_blend_max_color_attachments: uint32_t, + pub advanced_blend_max_color_attachments: u32, pub advanced_blend_independent_blend: Bool32, pub advanced_blend_non_premultiplied_src_color: Bool32, pub advanced_blend_non_premultiplied_dst_color: Bool32, @@ -10771,7 +10771,7 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesE PhysicalDeviceBlendOperationAdvancedPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), - advanced_blend_max_color_attachments: uint32_t::default(), + advanced_blend_max_color_attachments: u32::default(), advanced_blend_independent_blend: Bool32::default(), advanced_blend_non_premultiplied_src_color: Bool32::default(), advanced_blend_non_premultiplied_dst_color: Bool32::default(), @@ -10808,7 +10808,7 @@ pub struct PipelineCoverageModulationStateCreateInfoNV { pub flags: PipelineCoverageModulationStateCreateFlagsNV, pub coverage_modulation_mode: CoverageModulationModeNV, pub coverage_modulation_table_enable: Bool32, - pub coverage_modulation_table_count: uint32_t, + pub coverage_modulation_table_count: u32, pub p_coverage_modulation_table: *const c_float, } impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { @@ -10819,7 +10819,7 @@ impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { flags: PipelineCoverageModulationStateCreateFlagsNV::default(), coverage_modulation_mode: CoverageModulationModeNV::default(), coverage_modulation_table_enable: Bool32::default(), - coverage_modulation_table_count: uint32_t::default(), + coverage_modulation_table_count: u32::default(), p_coverage_modulation_table: ::std::ptr::null(), } } @@ -10829,7 +10829,7 @@ impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { pub struct ImageFormatListCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub view_format_count: uint32_t, + pub view_format_count: u32, pub p_view_formats: *const Format, } impl ::std::default::Default for ImageFormatListCreateInfoKHR { @@ -10837,7 +10837,7 @@ impl ::std::default::Default for ImageFormatListCreateInfoKHR { ImageFormatListCreateInfoKHR { s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO_KHR, p_next: ::std::ptr::null(), - view_format_count: uint32_t::default(), + view_format_count: u32::default(), p_view_formats: ::std::ptr::null(), } } @@ -10848,7 +10848,7 @@ pub struct ValidationCacheCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ValidationCacheCreateFlagsEXT, - pub initial_data_size: size_t, + pub initial_data_size: usize, pub p_initial_data: *const c_void, } impl ::std::default::Default for ValidationCacheCreateInfoEXT { @@ -10857,7 +10857,7 @@ impl ::std::default::Default for ValidationCacheCreateInfoEXT { s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), flags: ValidationCacheCreateFlagsEXT::default(), - initial_data_size: size_t::default(), + initial_data_size: usize::default(), p_initial_data: ::std::ptr::null(), } } @@ -10883,7 +10883,7 @@ impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { pub struct PhysicalDeviceMaintenance3Properties { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_per_set_descriptors: uint32_t, + pub max_per_set_descriptors: u32, pub max_memory_allocation_size: DeviceSize, } impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { @@ -10891,7 +10891,7 @@ impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { PhysicalDeviceMaintenance3Properties { s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, p_next: ::std::ptr::null_mut(), - max_per_set_descriptors: uint32_t::default(), + max_per_set_descriptors: u32::default(), max_memory_allocation_size: DeviceSize::default(), } } @@ -10953,22 +10953,22 @@ impl ::std::default::Default for NativeBufferANDROID { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ShaderResourceUsageAMD { - pub num_used_vgprs: uint32_t, - pub num_used_sgprs: uint32_t, - pub lds_size_per_local_work_group: uint32_t, - pub lds_usage_size_in_bytes: size_t, - pub scratch_mem_usage_in_bytes: size_t, + pub num_used_vgprs: u32, + pub num_used_sgprs: u32, + pub lds_size_per_local_work_group: u32, + pub lds_usage_size_in_bytes: usize, + pub scratch_mem_usage_in_bytes: usize, } #[repr(C)] #[derive(Copy, Clone)] pub struct ShaderStatisticsInfoAMD { pub shader_stage_mask: ShaderStageFlags, pub resource_usage: ShaderResourceUsageAMD, - pub num_physical_vgprs: uint32_t, - pub num_physical_sgprs: uint32_t, - pub num_available_vgprs: uint32_t, - pub num_available_sgprs: uint32_t, - pub compute_work_group_size: [uint32_t; 3], + pub num_physical_vgprs: u32, + pub num_physical_sgprs: u32, + pub num_available_vgprs: u32, + pub num_available_sgprs: u32, + pub compute_work_group_size: [u32; 3], } impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { @@ -10990,10 +10990,10 @@ impl ::std::default::Default for ShaderStatisticsInfoAMD { ShaderStatisticsInfoAMD { shader_stage_mask: ShaderStageFlags::default(), resource_usage: ShaderResourceUsageAMD::default(), - num_physical_vgprs: uint32_t::default(), - num_physical_sgprs: uint32_t::default(), - num_available_vgprs: uint32_t::default(), - num_available_sgprs: uint32_t::default(), + num_physical_vgprs: u32::default(), + num_physical_sgprs: u32::default(), + num_available_vgprs: u32::default(), + num_available_sgprs: u32::default(), compute_work_group_size: unsafe { ::std::mem::zeroed() }, } } @@ -11020,7 +11020,7 @@ pub struct DebugUtilsObjectNameInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: ObjectType, - pub object_handle: uint64_t, + pub object_handle: u64, pub p_object_name: *const c_char, } impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { @@ -11029,7 +11029,7 @@ impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT, p_next: ::std::ptr::null(), object_type: ObjectType::default(), - object_handle: uint64_t::default(), + object_handle: u64::default(), p_object_name: ::std::ptr::null(), } } @@ -11040,9 +11040,9 @@ pub struct DebugUtilsObjectTagInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: ObjectType, - pub object_handle: uint64_t, - pub tag_name: uint64_t, - pub tag_size: size_t, + pub object_handle: u64, + pub tag_name: u64, + pub tag_size: usize, pub p_tag: *const c_void, } impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { @@ -11051,9 +11051,9 @@ impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT, p_next: ::std::ptr::null(), object_type: ObjectType::default(), - object_handle: uint64_t::default(), - tag_name: uint64_t::default(), - tag_size: size_t::default(), + object_handle: u64::default(), + tag_name: u64::default(), + tag_size: usize::default(), p_tag: ::std::ptr::null(), } } @@ -11132,13 +11132,13 @@ pub struct DebugUtilsMessengerCallbackDataEXT { pub p_next: *const c_void, pub flags: DebugUtilsMessengerCallbackDataFlagsEXT, pub p_message_id_name: *const c_char, - pub message_id_number: int32_t, + pub message_id_number: i32, pub p_message: *const c_char, - pub queue_label_count: uint32_t, + pub queue_label_count: u32, pub p_queue_labels: *mut DebugUtilsLabelEXT, - pub cmd_buf_label_count: uint32_t, + pub cmd_buf_label_count: u32, pub p_cmd_buf_labels: *mut DebugUtilsLabelEXT, - pub object_count: uint32_t, + pub object_count: u32, pub p_objects: *mut DebugUtilsObjectNameInfoEXT, } impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { @@ -11148,13 +11148,13 @@ impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { p_next: ::std::ptr::null(), flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(), p_message_id_name: ::std::ptr::null(), - message_id_number: int32_t::default(), + message_id_number: i32::default(), p_message: ::std::ptr::null(), - queue_label_count: uint32_t::default(), + queue_label_count: u32::default(), p_queue_labels: ::std::ptr::null_mut(), - cmd_buf_label_count: uint32_t::default(), + cmd_buf_label_count: u32::default(), p_cmd_buf_labels: ::std::ptr::null_mut(), - object_count: uint32_t::default(), + object_count: u32::default(), p_objects: ::std::ptr::null_mut(), } } @@ -11182,14 +11182,14 @@ impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { pub struct MemoryHostPointerPropertiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub memory_type_bits: uint32_t, + pub memory_type_bits: u32, } impl ::std::default::Default for MemoryHostPointerPropertiesEXT { fn default() -> MemoryHostPointerPropertiesEXT { MemoryHostPointerPropertiesEXT { s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), - memory_type_bits: uint32_t::default(), + memory_type_bits: u32::default(), } } } @@ -11246,40 +11246,40 @@ impl ::std::default::Default for PhysicalDeviceConservativeRasterizationProperti pub struct PhysicalDeviceShaderCorePropertiesAMD { pub s_type: StructureType, pub p_next: *mut c_void, - pub shader_engine_count: uint32_t, - pub shader_arrays_per_engine_count: uint32_t, - pub compute_units_per_shader_array: uint32_t, - pub simd_per_compute_unit: uint32_t, - pub wavefronts_per_simd: uint32_t, - pub wavefront_size: uint32_t, - pub sgprs_per_simd: uint32_t, - pub min_sgpr_allocation: uint32_t, - pub max_sgpr_allocation: uint32_t, - pub sgpr_allocation_granularity: uint32_t, - pub vgprs_per_simd: uint32_t, - pub min_vgpr_allocation: uint32_t, - pub max_vgpr_allocation: uint32_t, - pub vgpr_allocation_granularity: uint32_t, + pub shader_engine_count: u32, + pub shader_arrays_per_engine_count: u32, + pub compute_units_per_shader_array: u32, + pub simd_per_compute_unit: u32, + pub wavefronts_per_simd: u32, + pub wavefront_size: u32, + pub sgprs_per_simd: u32, + pub min_sgpr_allocation: u32, + pub max_sgpr_allocation: u32, + pub sgpr_allocation_granularity: u32, + pub vgprs_per_simd: u32, + pub min_vgpr_allocation: u32, + pub max_vgpr_allocation: u32, + pub vgpr_allocation_granularity: u32, } impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { fn default() -> PhysicalDeviceShaderCorePropertiesAMD { PhysicalDeviceShaderCorePropertiesAMD { s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, p_next: ::std::ptr::null_mut(), - shader_engine_count: uint32_t::default(), - shader_arrays_per_engine_count: uint32_t::default(), - compute_units_per_shader_array: uint32_t::default(), - simd_per_compute_unit: uint32_t::default(), - wavefronts_per_simd: uint32_t::default(), - wavefront_size: uint32_t::default(), - sgprs_per_simd: uint32_t::default(), - min_sgpr_allocation: uint32_t::default(), - max_sgpr_allocation: uint32_t::default(), - sgpr_allocation_granularity: uint32_t::default(), - vgprs_per_simd: uint32_t::default(), - min_vgpr_allocation: uint32_t::default(), - max_vgpr_allocation: uint32_t::default(), - vgpr_allocation_granularity: uint32_t::default(), + shader_engine_count: u32::default(), + shader_arrays_per_engine_count: u32::default(), + compute_units_per_shader_array: u32::default(), + simd_per_compute_unit: u32::default(), + wavefronts_per_simd: u32::default(), + wavefront_size: u32::default(), + sgprs_per_simd: u32::default(), + min_sgpr_allocation: u32::default(), + max_sgpr_allocation: u32::default(), + sgpr_allocation_granularity: u32::default(), + vgprs_per_simd: u32::default(), + min_vgpr_allocation: u32::default(), + max_vgpr_allocation: u32::default(), + vgpr_allocation_granularity: u32::default(), } } } @@ -11362,7 +11362,7 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeaturesEXT { pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_update_after_bind_descriptors_in_all_pools: uint32_t, + pub max_update_after_bind_descriptors_in_all_pools: u32, pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, pub shader_sampled_image_array_non_uniform_indexing_native: Bool32, pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32, @@ -11370,28 +11370,28 @@ pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { pub shader_input_attachment_array_non_uniform_indexing_native: Bool32, pub robust_buffer_access_update_after_bind: Bool32, pub quad_divergent_implicit_lod: Bool32, - pub max_per_stage_descriptor_update_after_bind_samplers: uint32_t, - pub max_per_stage_descriptor_update_after_bind_uniform_buffers: uint32_t, - pub max_per_stage_descriptor_update_after_bind_storage_buffers: uint32_t, - pub max_per_stage_descriptor_update_after_bind_sampled_images: uint32_t, - pub max_per_stage_descriptor_update_after_bind_storage_images: uint32_t, - pub max_per_stage_descriptor_update_after_bind_input_attachments: uint32_t, - pub max_per_stage_update_after_bind_resources: uint32_t, - pub max_descriptor_set_update_after_bind_samplers: uint32_t, - pub max_descriptor_set_update_after_bind_uniform_buffers: uint32_t, - pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: uint32_t, - pub max_descriptor_set_update_after_bind_storage_buffers: uint32_t, - pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: uint32_t, - pub max_descriptor_set_update_after_bind_sampled_images: uint32_t, - pub max_descriptor_set_update_after_bind_storage_images: uint32_t, - pub max_descriptor_set_update_after_bind_input_attachments: uint32_t, + pub max_per_stage_descriptor_update_after_bind_samplers: u32, + pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_sampled_images: u32, + pub max_per_stage_descriptor_update_after_bind_storage_images: u32, + pub max_per_stage_descriptor_update_after_bind_input_attachments: u32, + pub max_per_stage_update_after_bind_resources: u32, + pub max_descriptor_set_update_after_bind_samplers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_storage_buffers: u32, + pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_sampled_images: u32, + pub max_descriptor_set_update_after_bind_storage_images: u32, + pub max_descriptor_set_update_after_bind_input_attachments: u32, } impl ::std::default::Default for PhysicalDeviceDescriptorIndexingPropertiesEXT { fn default() -> PhysicalDeviceDescriptorIndexingPropertiesEXT { PhysicalDeviceDescriptorIndexingPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), - max_update_after_bind_descriptors_in_all_pools: uint32_t::default(), + max_update_after_bind_descriptors_in_all_pools: u32::default(), shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(), shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(), shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(), @@ -11399,21 +11399,21 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingPropertiesEXT { shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(), robust_buffer_access_update_after_bind: Bool32::default(), quad_divergent_implicit_lod: Bool32::default(), - max_per_stage_descriptor_update_after_bind_samplers: uint32_t::default(), - max_per_stage_descriptor_update_after_bind_uniform_buffers: uint32_t::default(), - max_per_stage_descriptor_update_after_bind_storage_buffers: uint32_t::default(), - max_per_stage_descriptor_update_after_bind_sampled_images: uint32_t::default(), - max_per_stage_descriptor_update_after_bind_storage_images: uint32_t::default(), - max_per_stage_descriptor_update_after_bind_input_attachments: uint32_t::default(), - max_per_stage_update_after_bind_resources: uint32_t::default(), - max_descriptor_set_update_after_bind_samplers: uint32_t::default(), - max_descriptor_set_update_after_bind_uniform_buffers: uint32_t::default(), - max_descriptor_set_update_after_bind_uniform_buffers_dynamic: uint32_t::default(), - max_descriptor_set_update_after_bind_storage_buffers: uint32_t::default(), - max_descriptor_set_update_after_bind_storage_buffers_dynamic: uint32_t::default(), - max_descriptor_set_update_after_bind_sampled_images: uint32_t::default(), - max_descriptor_set_update_after_bind_storage_images: uint32_t::default(), - max_descriptor_set_update_after_bind_input_attachments: uint32_t::default(), + max_per_stage_descriptor_update_after_bind_samplers: u32::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_images: u32::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(), + max_per_stage_update_after_bind_resources: u32::default(), + max_descriptor_set_update_after_bind_samplers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_sampled_images: u32::default(), + max_descriptor_set_update_after_bind_storage_images: u32::default(), + max_descriptor_set_update_after_bind_input_attachments: u32::default(), } } } @@ -11422,7 +11422,7 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingPropertiesEXT { pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, - pub binding_count: uint32_t, + pub binding_count: u32, pub p_binding_flags: *const DescriptorBindingFlagsEXT, } impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfoEXT { @@ -11430,7 +11430,7 @@ impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfoEXT { DescriptorSetLayoutBindingFlagsCreateInfoEXT { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, p_next: ::std::ptr::null(), - binding_count: uint32_t::default(), + binding_count: u32::default(), p_binding_flags: ::std::ptr::null(), } } @@ -11440,15 +11440,15 @@ impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfoEXT { pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, - pub descriptor_set_count: uint32_t, - pub p_descriptor_counts: *const uint32_t, + pub descriptor_set_count: u32, + pub p_descriptor_counts: *const u32, } impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfoEXT { fn default() -> DescriptorSetVariableDescriptorCountAllocateInfoEXT { DescriptorSetVariableDescriptorCountAllocateInfoEXT { s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, p_next: ::std::ptr::null(), - descriptor_set_count: uint32_t::default(), + descriptor_set_count: u32::default(), p_descriptor_counts: ::std::ptr::null(), } } @@ -11458,29 +11458,29 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInf pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_variable_descriptor_count: uint32_t, + pub max_variable_descriptor_count: u32, } impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupportEXT { fn default() -> DescriptorSetVariableDescriptorCountLayoutSupportEXT { DescriptorSetVariableDescriptorCountLayoutSupportEXT { s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, p_next: ::std::ptr::null_mut(), - max_variable_descriptor_count: uint32_t::default(), + max_variable_descriptor_count: u32::default(), } } } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct VertexInputBindingDivisorDescriptionEXT { - pub binding: uint32_t, - pub divisor: uint32_t, + pub binding: u32, + pub divisor: u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineVertexInputDivisorStateCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, - pub vertex_binding_divisor_count: uint32_t, + pub vertex_binding_divisor_count: u32, pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT, } impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { @@ -11488,7 +11488,7 @@ impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { PipelineVertexInputDivisorStateCreateInfoEXT { s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), - vertex_binding_divisor_count: uint32_t::default(), + vertex_binding_divisor_count: u32::default(), p_vertex_binding_divisors: ::std::ptr::null(), } } @@ -11498,14 +11498,14 @@ impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_vertex_attrib_divisor: uint32_t, + pub max_vertex_attrib_divisor: u32, } impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { fn default() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { PhysicalDeviceVertexAttributeDivisorPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), - max_vertex_attrib_divisor: uint32_t::default(), + max_vertex_attrib_divisor: u32::default(), } } } @@ -11530,14 +11530,14 @@ impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { pub struct AndroidHardwareBufferUsageANDROID { pub s_type: StructureType, pub p_next: *mut c_void, - pub android_hardware_buffer_usage: uint64_t, + pub android_hardware_buffer_usage: u64, } impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { fn default() -> AndroidHardwareBufferUsageANDROID { AndroidHardwareBufferUsageANDROID { s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, p_next: ::std::ptr::null_mut(), - android_hardware_buffer_usage: uint64_t::default(), + android_hardware_buffer_usage: u64::default(), } } } @@ -11547,7 +11547,7 @@ pub struct AndroidHardwareBufferPropertiesANDROID { pub s_type: StructureType, pub p_next: *mut c_void, pub allocation_size: DeviceSize, - pub memory_type_bits: uint32_t, + pub memory_type_bits: u32, } impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { fn default() -> AndroidHardwareBufferPropertiesANDROID { @@ -11555,7 +11555,7 @@ impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, p_next: ::std::ptr::null_mut(), allocation_size: DeviceSize::default(), - memory_type_bits: uint32_t::default(), + memory_type_bits: u32::default(), } } } @@ -11581,7 +11581,7 @@ pub struct AndroidHardwareBufferFormatPropertiesANDROID { pub s_type: StructureType, pub p_next: *mut c_void, pub format: Format, - pub external_format: uint64_t, + pub external_format: u64, pub format_features: FormatFeatureFlags, pub sampler_ycbcr_conversion_components: ComponentMapping, pub suggested_ycbcr_model: SamplerYcbcrModelConversion, @@ -11595,7 +11595,7 @@ impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, p_next: ::std::ptr::null_mut(), format: Format::default(), - external_format: uint64_t::default(), + external_format: u64::default(), format_features: FormatFeatureFlags::default(), sampler_ycbcr_conversion_components: ComponentMapping::default(), suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), @@ -11610,14 +11610,14 @@ impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { pub struct ExternalFormatANDROID { pub s_type: StructureType, pub p_next: *mut c_void, - pub external_format: uint64_t, + pub external_format: u64, } impl ::std::default::Default for ExternalFormatANDROID { fn default() -> ExternalFormatANDROID { ExternalFormatANDROID { s_type: StructureType::EXTERNAL_FORMAT_ANDROID, p_next: ::std::ptr::null_mut(), - external_format: uint64_t::default(), + external_format: u64::default(), } } } @@ -13892,7 +13892,7 @@ pub mod extensions { get_physical_device_surface_support_khr: extern "system" fn( physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, surface: SurfaceKHR, p_supported: *mut Bool32, ) -> Result, @@ -13906,14 +13906,14 @@ pub mod extensions { extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_format_count: *mut uint32_t, + p_surface_format_count: *mut u32, p_surface_formats: *mut SurfaceFormatKHR, ) -> Result, get_physical_device_surface_present_modes_khr: extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, - p_present_mode_count: *mut uint32_t, + p_present_mode_count: *mut u32, p_present_modes: *mut PresentModeKHR, ) -> Result, } @@ -14004,7 +14004,7 @@ pub mod extensions { pub unsafe fn get_physical_device_surface_support_khr( &self, physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, surface: SurfaceKHR, p_supported: *mut Bool32, ) -> Result { @@ -14031,7 +14031,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_surface_format_count: *mut uint32_t, + p_surface_format_count: *mut u32, p_surface_formats: *mut SurfaceFormatKHR, ) -> Result { (self.get_physical_device_surface_formats_khr)( @@ -14045,7 +14045,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_present_mode_count: *mut uint32_t, + p_present_mode_count: *mut u32, p_present_modes: *mut PresentModeKHR, ) -> Result { (self.get_physical_device_surface_present_modes_khr)( @@ -14068,7 +14068,7 @@ pub mod extensions { impl ObjectType { pub const SURFACE_KHR: Self = ObjectType(1000000000); } - pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *mut SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *mut uint32_t , p_swapchain_images : *mut Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : uint64_t , semaphore : Semaphore , fence : Fence , p_image_index : *mut uint32_t , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut uint32_t , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut uint32_t , ) -> Result , } + pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *mut SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *mut u32 , p_swapchain_images : *mut Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : u64 , semaphore : Semaphore , fence : Fence , p_image_index : *mut u32 , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } unsafe impl Send for KhrSwapchainFn {} unsafe impl Sync for KhrSwapchainFn {} impl ::std::clone::Clone for KhrSwapchainFn { @@ -14205,7 +14205,7 @@ pub mod extensions { &self, device: Device, swapchain: SwapchainKHR, - p_swapchain_image_count: *mut uint32_t, + p_swapchain_image_count: *mut u32, p_swapchain_images: *mut Image, ) -> Result { (self.get_swapchain_images_khr)( @@ -14219,10 +14219,10 @@ pub mod extensions { &self, device: Device, swapchain: SwapchainKHR, - timeout: uint64_t, + timeout: u64, semaphore: Semaphore, fence: Fence, - p_image_index: *mut uint32_t, + p_image_index: *mut u32, ) -> Result { (self.acquire_next_image_khr)( device, @@ -14262,7 +14262,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_rect_count: *mut uint32_t, + p_rect_count: *mut u32, p_rects: *mut Rect2D, ) -> Result { (self.get_physical_device_present_rectangles_khr)( @@ -14276,7 +14276,7 @@ pub mod extensions { &self, device: Device, p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *mut uint32_t, + p_image_index: *mut u32, ) -> Result { (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) } @@ -14341,27 +14341,27 @@ pub mod extensions { get_physical_device_display_properties_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayPropertiesKHR, ) -> Result, get_physical_device_display_plane_properties_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayPlanePropertiesKHR, ) -> Result, get_display_plane_supported_displays_khr: extern "system" fn( physical_device: PhysicalDevice, - plane_index: uint32_t, - p_display_count: *mut uint32_t, + plane_index: u32, + p_display_count: *mut u32, p_displays: *mut DisplayKHR, ) -> Result, get_display_mode_properties_khr: extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayModePropertiesKHR, ) -> Result, create_display_mode_khr: extern "system" fn( @@ -14375,7 +14375,7 @@ pub mod extensions { extern "system" fn( physical_device: PhysicalDevice, mode: DisplayModeKHR, - plane_index: uint32_t, + plane_index: u32, p_capabilities: *mut DisplayPlaneCapabilitiesKHR, ) -> Result, create_display_plane_surface_khr: @@ -14484,7 +14484,7 @@ pub mod extensions { pub unsafe fn get_physical_device_display_properties_khr( &self, physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayPropertiesKHR, ) -> Result { (self.get_physical_device_display_properties_khr)( @@ -14496,7 +14496,7 @@ pub mod extensions { pub unsafe fn get_physical_device_display_plane_properties_khr( &self, physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayPlanePropertiesKHR, ) -> Result { (self.get_physical_device_display_plane_properties_khr)( @@ -14508,8 +14508,8 @@ pub mod extensions { pub unsafe fn get_display_plane_supported_displays_khr( &self, physical_device: PhysicalDevice, - plane_index: uint32_t, - p_display_count: *mut uint32_t, + plane_index: u32, + p_display_count: *mut u32, p_displays: *mut DisplayKHR, ) -> Result { (self.get_display_plane_supported_displays_khr)( @@ -14523,7 +14523,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayModePropertiesKHR, ) -> Result { (self.get_display_mode_properties_khr)( @@ -14553,7 +14553,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, mode: DisplayModeKHR, - plane_index: uint32_t, + plane_index: u32, p_capabilities: *mut DisplayPlaneCapabilitiesKHR, ) -> Result { (self.get_display_plane_capabilities_khr)( @@ -14593,7 +14593,7 @@ pub mod extensions { create_shared_swapchains_khr: extern "system" fn( device: Device, - swapchain_count: uint32_t, + swapchain_count: u32, p_create_infos: *const SwapchainCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_swapchains: *mut SwapchainKHR, @@ -14634,7 +14634,7 @@ pub mod extensions { pub unsafe fn create_shared_swapchains_khr( &self, device: Device, - swapchain_count: uint32_t, + swapchain_count: u32, p_create_infos: *const SwapchainCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_swapchains: *mut SwapchainKHR, @@ -14666,7 +14666,7 @@ pub mod extensions { get_physical_device_xlib_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, dpy: *mut Display, visual_id: VisualID, ) -> Bool32, @@ -14726,7 +14726,7 @@ pub mod extensions { pub unsafe fn get_physical_device_xlib_presentation_support_khr( &self, physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, dpy: *mut Display, visual_id: VisualID, ) -> Bool32 { @@ -14752,7 +14752,7 @@ pub mod extensions { get_physical_device_xcb_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, connection: *mut xcb_connection_t, visual_id: xcb_visualid_t, ) -> Bool32, @@ -14812,7 +14812,7 @@ pub mod extensions { pub unsafe fn get_physical_device_xcb_presentation_support_khr( &self, physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, connection: *mut xcb_connection_t, visual_id: xcb_visualid_t, ) -> Bool32 { @@ -14839,7 +14839,7 @@ pub mod extensions { get_physical_device_wayland_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, display: *mut wl_display, ) -> Bool32, } @@ -14898,7 +14898,7 @@ pub mod extensions { pub unsafe fn get_physical_device_wayland_presentation_support_khr( &self, physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, display: *mut wl_display, ) -> Bool32 { (self.get_physical_device_wayland_presentation_support_khr)( @@ -14922,7 +14922,7 @@ pub mod extensions { get_physical_device_mir_presentation_support_khr: extern "system" fn( physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, connection: *mut MirConnection, ) -> Bool32, } @@ -14981,7 +14981,7 @@ pub mod extensions { pub unsafe fn get_physical_device_mir_presentation_support_khr( &self, physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, connection: *mut MirConnection, ) -> Bool32 { (self.get_physical_device_mir_presentation_support_khr)( @@ -15059,8 +15059,7 @@ pub mod extensions { p_surface: *mut SurfaceKHR, ) -> Result, get_physical_device_win32_presentation_support_khr: - extern "system" fn(physical_device: PhysicalDevice, queue_family_index: uint32_t) - -> Bool32, + extern "system" fn(physical_device: PhysicalDevice, queue_family_index: u32) -> Bool32, } unsafe impl Send for KhrWin32SurfaceFn {} unsafe impl Sync for KhrWin32SurfaceFn {} @@ -15117,7 +15116,7 @@ pub mod extensions { pub unsafe fn get_physical_device_win32_presentation_support_khr( &self, physical_device: PhysicalDevice, - queue_family_index: uint32_t, + queue_family_index: u32, ) -> Bool32 { (self.get_physical_device_win32_presentation_support_khr)( physical_device, @@ -15145,7 +15144,7 @@ pub mod extensions { ) -> Result, queue_signal_release_image_android: extern "system" fn( queue: Queue, - wait_semaphore_count: uint32_t, + wait_semaphore_count: u32, p_wait_semaphores: *const Semaphore, image: Image, p_native_fence_fd: *mut c_int, @@ -15225,7 +15224,7 @@ pub mod extensions { pub unsafe fn queue_signal_release_image_android( &self, queue: Queue, - wait_semaphore_count: uint32_t, + wait_semaphore_count: u32, p_wait_semaphores: *const Semaphore, image: Image, p_native_fence_fd: *mut c_int, @@ -15261,9 +15260,9 @@ pub mod extensions { instance: Instance, flags: DebugReportFlagsEXT, object_type: DebugReportObjectTypeEXT, - object: uint64_t, - location: size_t, - message_code: int32_t, + object: u64, + location: usize, + message_code: i32, p_layer_prefix: *const c_char, p_message: *const c_char, ) -> c_void, @@ -15347,9 +15346,9 @@ pub mod extensions { instance: Instance, flags: DebugReportFlagsEXT, object_type: DebugReportObjectTypeEXT, - object: uint64_t, - location: size_t, - message_code: int32_t, + object: u64, + location: usize, + message_code: i32, p_layer_prefix: *const c_char, p_message: *const c_char, ) -> c_void { @@ -15996,8 +15995,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void, cmd_draw_indexed_indirect_count_amd: extern "system" fn( command_buffer: CommandBuffer, @@ -16005,8 +16004,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void, } unsafe impl Send for AmdDrawIndirectCountFn {} @@ -16058,8 +16057,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void { (self.cmd_draw_indirect_count_amd)( command_buffer, @@ -16078,8 +16077,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void { (self.cmd_draw_indexed_indirect_count_amd)( command_buffer, @@ -16278,7 +16277,7 @@ pub mod extensions { pipeline: Pipeline, shader_stage: ShaderStageFlags, info_type: ShaderInfoTypeAMD, - p_info_size: *mut size_t, + p_info_size: *mut usize, p_info: *mut c_void, ) -> Result, } @@ -16320,7 +16319,7 @@ pub mod extensions { pipeline: Pipeline, shader_stage: ShaderStageFlags, info_type: ShaderInfoTypeAMD, - p_info_size: *mut size_t, + p_info_size: *mut usize, p_info: *mut c_void, ) -> Result { (self.get_shader_info_amd)( @@ -16823,7 +16822,7 @@ pub mod extensions { } } } - pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut uint32_t , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut uint32_t , ) -> Result , } + pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } unsafe impl Send for KhrDeviceGroupFn {} unsafe impl Sync for KhrDeviceGroupFn {} impl ::std::clone::Clone for KhrDeviceGroupFn { @@ -16911,7 +16910,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, surface: SurfaceKHR, - p_rect_count: *mut uint32_t, + p_rect_count: *mut u32, p_rects: *mut Rect2D, ) -> Result { (self.get_physical_device_present_rectangles_khr)( @@ -16925,7 +16924,7 @@ pub mod extensions { &self, device: Device, p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *mut uint32_t, + p_image_index: *mut u32, ) -> Result { (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) } @@ -17627,8 +17626,8 @@ pub mod extensions { command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, - set: uint32_t, - descriptor_write_count: uint32_t, + set: u32, + descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, ) -> c_void, cmd_push_descriptor_set_with_template_khr: @@ -17636,7 +17635,7 @@ pub mod extensions { command_buffer: CommandBuffer, descriptor_update_template: DescriptorUpdateTemplate, layout: PipelineLayout, - set: uint32_t, + set: u32, p_data: *const c_void, ) -> c_void, } @@ -17688,8 +17687,8 @@ pub mod extensions { command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, - set: uint32_t, - descriptor_write_count: uint32_t, + set: u32, + descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, ) -> c_void { (self.cmd_push_descriptor_set_khr)( @@ -17706,7 +17705,7 @@ pub mod extensions { command_buffer: CommandBuffer, descriptor_update_template: DescriptorUpdateTemplate, layout: PipelineLayout, - set: uint32_t, + set: u32, p_data: *const c_void, ) -> c_void { (self.cmd_push_descriptor_set_with_template_khr)( @@ -17824,7 +17823,7 @@ pub mod extensions { command_buffer: CommandBuffer, descriptor_update_template: DescriptorUpdateTemplate, layout: PipelineLayout, - set: uint32_t, + set: u32, p_data: *const c_void, ) -> c_void, } @@ -17866,7 +17865,7 @@ pub mod extensions { command_buffer: CommandBuffer, descriptor_update_template: DescriptorUpdateTemplate, layout: PipelineLayout, - set: uint32_t, + set: u32, p_data: *const c_void, ) -> c_void { (self.cmd_push_descriptor_set_with_template_khr)( @@ -17917,16 +17916,16 @@ pub mod extensions { extern "system" fn( device: Device, object_table: ObjectTableNVX, - object_count: uint32_t, + object_count: u32, pp_object_table_entries: *const *const ObjectTableEntryNVX, - p_object_indices: *const uint32_t, + p_object_indices: *const u32, ) -> Result, unregister_objects_nvx: extern "system" fn( device: Device, object_table: ObjectTableNVX, - object_count: uint32_t, + object_count: u32, p_object_entry_types: *const ObjectEntryTypeNVX, - p_object_indices: *const uint32_t, + p_object_indices: *const u32, ) -> Result, get_physical_device_generated_commands_properties_nvx: extern "system" fn( @@ -18109,9 +18108,9 @@ pub mod extensions { &self, device: Device, object_table: ObjectTableNVX, - object_count: uint32_t, + object_count: u32, pp_object_table_entries: *const *const ObjectTableEntryNVX, - p_object_indices: *const uint32_t, + p_object_indices: *const u32, ) -> Result { (self.register_objects_nvx)( device, @@ -18125,9 +18124,9 @@ pub mod extensions { &self, device: Device, object_table: ObjectTableNVX, - object_count: uint32_t, + object_count: u32, p_object_entry_types: *const ObjectEntryTypeNVX, - p_object_indices: *const uint32_t, + p_object_indices: *const u32, ) -> Result { (self.unregister_objects_nvx)( device, @@ -18198,8 +18197,8 @@ pub mod extensions { cmd_set_viewport_w_scaling_nv: extern "system" fn( command_buffer: CommandBuffer, - first_viewport: uint32_t, - viewport_count: uint32_t, + first_viewport: u32, + viewport_count: u32, p_viewport_w_scalings: *const ViewportWScalingNV, ) -> c_void, } @@ -18238,8 +18237,8 @@ pub mod extensions { pub unsafe fn cmd_set_viewport_w_scaling_nv( &self, command_buffer: CommandBuffer, - first_viewport: uint32_t, - viewport_count: uint32_t, + first_viewport: u32, + viewport_count: u32, p_viewport_w_scalings: *const ViewportWScalingNV, ) -> c_void { (self.cmd_set_viewport_w_scaling_nv)( @@ -18460,7 +18459,7 @@ pub mod extensions { device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, - p_counter_value: *mut uint64_t, + p_counter_value: *mut u64, ) -> Result, } unsafe impl Send for ExtDisplayControlFn {} @@ -18563,7 +18562,7 @@ pub mod extensions { device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, - p_counter_value: *mut uint64_t, + p_counter_value: *mut u64, ) -> Result { (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value) } @@ -18595,7 +18594,7 @@ pub mod extensions { extern "system" fn( device: Device, swapchain: SwapchainKHR, - p_presentation_timing_count: *mut uint32_t, + p_presentation_timing_count: *mut u32, p_presentation_timings: *mut PastPresentationTimingGOOGLE, ) -> Result, } @@ -18653,7 +18652,7 @@ pub mod extensions { &self, device: Device, swapchain: SwapchainKHR, - p_presentation_timing_count: *mut uint32_t, + p_presentation_timing_count: *mut u32, p_presentation_timings: *mut PastPresentationTimingGOOGLE, ) -> Result { (self.get_past_presentation_timing_google)( @@ -18798,8 +18797,8 @@ pub mod extensions { pub struct ExtDiscardRectanglesFn { cmd_set_discard_rectangle_ext: extern "system" fn( command_buffer: CommandBuffer, - first_discard_rectangle: uint32_t, - discard_rectangle_count: uint32_t, + first_discard_rectangle: u32, + discard_rectangle_count: u32, p_discard_rectangles: *const Rect2D, ) -> c_void, } @@ -18838,8 +18837,8 @@ pub mod extensions { pub unsafe fn cmd_set_discard_rectangle_ext( &self, command_buffer: CommandBuffer, - first_discard_rectangle: uint32_t, - discard_rectangle_count: uint32_t, + first_discard_rectangle: u32, + discard_rectangle_count: u32, p_discard_rectangles: *const Rect2D, ) -> c_void { (self.cmd_set_discard_rectangle_ext)( @@ -19043,7 +19042,7 @@ pub mod extensions { pub struct ExtHdrMetadataFn { set_hdr_metadata_ext: extern "system" fn( device: Device, - swapchain_count: uint32_t, + swapchain_count: u32, p_swapchains: *const SwapchainKHR, p_metadata: *const HdrMetadataEXT, ) -> c_void, @@ -19083,7 +19082,7 @@ pub mod extensions { pub unsafe fn set_hdr_metadata_ext( &self, device: Device, - swapchain_count: uint32_t, + swapchain_count: u32, p_swapchains: *const SwapchainKHR, p_metadata: *const HdrMetadataEXT, ) -> c_void { @@ -19532,7 +19531,7 @@ pub mod extensions { extern "system" fn( physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_format_count: *mut uint32_t, + p_surface_format_count: *mut u32, p_surface_formats: *mut SurfaceFormat2KHR, ) -> Result, } @@ -19596,7 +19595,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_format_count: *mut uint32_t, + p_surface_format_count: *mut u32, p_surface_formats: *mut SurfaceFormat2KHR, ) -> Result { (self.get_physical_device_surface_formats2_khr)( @@ -19645,20 +19644,20 @@ pub mod extensions { get_physical_device_display_properties2_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayProperties2KHR, ) -> Result, get_physical_device_display_plane_properties2_khr: extern "system" fn( physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayPlaneProperties2KHR, ) -> Result, get_display_mode_properties2_khr: extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayModeProperties2KHR, ) -> Result, get_display_plane_capabilities2_khr: @@ -19735,7 +19734,7 @@ pub mod extensions { pub unsafe fn get_physical_device_display_properties2_khr( &self, physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayProperties2KHR, ) -> Result { (self.get_physical_device_display_properties2_khr)( @@ -19747,7 +19746,7 @@ pub mod extensions { pub unsafe fn get_physical_device_display_plane_properties2_khr( &self, physical_device: PhysicalDevice, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayPlaneProperties2KHR, ) -> Result { (self.get_physical_device_display_plane_properties2_khr)( @@ -19760,7 +19759,7 @@ pub mod extensions { &self, physical_device: PhysicalDevice, display: DisplayKHR, - p_property_count: *mut uint32_t, + p_property_count: *mut u32, p_properties: *mut DisplayModeProperties2KHR, ) -> Result { (self.get_display_mode_properties2_khr)( @@ -21367,13 +21366,13 @@ pub mod extensions { merge_validation_caches_ext: extern "system" fn( device: Device, dst_cache: ValidationCacheEXT, - src_cache_count: uint32_t, + src_cache_count: u32, p_src_caches: *const ValidationCacheEXT, ) -> Result, get_validation_cache_data_ext: extern "system" fn( device: Device, validation_cache: ValidationCacheEXT, - p_data_size: *mut size_t, + p_data_size: *mut usize, p_data: *mut c_void, ) -> Result, } @@ -21465,7 +21464,7 @@ pub mod extensions { &self, device: Device, dst_cache: ValidationCacheEXT, - src_cache_count: uint32_t, + src_cache_count: u32, p_src_caches: *const ValidationCacheEXT, ) -> Result { (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) @@ -21474,7 +21473,7 @@ pub mod extensions { &self, device: Device, validation_cache: ValidationCacheEXT, - p_data_size: *mut size_t, + p_data_size: *mut usize, p_data: *mut c_void, ) -> Result { (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) @@ -21712,8 +21711,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void, cmd_draw_indexed_indirect_count_khr: extern "system" fn( command_buffer: CommandBuffer, @@ -21721,8 +21720,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void, } unsafe impl Send for KhrDrawIndirectCountFn {} @@ -21774,8 +21773,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void { (self.cmd_draw_indirect_count_khr)( command_buffer, @@ -21794,8 +21793,8 @@ pub mod extensions { offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, - max_draw_count: uint32_t, - stride: uint32_t, + max_draw_count: u32, + stride: u32, ) -> c_void { (self.cmd_draw_indexed_indirect_count_khr)( command_buffer, @@ -22069,7 +22068,7 @@ pub mod extensions { pipeline_stage: PipelineStageFlags, dst_buffer: Buffer, dst_offset: DeviceSize, - marker: uint32_t, + marker: u32, ) -> c_void, } unsafe impl Send for AmdBufferMarkerFn {} @@ -22110,7 +22109,7 @@ pub mod extensions { pipeline_stage: PipelineStageFlags, dst_buffer: Buffer, dst_offset: DeviceSize, - marker: uint32_t, + marker: u32, ) -> c_void { (self.cmd_write_buffer_marker_amd)( command_buffer, @@ -23412,11 +23411,26 @@ fn display_flags( } Ok(()) } -impl fmt::Display for ValidationCheckEXT { +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -23426,54 +23440,11 @@ impl fmt::Display for ValidationCheckEXT { } } } -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { +impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), _ => None, }; if let Some(x) = name { @@ -23483,122 +23454,33 @@ impl fmt::Display for ImageType { } } } -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for StencilFaceFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -23628,163 +23510,6 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for CommandBufferLevel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -23799,11 +23524,10 @@ impl fmt::Display for CommandBufferLevel { } } } -impl fmt::Display for RasterizationOrderAMD { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -23813,415 +23537,78 @@ impl fmt::Display for RasterizationOrderAMD { } } } -impl fmt::Display for DisplayEventTypeEXT { +impl fmt::Display for ImageAspectFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalSemaphoreFeatureFlags { +impl fmt::Display for SurfaceCounterFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for BlendOverlapEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24252,87 +23639,113 @@ impl fmt::Display for DisplayPowerStateEXT { } } } -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { +impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for StencilFaceFlags { +impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentLoadOp { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -24342,29 +23755,25 @@ impl fmt::Display for AttachmentLoadOp { } } } -impl fmt::Display for ExternalMemoryFeatureFlags { +impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for InternalAllocationType { +impl fmt::Display for SystemAllocationScope { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), _ => None, }; if let Some(x) = name { @@ -24374,11 +23783,13 @@ impl fmt::Display for InternalAllocationType { } } } -impl fmt::Display for IndexType { +impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -24388,69 +23799,12 @@ impl fmt::Display for IndexType { } } } -impl fmt::Display for AttachmentStoreOp { +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), _ => None, }; if let Some(x) = name { @@ -24473,16 +23827,242 @@ impl fmt::Display for MemoryPropertyFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ComponentSwizzle { +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), _ => None, }; if let Some(x) = name { @@ -24516,470 +24096,56 @@ impl fmt::Display for DynamicState { } } } -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DiscardRectangleModeEXT { +impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageCreateFlags { +impl fmt::Display for AttachmentDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25420,17 +24586,6 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DescriptorSetLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -25446,10 +24601,47 @@ impl fmt::Display for DescriptorSetLayoutCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), _ => None, }; if let Some(x) = name { @@ -25459,21 +24651,234 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for DependencyFlags { +impl fmt::Display for ImageUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageTiling { +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -25489,12 +24894,169 @@ impl fmt::Display for FormatFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryControlFlags { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25509,12 +25071,43 @@ impl fmt::Display for VertexInputRate { } } } -impl fmt::Display for Filter { +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), _ => None, }; if let Some(x) = name { @@ -25524,102 +25117,25 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { +impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), _ => None, }; if let Some(x) = name { @@ -25644,15 +25160,490 @@ impl fmt::Display for DescriptorPoolCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { +impl fmt::Display for ExternalMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", ), ]; display_flags(f, KNOWN, self.0) @@ -25925,130 +25916,6 @@ impl fmt::Display for Format { } } } -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -26063,40 +25930,39 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for SurfaceTransformFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", ), ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", ), ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", ), ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompareOp { +impl fmt::Display for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), _ => None, }; if let Some(x) = name { @@ -26106,24 +25972,157 @@ impl fmt::Display for CompareOp { } } } -impl fmt::Display for BufferUsageFlags { +impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", ), ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), ]; display_flags(f, KNOWN, self.0) } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index d8efec8..142d22a 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -123,7 +123,7 @@ pub fn handle_nondispatchable_macro() -> Tokens { ($name: ident, $ty: ident) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] - pub struct $name(uint64_t); + pub struct $name(u64); impl Handle for $name { const TYPE: ObjectType = ObjectType::$ty; @@ -595,6 +595,15 @@ impl ToTokens for vkxml::ReferenceType { } fn name_to_tokens(type_name: &str) -> Ident { let new_name = match type_name { + "uint8_t" => "u8", + "uint16_t" => "u16", + "uint32_t" => "u32", + "uint64_t" => "u64", + "int8_t" => "i8", + "int16_t" => "i16", + "int32_t" => "i32", + "int64_t" => "i64", + "size_t" => "usize", "int" => "c_int", "void" => "c_void", "char" => "c_char", From fd5d89f2b62f08584b408c499b8f80c6c63018b7 Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Tue, 28 Aug 2018 20:01:16 +0300 Subject: [PATCH 090/122] Remove libc usage --- ash/Cargo.toml | 1 - ash/src/allocator.rs | 73 ++++++++--------- ash/src/device.rs | 137 ++++++++++++++++---------------- ash/src/entry.rs | 5 +- ash/src/extensions/surface.rs | 2 +- ash/src/extensions/swapchain.rs | 8 +- ash/src/instance.rs | 3 +- ash/src/lib.rs | 1 - ash/src/util.rs | 5 +- ash/src/vk.rs | 6 +- examples/src/bin/texture.rs | 3 +- examples/src/lib.rs | 17 ++-- generator/src/lib.rs | 6 +- 13 files changed, 134 insertions(+), 133 deletions(-) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 205661e..f6a2802 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -12,7 +12,6 @@ documentation = "https://docs.rs/ash" [dependencies] shared_library = "0.1.5" lazy_static = "0.2.1" -libc = "0.2.26" [features] default = [] diff --git a/ash/src/allocator.rs b/ash/src/allocator.rs index d0dc1a3..3cd1569 100644 --- a/ash/src/allocator.rs +++ b/ash/src/allocator.rs @@ -1,30 +1,31 @@ #![allow(dead_code)] use vk; +use std::os::raw::c_void; use std::ptr; pub trait VkAllocation { unsafe extern "system" fn allocation( *mut (), - vk::size_t, - vk::size_t, + usize, + usize, vk::SystemAllocationScope, ) -> *mut (); unsafe extern "system" fn reallocation( - *mut vk::c_void, - *mut vk::c_void, - vk::size_t, - vk::size_t, + *mut c_void, + *mut c_void, + usize, + usize, vk::SystemAllocationScope, - ) -> *mut vk::c_void; - unsafe extern "system" fn free(*mut vk::c_void, *mut vk::c_void); + ) -> *mut c_void; + unsafe extern "system" fn free(*mut c_void, *mut c_void); unsafe extern "system" fn internal_allocation( - *mut vk::c_void, - vk::size_t, + *mut c_void, + usize, vk::InternalAllocationType, vk::SystemAllocationScope, ); unsafe extern "system" fn internal_free( - *mut vk::c_void, - vk::size_t, + *mut c_void, + usize, vk::InternalAllocationType, vk::SystemAllocationScope, ); @@ -47,33 +48,33 @@ pub struct TestAlloc; impl VkAllocation for TestAlloc { unsafe extern "system" fn allocation( _: *mut (), - _: vk::size_t, - _: vk::size_t, + _: usize, + _: usize, _: vk::SystemAllocationScope, ) -> *mut () { ptr::null_mut() } unsafe extern "system" fn reallocation( - _: *mut vk::c_void, - _: *mut vk::c_void, - _: vk::size_t, - _: vk::size_t, + _: *mut c_void, + _: *mut c_void, + _: usize, + _: usize, _: vk::SystemAllocationScope, - ) -> *mut vk::c_void { + ) -> *mut c_void { ptr::null_mut() } - unsafe extern "system" fn free(_: *mut vk::c_void, _: *mut vk::c_void) {} + unsafe extern "system" fn free(_: *mut c_void, _: *mut c_void) {} unsafe extern "system" fn internal_allocation( - _: *mut vk::c_void, - _: vk::size_t, + _: *mut c_void, + _: usize, _: vk::InternalAllocationType, _: vk::SystemAllocationScope, ) { } unsafe extern "system" fn internal_free( - _: *mut vk::c_void, - _: vk::size_t, + _: *mut c_void, + _: usize, _: vk::InternalAllocationType, _: vk::SystemAllocationScope, ) { @@ -82,33 +83,33 @@ impl VkAllocation for TestAlloc { impl VkAllocation for DefaultAllocatorCallback { unsafe extern "system" fn allocation( _: *mut (), - _: vk::size_t, - _: vk::size_t, + _: usize, + _: usize, _: vk::SystemAllocationScope, ) -> *mut () { ptr::null_mut() } unsafe extern "system" fn reallocation( - _: *mut vk::c_void, - _: *mut vk::c_void, - _: vk::size_t, - _: vk::size_t, + _: *mut c_void, + _: *mut c_void, + _: usize, + _: usize, _: vk::SystemAllocationScope, - ) -> *mut vk::c_void { + ) -> *mut c_void { ptr::null_mut() } - unsafe extern "system" fn free(_: *mut vk::c_void, _: *mut vk::c_void) {} + unsafe extern "system" fn free(_: *mut c_void, _: *mut c_void) {} unsafe extern "system" fn internal_allocation( - _: *mut vk::c_void, - _: vk::size_t, + _: *mut c_void, + _: usize, _: vk::InternalAllocationType, _: vk::SystemAllocationScope, ) { } unsafe extern "system" fn internal_free( - _: *mut vk::c_void, - _: vk::size_t, + _: *mut c_void, + _: usize, _: vk::InternalAllocationType, _: vk::SystemAllocationScope, ) { diff --git a/ash/src/device.rs b/ash/src/device.rs index e562b0d..b6a2991 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -1,6 +1,7 @@ #![allow(dead_code)] use prelude::*; use std::mem; +use std::os::raw::c_void; use std::ptr; use version::{FunctionPointers, V1_0, V1_1}; use vk; @@ -36,9 +37,9 @@ pub trait DeviceV1_1: DeviceV1_0 { unsafe fn get_device_group_peer_memory_features( &self, - heap_index: vk::uint32_t, - local_device_index: vk::uint32_t, - remote_device_index: vk::uint32_t, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, ) -> vk::PeerMemoryFeatureFlags { let mut peer_memory_features = mem::uninitialized(); self.fp_v1_1().get_device_group_peer_memory_features( @@ -54,7 +55,7 @@ pub trait DeviceV1_1: DeviceV1_0 { unsafe fn cmd_set_device_mask( &self, command_buffer: vk::CommandBuffer, - device_mask: vk::uint32_t, + device_mask: u32, ) { self.fp_v1_1() .cmd_set_device_mask(command_buffer, device_mask); @@ -63,12 +64,12 @@ pub trait DeviceV1_1: DeviceV1_0 { unsafe fn cmd_dispatch_base( &self, command_buffer: vk::CommandBuffer, - base_group_x: vk::uint32_t, - base_group_y: vk::uint32_t, - base_group_z: vk::uint32_t, - group_count_x: vk::uint32_t, - group_count_y: vk::uint32_t, - group_count_z: vk::uint32_t, + base_group_x: u32, + base_group_y: u32, + base_group_z: u32, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, ) { self.fp_v1_1().cmd_dispatch_base( command_buffer, @@ -202,7 +203,7 @@ pub trait DeviceV1_1: DeviceV1_0 { &self, descriptor_set: vk::DescriptorSet, descriptor_update_template: vk::DescriptorUpdateTemplate, - data: *const vk::c_void, + data: *const c_void, ) { self.fp_v1_1().update_descriptor_set_with_template( self.handle(), @@ -261,7 +262,7 @@ pub trait DeviceV1_0 { self.fp_v1_0().free_command_buffers( self.handle(), command_pool, - command_buffers.len() as vk::uint32_t, + command_buffers.len() as u32, command_buffers.as_ptr(), ); } @@ -521,7 +522,7 @@ pub trait DeviceV1_0 { buffer: vk::Buffer, offset: vk::DeviceSize, size: vk::DeviceSize, - data: vk::uint32_t, + data: u32, ) { self.fp_v1_0() .cmd_fill_buffer(command_buffer, buffer, offset, size, data); @@ -572,7 +573,7 @@ pub trait DeviceV1_0 { src_image, src_image_layout, dst_buffer, - regions.len() as vk::uint32_t, + regions.len() as u32, regions.as_ptr(), ); } @@ -722,7 +723,7 @@ pub trait DeviceV1_0 { unsafe fn reset_fences(&self, fences: &[vk::Fence]) -> VkResult<()> { let err_code = self.fp_v1_0().reset_fences( self.handle(), - fences.len() as vk::uint32_t, + fences.len() as u32, fences.as_ptr(), ); match err_code { @@ -755,7 +756,7 @@ pub trait DeviceV1_0 { image, image_layout, clear_color_value, - ranges.len() as vk::uint32_t, + ranges.len() as u32, ranges.as_ptr(), ); } @@ -773,7 +774,7 @@ pub trait DeviceV1_0 { image, image_layout, clear_depth_stencil_value, - ranges.len() as vk::uint32_t, + ranges.len() as u32, ranges.as_ptr(), ); } @@ -786,9 +787,9 @@ pub trait DeviceV1_0 { ) { self.fp_v1_0().cmd_clear_attachments( command_buffer, - attachments.len() as vk::uint32_t, + attachments.len() as u32, attachments.as_ptr(), - rects.len() as vk::uint32_t, + rects.len() as u32, rects.as_ptr(), ); } @@ -796,11 +797,11 @@ pub trait DeviceV1_0 { unsafe fn cmd_draw_indexed( &self, command_buffer: vk::CommandBuffer, - index_count: vk::uint32_t, - instance_count: vk::uint32_t, - first_index: vk::uint32_t, - vertex_offset: vk::int32_t, - first_instance: vk::uint32_t, + index_count: u32, + instance_count: u32, + first_index: u32, + vertex_offset: i32, + first_instance: u32, ) { self.fp_v1_0().cmd_draw_indexed( command_buffer, @@ -817,8 +818,8 @@ pub trait DeviceV1_0 { command_buffer: vk::CommandBuffer, buffer: vk::Buffer, offset: vk::DeviceSize, - draw_count: vk::uint32_t, - stride: vk::uint32_t, + draw_count: u32, + stride: u32, ) { self.fp_v1_0().cmd_draw_indexed_indirect( command_buffer, @@ -836,7 +837,7 @@ pub trait DeviceV1_0 { ) { self.fp_v1_0().cmd_execute_commands( primary_command_buffer, - secondary_command_buffers.len() as vk::uint32_t, + secondary_command_buffers.len() as u32, secondary_command_buffers.as_ptr(), ); } @@ -846,18 +847,18 @@ pub trait DeviceV1_0 { command_buffer: vk::CommandBuffer, pipeline_bind_point: vk::PipelineBindPoint, layout: vk::PipelineLayout, - first_set: vk::uint32_t, + first_set: u32, descriptor_sets: &[vk::DescriptorSet], - dynamic_offsets: &[vk::uint32_t], + dynamic_offsets: &[u32], ) { self.fp_v1_0().cmd_bind_descriptor_sets( command_buffer, pipeline_bind_point, layout, first_set, - descriptor_sets.len() as vk::uint32_t, + descriptor_sets.len() as u32, descriptor_sets.as_ptr(), - dynamic_offsets.len() as vk::uint32_t, + dynamic_offsets.len() as u32, dynamic_offsets.as_ptr(), ); } @@ -866,8 +867,8 @@ pub trait DeviceV1_0 { &self, command_buffer: vk::CommandBuffer, query_pool: vk::QueryPool, - first_query: vk::uint32_t, - query_count: vk::uint32_t, + first_query: u32, + query_count: u32, dst_buffer: vk::Buffer, dst_offset: vk::DeviceSize, stride: vk::DeviceSize, @@ -890,7 +891,7 @@ pub trait DeviceV1_0 { command_buffer: vk::CommandBuffer, layout: vk::PipelineLayout, stage_flags: vk::ShaderStageFlags, - offset: vk::uint32_t, + offset: u32, constants: &[u8], ) { self.fp_v1_0().cmd_push_constants( @@ -934,13 +935,13 @@ pub trait DeviceV1_0 { unsafe fn cmd_set_scissor( &self, command_buffer: vk::CommandBuffer, - first_scissor: vk::uint32_t, + first_scissor: u32, scissors: &[vk::Rect2D], ) { self.fp_v1_0().cmd_set_scissor( command_buffer, first_scissor, - scissors.len() as vk::uint32_t, + scissors.len() as u32, scissors.as_ptr(), ); } @@ -953,7 +954,7 @@ pub trait DeviceV1_0 { unsafe fn cmd_bind_vertex_buffers( &self, command_buffer: vk::CommandBuffer, - first_binding: vk::uint32_t, + first_binding: u32, buffers: &[vk::Buffer], offsets: &[vk::DeviceSize], ) { @@ -961,7 +962,7 @@ pub trait DeviceV1_0 { self.fp_v1_0().cmd_bind_vertex_buffers( command_buffer, first_binding, - buffers.len() as vk::uint32_t, + buffers.len() as u32, buffers.as_ptr(), offsets.as_ptr(), ); @@ -974,10 +975,10 @@ pub trait DeviceV1_0 { unsafe fn cmd_draw( &self, command_buffer: vk::CommandBuffer, - vertex_count: vk::uint32_t, - instance_count: vk::uint32_t, - first_vertex: vk::uint32_t, - first_instance: vk::uint32_t, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, ) { self.fp_v1_0().cmd_draw( command_buffer, @@ -993,8 +994,8 @@ pub trait DeviceV1_0 { command_buffer: vk::CommandBuffer, buffer: vk::Buffer, offset: vk::DeviceSize, - draw_count: vk::uint32_t, - stride: vk::uint32_t, + draw_count: u32, + stride: u32, ) { self.fp_v1_0() .cmd_draw_indirect(command_buffer, buffer, offset, draw_count, stride); @@ -1003,9 +1004,9 @@ pub trait DeviceV1_0 { unsafe fn cmd_dispatch( &self, command_buffer: vk::CommandBuffer, - group_count_x: vk::uint32_t, - group_count_y: vk::uint32_t, - group_count_z: vk::uint32_t, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, ) { self.fp_v1_0() .cmd_dispatch(command_buffer, group_count_x, group_count_y, group_count_z); @@ -1024,13 +1025,13 @@ pub trait DeviceV1_0 { unsafe fn cmd_set_viewport( &self, command_buffer: vk::CommandBuffer, - first_viewport: vk::uint32_t, + first_viewport: u32, viewports: &[vk::Viewport], ) { self.fp_v1_0().cmd_set_viewport( command_buffer, first_viewport, - viewports.len() as vk::uint32_t, + viewports.len() as u32, viewports.as_ptr(), ); } @@ -1098,8 +1099,8 @@ pub trait DeviceV1_0 { unsafe fn get_query_pool_results( &self, query_pool: vk::QueryPool, - first_query: vk::uint32_t, - query_count: vk::uint32_t, + first_query: u32, + query_count: u32, data: &mut [T], flags: vk::QueryResultFlags, ) -> VkResult<()> { @@ -1201,7 +1202,7 @@ pub trait DeviceV1_0 { let err_code = self.fp_v1_0().create_graphics_pipelines( self.handle(), pipeline_cache, - create_infos.len() as vk::uint32_t, + create_infos.len() as u32, create_infos.as_ptr(), allocation_callbacks.as_raw_ptr(), pipelines.as_mut_ptr(), @@ -1223,7 +1224,7 @@ pub trait DeviceV1_0 { let err_code = self.fp_v1_0().create_compute_pipelines( self.handle(), pipeline_cache, - create_infos.len() as vk::uint32_t, + create_infos.len() as u32, create_infos.as_ptr(), allocation_callbacks.as_raw_ptr(), pipelines.as_mut_ptr(), @@ -1296,8 +1297,8 @@ pub trait DeviceV1_0 { offset: vk::DeviceSize, size: vk::DeviceSize, flags: vk::MemoryMapFlags, - ) -> VkResult<*mut vk::c_void> { - let mut data: *mut vk::c_void = mem::uninitialized(); + ) -> VkResult<*mut c_void> { + let mut data: *mut c_void = mem::uninitialized(); let err_code = self.fp_v1_0() .map_memory(self.handle(), memory, offset, size, flags, &mut data); @@ -1317,7 +1318,7 @@ pub trait DeviceV1_0 { ) -> VkResult<()> { let err_code = self.fp_v1_0().invalidate_mapped_memory_ranges( self.handle(), - ranges.len() as vk::uint32_t, + ranges.len() as u32, ranges.as_ptr(), ); match err_code { @@ -1329,7 +1330,7 @@ pub trait DeviceV1_0 { unsafe fn flush_mapped_memory_ranges(&self, ranges: &[vk::MappedMemoryRange]) -> VkResult<()> { let err_code = self.fp_v1_0().flush_mapped_memory_ranges( self.handle(), - ranges.len() as vk::uint32_t, + ranges.len() as u32, ranges.as_ptr(), ); match err_code { @@ -1358,8 +1359,8 @@ pub trait DeviceV1_0 { unsafe fn get_device_queue( &self, - queue_family_index: vk::uint32_t, - queue_index: vk::uint32_t, + queue_family_index: u32, + queue_index: u32, ) -> vk::Queue { let mut queue = mem::uninitialized(); self.fp_v1_0() @@ -1382,11 +1383,11 @@ pub trait DeviceV1_0 { src_stage_mask, dst_stage_mask, dependency_flags, - memory_barriers.len() as vk::uint32_t, + memory_barriers.len() as u32, memory_barriers.as_ptr(), - buffer_memory_barriers.len() as vk::uint32_t, + buffer_memory_barriers.len() as u32, buffer_memory_barriers.as_ptr(), - image_memory_barriers.len() as vk::uint32_t, + image_memory_barriers.len() as u32, image_memory_barriers.as_ptr(), ); } @@ -1435,13 +1436,13 @@ pub trait DeviceV1_0 { &self, fences: &[vk::Fence], wait_all: bool, - timeout: vk::uint64_t, + timeout: u64, ) -> VkResult<()> { let err_code = self.fp_v1_0().wait_for_fences( self.handle(), - fences.len() as vk::uint32_t, + fences.len() as u32, fences.as_ptr(), - wait_all as vk::uint32_t, + wait_all as u32, timeout, ); match err_code { @@ -1474,7 +1475,7 @@ pub trait DeviceV1_0 { ) -> VkResult<()> { let err_code = self.fp_v1_0().queue_submit( queue, - submits.len() as vk::uint32_t, + submits.len() as u32, submits.as_ptr(), fence, ); @@ -1536,13 +1537,13 @@ pub trait DeviceV1_0 { &self, create_info: &vk::CommandBufferAllocateInfo, ) -> VkResult> { - let mut buffers = Vec::with_capacity(create_info.command_buffer_count as vk::size_t); + let mut buffers = Vec::with_capacity(create_info.command_buffer_count as usize); let err_code = self.fp_v1_0().allocate_command_buffers( self.handle(), create_info, buffers.as_mut_ptr(), ); - buffers.set_len(create_info.command_buffer_count as vk::size_t); + buffers.set_len(create_info.command_buffer_count as usize); match err_code { vk::Result::SUCCESS => Ok(buffers), _ => Err(err_code), diff --git a/ash/src/entry.rs b/ash/src/entry.rs index 3552ab6..7fdefbe 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -4,6 +4,7 @@ use shared_library::dynamic_library::DynamicLibrary; use std::error::Error; use std::fmt; use std::mem; +use std::os::raw::c_char; use std::path::Path; use std::ptr; use version::{EntryLoader, FunctionPointers, InstanceLoader, V1_0, V1_1}; @@ -134,7 +135,7 @@ pub trait EntryV1_0 { fn get_instance_proc_addr( &self, instance: vk::Instance, - p_name: *const vk::c_char, + p_name: *const c_char, ) -> vk::PFN_vkVoidFunction { unsafe { self.static_fn().get_instance_proc_addr(instance, p_name) } } @@ -191,7 +192,7 @@ impl Entry { pub trait EntryV1_1: EntryV1_0 { fn fp_v1_1(&self) -> &vk::EntryFnV1_1; - fn enumerate_instance_version(&self) -> VkResult { + fn enumerate_instance_version(&self) -> VkResult { unsafe { let mut api_version = 0; let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version); diff --git a/ash/src/extensions/surface.rs b/ash/src/extensions/surface.rs index 22e8b23..ce8cfd2 100644 --- a/ash/src/extensions/surface.rs +++ b/ash/src/extensions/surface.rs @@ -34,7 +34,7 @@ impl Surface { pub fn get_physical_device_surface_support_khr( &self, physical_device: vk::PhysicalDevice, - queue_index: vk::uint32_t, + queue_index: u32, surface: vk::SurfaceKHR, ) -> bool { unsafe { diff --git a/ash/src/extensions/swapchain.rs b/ash/src/extensions/swapchain.rs index 2488d6e..0a99708 100644 --- a/ash/src/extensions/swapchain.rs +++ b/ash/src/extensions/swapchain.rs @@ -46,10 +46,10 @@ impl Swapchain { pub unsafe fn acquire_next_image_khr( &self, swapchain: vk::SwapchainKHR, - timeout: vk::uint64_t, + timeout: u64, semaphore: vk::Semaphore, fence: vk::Fence, - ) -> VkResult { + ) -> VkResult { let mut index = mem::uninitialized(); let err_code = self.swapchain_fn.acquire_next_image_khr( self.handle, @@ -108,14 +108,14 @@ impl Swapchain { ptr::null_mut(), ); - let mut v = Vec::with_capacity(count as vk::size_t); + let mut v = Vec::with_capacity(count as usize); let err_code = self.swapchain_fn.get_swapchain_images_khr( self.handle, swapchain, &mut count, v.as_mut_ptr(), ); - v.set_len(count as vk::size_t); + v.set_len(count as usize); match err_code { vk::Result::SUCCESS => Ok(v), _ => Err(err_code), diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 50c459a..f799fe9 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -4,6 +4,7 @@ use prelude::*; use std::error::Error; use std::fmt; use std::mem; +use std::os::raw::c_char; use std::ptr; use version::DeviceLoader; use version::{FunctionPointers, V1_0, V1_1}; @@ -290,7 +291,7 @@ pub trait InstanceV1_0 { fn get_device_proc_addr( &self, device: vk::Device, - p_name: *const vk::c_char, + p_name: *const c_char, ) -> vk::PFN_vkVoidFunction { unsafe { self.fp_v1_0().get_device_proc_addr(device, p_name) } } diff --git a/ash/src/lib.rs b/ash/src/lib.rs index 7e75782..bb9b464 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -1,6 +1,5 @@ #[macro_use] extern crate lazy_static; -extern crate libc; extern crate shared_library; pub use device::Device; pub use entry::{Entry, InstanceError, LoadingError}; diff --git a/ash/src/util.rs b/ash/src/util.rs index 917333a..173d2da 100644 --- a/ash/src/util.rs +++ b/ash/src/util.rs @@ -1,6 +1,7 @@ use std::iter::Iterator; use std::marker::PhantomData; use std::mem::size_of; +use std::os::raw::c_void; use vk; /// `Align` handles dynamic alignment. The is useful for dynamic uniform buffers where @@ -12,7 +13,7 @@ use vk; /// an additional allocation and with the correct alignment. #[derive(Debug, Clone)] pub struct Align { - ptr: *mut vk::c_void, + ptr: *mut c_void, elem_size: vk::DeviceSize, size: vk::DeviceSize, _m: PhantomData, @@ -46,7 +47,7 @@ fn calc_padding(adr: vk::DeviceSize, align: vk::DeviceSize) -> vk::DeviceSize { impl Align { pub unsafe fn new( - ptr: *mut vk::c_void, + ptr: *mut c_void, alignment: vk::DeviceSize, size: vk::DeviceSize, ) -> Self { diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 5c548a2..d2c8903 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -2,9 +2,8 @@ pub use self::bitflags::*; #[doc(hidden)] pub use self::extensions::*; -#[doc(hidden)] -pub use libc::*; use std::fmt; +use std::os::raw::*; pub trait Handle { const TYPE: ObjectType; fn as_raw(self) -> u64; @@ -54,8 +53,7 @@ pub type wl_display = *const c_void; pub type wl_surface = *const c_void; pub type HANDLE = *mut c_void; pub type DWORD = c_ulong; -pub type WCHAR = wchar_t; -pub type LPCWSTR = *const WCHAR; +pub type LPCWSTR = *const u16; #[allow(non_camel_case_types)] pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index e089bc0..d87df89 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -8,6 +8,7 @@ use std::ffi::CString; use std::fs::File; use std::io::Read; use std::mem::{self, align_of}; +use std::os::raw::c_void; use std::path::Path; use std::ptr; @@ -152,7 +153,7 @@ fn main() { .device .allocate_memory(&index_allocate_info, None) .unwrap(); - let index_ptr: *mut vk::c_void = base + let index_ptr: *mut c_void = base .device .map_memory( index_buffer_memory, diff --git a/examples/src/lib.rs b/examples/src/lib.rs index a197f4c..5d0db7f 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -18,6 +18,7 @@ use std::cell::RefCell; use std::default::Default; use std::ffi::{CStr, CString}; use std::ops::Drop; +use std::os::raw::{c_char, c_void}; use std::ptr; // Simple offset_of macro akin to C++ offsetof @@ -121,13 +122,13 @@ unsafe fn create_surface( use winit::os::windows::WindowExt; let hwnd = window.get_hwnd() as HWND; - let hinstance = GetWindow(hwnd, 0) as *const vk::c_void; + let hinstance = GetWindow(hwnd, 0) as *const c_void; let win32_create_info = vk::Win32SurfaceCreateInfoKHR { s_type: vk::StructureType::WIN32_SURFACE_CREATE_INFO_KHR, p_next: ptr::null(), flags: Default::default(), hinstance: hinstance, - hwnd: hwnd as *const vk::c_void, + hwnd: hwnd as *const c_void, }; let win32_surface_loader = Win32Surface::new(entry, instance).expect("Unable to load win32 surface"); @@ -155,12 +156,12 @@ fn extension_names() -> Vec<*const i8> { unsafe extern "system" fn vulkan_debug_callback( _: vk::DebugReportFlagsEXT, _: vk::DebugReportObjectTypeEXT, - _: vk::uint64_t, - _: vk::size_t, - _: vk::int32_t, - _: *const vk::c_char, - p_message: *const vk::c_char, - _: *mut vk::c_void, + _: u64, + _: usize, + _: i32, + _: *const c_char, + p_message: *const c_char, + _: *mut c_void, ) -> u32 { println!("{:?}", CStr::from_ptr(p_message)); 1 diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 142d22a..955d364 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -349,8 +349,7 @@ pub fn platform_specific_types() -> Tokens { pub type wl_surface = *const c_void; pub type HANDLE = *mut c_void; pub type DWORD = c_ulong; - pub type WCHAR = wchar_t; - pub type LPCWSTR = *const WCHAR; + pub type LPCWSTR = *const u16; // FIXME: Platform specific types that should come from a library // typedefs are only here so that the code compiles for now @@ -1687,8 +1686,7 @@ pub fn write_source_code(path: &Path) { let platform_specific_types = platform_specific_types(); let source_code = quote!{ use std::fmt; - #[doc(hidden)] - pub use libc::*; + use std::os::raw::*; #[doc(hidden)] pub use self::extensions::*; #[doc(hidden)] From 72a8c9a341bc6037425ebda94e5b59f69edd0e6b Mon Sep 17 00:00:00 2001 From: Gabriel Majeri Date: Wed, 29 Aug 2018 14:44:55 +0300 Subject: [PATCH 091/122] Fix Windows surface creation --- examples/Cargo.toml | 2 +- examples/src/lib.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/Cargo.toml b/examples/Cargo.toml index 8873048..786954d 100644 --- a/examples/Cargo.toml +++ b/examples/Cargo.toml @@ -9,4 +9,4 @@ image = "0.10.4" ash = { path = "../ash" } [target.'cfg(windows)'.dependencies] -winapi = { version = "0.3.4", features = ["windef", "winuser"] } +winapi = { version = "0.3.4", features = ["windef", "libloaderapi"] } diff --git a/examples/src/lib.rs b/examples/src/lib.rs index f60dae7..0209cb2 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -118,11 +118,11 @@ unsafe fn create_surface( window: &winit::Window, ) -> Result { use winapi::shared::windef::HWND; - use winapi::um::winuser::GetWindow; + use winapi::um::libloaderapi::GetModuleHandleW; use winit::os::windows::WindowExt; let hwnd = window.get_hwnd() as HWND; - let hinstance = GetWindow(hwnd, 0) as *const c_void; + let hinstance = GetModuleHandleW(ptr::null()) as *const c_void; let win32_create_info = vk::Win32SurfaceCreateInfoKHR { s_type: vk::StructureType::WIN32_SURFACE_CREATE_INFO_KHR, p_next: ptr::null(), From 0446b598734e573b0f7f61775320e3048e31f81f Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 16 Sep 2018 11:59:55 -0700 Subject: [PATCH 092/122] More consistent names in flags API Improves consistency with other newtypes and with bitflags. --- ash/src/vk.rs | 3852 ++++++++++++++++++++---------------------- examples/src/lib.rs | 4 +- generator/src/lib.rs | 21 +- 3 files changed, 1885 insertions(+), 1992 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index d2c8903..6fa619c 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -11,25 +11,25 @@ pub trait Handle { } #[macro_export] macro_rules! vk_make_version { - ($major:expr, $minor:expr, $patch:expr) => { + ( $ major : expr , $ minor : expr , $ patch : expr ) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ($major:expr) => { + ( $ major : expr ) => { ($major as u32) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ($minor:expr) => { + ( $ minor : expr ) => { (($minor as u32) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ($minor:expr) => { + ( $ minor : expr ) => { ($minor as u32) & 0xfff }; } @@ -59,7 +59,7 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ($name:ident, $all:expr, $flag_type:ty) => { + ( $ name : ident , $ all : expr , $ flag_type : ty ) => { impl Default for $name { fn default() -> $name { $name(0) @@ -83,22 +83,14 @@ macro_rules! vk_bitflags_wrapped { $name($all) } #[inline] - pub fn flags(self) -> $flag_type { + pub fn from_raw(x: $flag_type) -> Self { + $name(x) + } + #[inline] + pub fn as_raw(self) -> $flag_type { self.0 } #[inline] - pub fn from_flags(flags: $flag_type) -> Option<$name> { - if flags & !$all == 0 { - Some($name(flags)) - } else { - None - } - } - #[inline] - pub fn from_flags_truncate(flags: $flag_type) -> $name { - $name(flags & $all) - } - #[inline] pub fn is_empty(self) -> bool { self == $name::empty() } @@ -110,9 +102,9 @@ macro_rules! vk_bitflags_wrapped { pub fn intersects(self, other: $name) -> bool { self & other != $name::empty() } - #[doc = r" Returns true of `other` is a subset of `self`"] + #[doc = r" Returns whether `other` is a subset of `self`"] #[inline] - pub fn subset(self, other: $name) -> bool { + pub fn contains(self, other: $name) -> bool { self & other == other } } @@ -178,7 +170,7 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(u64); @@ -215,7 +207,7 @@ macro_rules! handle_nondispatchable { }; } macro_rules! define_handle { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] #[derive(Clone, Copy, Debug)] pub struct $name(*mut u8); @@ -462,18 +454,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: self - .get_physical_device_image_format_properties, + get_physical_device_image_format_properties: + self.get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: self - .get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: + self.get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: self - .get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: + self.get_physical_device_sparse_image_format_properties, } } } @@ -3955,19 +3947,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: self - .get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: self - .get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: + self.get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: + self.get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: self - .get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: self - .get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: self - .get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: self - .get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: + self.get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: + self.get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: + self.get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: + self.get_physical_device_external_semaphore_properties, } } } @@ -5044,11 +5036,9 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }) - .field("pipeline_cache_uuid", &unsafe { + }).field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }) - .field("limits", &self.limits) + }).field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5079,8 +5069,7 @@ impl ::std::fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .finish() } } @@ -5105,13 +5094,11 @@ impl ::std::fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for LayerProperties { @@ -5168,8 +5155,7 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ) - .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5285,12 +5271,10 @@ impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }) - .field("memory_heap_count", &self.memory_heap_count) + }).field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5820,12 +5804,10 @@ impl ::std::fmt::Debug for ImageBlit { .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }) - .field("dst_subresource", &self.dst_subresource) + }).field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ImageBlit { @@ -6239,8 +6221,7 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6944,202 +6925,155 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ) - .field( + ).field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ) - .field("buffer_image_granularity", &self.buffer_image_granularity) + ).field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ) - .field( + ).field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ) - .field( + ).field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ) - .field( + ).field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ) - .field("max_per_stage_resources", &self.max_per_stage_resources) + ).field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ) - .field( + ).field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ) - .field( + ).field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ) - .field( + ).field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ) - .field( + ).field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ) - .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ) - .field( + ).field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ) - .field( + ).field( "max_vertex_output_components", &self.max_vertex_output_components, - ) - .field( + ).field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ) - .field( + ).field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ) - .field( + ).field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ) - .field( + ).field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ) - .field( + ).field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ) - .field( + ).field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ) - .field( + ).field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ) - .field( + ).field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ) - .field( + ).field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ) - .field( + ).field( "max_geometry_input_components", &self.max_geometry_input_components, - ) - .field( + ).field( "max_geometry_output_components", &self.max_geometry_output_components, - ) - .field( + ).field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ) - .field( + ).field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ) - .field( + ).field( "max_fragment_input_components", &self.max_fragment_input_components, - ) - .field( + ).field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ) - .field( + ).field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ) - .field( + ).field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ) - .field( + ).field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ) - .field("max_compute_work_group_count", &unsafe { + ).field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }) - .field( + }).field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ) - .field("max_compute_work_group_size", &unsafe { + ).field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }) - .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ) - .field("max_draw_indirect_count", &self.max_draw_indirect_count) + ).field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }) - .field("viewport_bounds_range", &unsafe { + }).field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }) - .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ) - .field( + ).field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ) - .field( + ).field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ) - .field("min_texel_offset", &self.min_texel_offset) + ).field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7148,79 +7082,63 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ) - .field("max_framebuffer_width", &self.max_framebuffer_width) + ).field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ) - .field( + ).field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ) - .field( + ).field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ) - .field( + ).field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ) - .field("max_color_attachments", &self.max_color_attachments) + ).field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ) - .field( + ).field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ) - .field( + ).field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ) - .field( + ).field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ) - .field( + ).field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ) - .field("max_sample_mask_words", &self.max_sample_mask_words) + ).field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ) - .field("timestamp_period", &self.timestamp_period) + ).field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ) - .field("discrete_queue_priorities", &self.discrete_queue_priorities) + ).field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }) - .field("line_width_range", &unsafe { + }).field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }) - .field("point_size_granularity", &self.point_size_granularity) + }).field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ) - .field( + ).field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ) - .field("non_coherent_atom_size", &self.non_coherent_atom_size) + ).field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7930,8 +7848,7 @@ impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8631,14 +8548,11 @@ impl ::std::fmt::Debug for PhysicalDeviceIDProperties { .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }) - .field("driver_uuid", &unsafe { + }).field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }) - .field("device_luid", &unsafe { + }).field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }) - .field("device_node_mask", &self.device_node_mask) + }).field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -9369,8 +9283,7 @@ impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }) - .field("subset_allocation", &self.subset_allocation) + }).field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9578,8 +9491,7 @@ impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }) - .field("modes", &self.modes) + }).field("modes", &self.modes) .finish() } } @@ -10673,21 +10585,17 @@ impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ) - .field( + ).field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ) - .field("sample_location_coordinate_range", &unsafe { + ).field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }) - .field( + }).field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ) - .field("variable_sample_locations", &self.variable_sample_locations) + ).field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -10979,8 +10887,7 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -11072,8 +10979,7 @@ impl ::std::fmt::Debug for DebugUtilsLabelEXT { .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -13923,12 +13829,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: self - .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: + self.get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: self - .get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: + self.get_physical_device_surface_present_modes_khr, } } } @@ -14077,12 +13983,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -14389,10 +14295,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: self - .get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: self - .get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: + self.get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: + self.get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14675,8 +14581,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: self - .get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: + self.get_physical_device_xlib_presentation_support_khr, } } } @@ -14761,8 +14667,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: self - .get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: + self.get_physical_device_xcb_presentation_support_khr, } } } @@ -14847,8 +14753,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: self - .get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: + self.get_physical_device_wayland_presentation_support_khr, } } } @@ -14930,8 +14836,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: self - .get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: + self.get_physical_device_mir_presentation_support_khr, } } } @@ -15065,8 +14971,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: self - .get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: + self.get_physical_device_win32_presentation_support_khr, } } } @@ -16632,8 +16538,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: self - .get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: + self.get_physical_device_external_image_format_properties_nv, } } } @@ -16826,12 +16732,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17643,8 +17549,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17830,8 +17736,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17945,8 +17851,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: self - .get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: + self.get_physical_device_generated_commands_properties_nvx, } } } @@ -18386,8 +18292,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: self - .get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: + self.get_physical_device_surface_capabilities2_ext, } } } @@ -19538,8 +19444,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: self - .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: + self.get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19670,10 +19576,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: self - .get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: self - .get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: + self.get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: + self.get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -20309,10 +20215,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: self - .get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: self - .get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: + self.get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: + self.get_memory_android_hardware_buffer_android, } } } @@ -20713,8 +20619,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: self - .get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: + self.get_physical_device_multisample_properties_ext, } } } @@ -23409,652 +23315,15 @@ fn display_flags( } Ok(()) } -impl fmt::Display for CommandPoolCreateFlags { +impl fmt::Display for CommandBufferResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ImageType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24070,80 +23339,6 @@ impl fmt::Display for ImageType { } } } -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24584,879 +23779,6 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25520,39 +23842,12 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { +impl fmt::Display for AttachmentLoadOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), _ => None, }; if let Some(x) = name { @@ -25562,15 +23857,388 @@ impl fmt::Display for BlendFactor { } } } -impl fmt::Display for MemoryHeapFlags { +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25620,33 +24288,654 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", ), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25914,11 +25203,49 @@ impl fmt::Display for Format { } } } -impl fmt::Display for SharingMode { +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), _ => None, }; if let Some(x) = name { @@ -25928,30 +25255,56 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for SurfaceTransformFlagsKHR { +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), ]; display_flags(f, KNOWN, self.0) } @@ -25970,48 +25323,11 @@ impl fmt::Display for ChromaLocation { } } } -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -26053,12 +25369,20 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ShaderInfoTypeAMD { +impl fmt::Display for DescriptorType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), _ => None, }; if let Some(x) = name { @@ -26068,6 +25392,194 @@ impl fmt::Display for ShaderInfoTypeAMD { } } } +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -26125,3 +25637,397 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 0209cb2..9fe7c3e 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -333,7 +333,7 @@ impl ExampleBase { .enumerate() .filter_map(|(index, ref info)| { let supports_graphic_and_surface = - info.queue_flags.subset(vk::QueueFlags::GRAPHICS) && surface_loader + info.queue_flags.contains(vk::QueueFlags::GRAPHICS) && surface_loader .get_physical_device_surface_support_khr( *pdevice, index as u32, @@ -410,7 +410,7 @@ impl ExampleBase { }; let pre_transform = if surface_capabilities .supported_transforms - .subset(vk::SurfaceTransformFlagsKHR::IDENTITY) + .contains(vk::SurfaceTransformFlagsKHR::IDENTITY) { vk::SurfaceTransformFlagsKHR::IDENTITY } else { diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 955d364..d17166e 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -210,23 +210,10 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { } #[inline] - pub fn flags(self) -> $flag_type { - self.0 - } + pub fn from_raw(x: $flag_type) -> Self { $name(x) } #[inline] - pub fn from_flags(flags: $flag_type) -> Option<$name> { - if flags & !$all == 0 { - Some($name(flags)) - } else { - None - } - } - - #[inline] - pub fn from_flags_truncate(flags: $flag_type) -> $name { - $name (flags & $all) - } + pub fn as_raw(self) -> $flag_type { self.0 } #[inline] pub fn is_empty(self) -> bool { @@ -243,9 +230,9 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { self & other != $name::empty() } - /// Returns true of `other` is a subset of `self` + /// Returns whether `other` is a subset of `self` #[inline] - pub fn subset(self, other: $name) -> bool { + pub fn contains(self, other: $name) -> bool { self & other == other } } From aa171d405acda55bde5012aad70c534864087e79 Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 16 Sep 2018 12:15:01 -0700 Subject: [PATCH 093/122] More traits for dispatchable handles --- ash/src/vk.rs | 3291 ++++++++++++++++++++---------------------- generator/src/lib.rs | 31 +- 2 files changed, 1625 insertions(+), 1697 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index d2c8903..2fc09be 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -11,25 +11,25 @@ pub trait Handle { } #[macro_export] macro_rules! vk_make_version { - ($major:expr, $minor:expr, $patch:expr) => { + ( $ major : expr , $ minor : expr , $ patch : expr ) => { (($major as u32) << 22) | (($minor as u32) << 12) | $patch as u32 }; } #[macro_export] macro_rules! vk_version_major { - ($major:expr) => { + ( $ major : expr ) => { ($major as u32) >> 22 }; } #[macro_export] macro_rules! vk_version_minor { - ($minor:expr) => { + ( $ minor : expr ) => { (($minor as u32) >> 12) & 0x3ff }; } #[macro_export] macro_rules! vk_version_patch { - ($minor:expr) => { + ( $ minor : expr ) => { ($minor as u32) & 0xfff }; } @@ -59,17 +59,14 @@ pub type SECURITY_ATTRIBUTES = (); pub type ANativeWindow = c_void; pub type AHardwareBuffer = c_void; macro_rules! vk_bitflags_wrapped { - ($name:ident, $all:expr, $flag_type:ty) => { + ( $ name : ident , $ all : expr , $ flag_type : ty ) => { impl Default for $name { fn default() -> $name { $name(0) } } - impl ::std::fmt::Debug for $name { - fn fmt( - &self, - f: &mut ::std::fmt::Formatter, - ) -> ::std::result::Result<(), ::std::fmt::Error> { + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}({:b})", stringify!($name), self.0) } } @@ -178,7 +175,7 @@ macro_rules! vk_bitflags_wrapped { }; } macro_rules! handle_nondispatchable { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] pub struct $name(u64); @@ -196,28 +193,22 @@ macro_rules! handle_nondispatchable { $name(0) } } - impl ::std::fmt::Pointer for $name { - fn fmt( - &self, - f: &mut ::std::fmt::Formatter, - ) -> ::std::result::Result<(), ::std::fmt::Error> { + impl fmt::Pointer for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "0x{:x}", self.0) } } - impl ::std::fmt::Debug for $name { - fn fmt( - &self, - f: &mut ::std::fmt::Formatter, - ) -> ::std::result::Result<(), ::std::fmt::Error> { + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "0x{:x}", self.0) } } }; } macro_rules! define_handle { - ($name:ident, $ty:ident) => { + ( $ name : ident , $ ty : ident ) => { #[repr(transparent)] - #[derive(Clone, Copy, Debug)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] pub struct $name(*mut u8); impl Default for $name { fn default() -> $name { @@ -240,6 +231,16 @@ macro_rules! define_handle { $name(::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) + } + } }; } pub struct StaticFn { @@ -462,18 +463,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: self - .get_physical_device_image_format_properties, + get_physical_device_image_format_properties: + self.get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: self - .get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: + self.get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: self - .get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: + self.get_physical_device_sparse_image_format_properties, } } } @@ -3955,19 +3956,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: self - .get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: self - .get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: + self.get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: + self.get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: self - .get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: self - .get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: self - .get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: self - .get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: + self.get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: + self.get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: + self.get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: + self.get_physical_device_external_semaphore_properties, } } } @@ -5034,8 +5035,8 @@ pub struct PhysicalDeviceProperties { pub limits: PhysicalDeviceLimits, pub sparse_properties: PhysicalDeviceSparseProperties, } -impl ::std::fmt::Debug for PhysicalDeviceProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for PhysicalDeviceProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceProperties") .field("api_version", &self.api_version) .field("driver_version", &self.driver_version) @@ -5044,11 +5045,9 @@ impl ::std::fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }) - .field("pipeline_cache_uuid", &unsafe { + }).field("pipeline_cache_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }) - .field("limits", &self.limits) + }).field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5074,13 +5073,12 @@ pub struct ExtensionProperties { pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], pub spec_version: u32, } -impl ::std::fmt::Debug for ExtensionProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for ExtensionProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .finish() } } @@ -5100,18 +5098,16 @@ pub struct LayerProperties { pub implementation_version: u32, pub description: [c_char; MAX_DESCRIPTION_SIZE], } -impl ::std::fmt::Debug for LayerProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for LayerProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for LayerProperties { @@ -5158,8 +5154,8 @@ pub struct AllocationCallbacks { pub pfn_internal_allocation: PFN_vkInternalAllocationNotification, pub pfn_internal_free: PFN_vkInternalFreeNotification, } -impl ::std::fmt::Debug for AllocationCallbacks { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for AllocationCallbacks { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AllocationCallbacks") .field("p_user_data", &self.p_user_data) .field("pfn_allocation", &(self.pfn_allocation as *const ())) @@ -5168,8 +5164,7 @@ impl ::std::fmt::Debug for AllocationCallbacks { .field( "pfn_internal_allocation", &(self.pfn_internal_allocation as *const ()), - ) - .field("pfn_internal_free", &(self.pfn_internal_free as *const ())) + ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) .finish() } } @@ -5279,18 +5274,16 @@ pub struct PhysicalDeviceMemoryProperties { pub memory_heap_count: u32, pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], } -impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for PhysicalDeviceMemoryProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceMemoryProperties") .field("memory_type_count", &self.memory_type_count) .field("memory_types", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }) - .field("memory_heap_count", &self.memory_heap_count) + }).field("memory_heap_count", &self.memory_heap_count) .field("memory_heaps", &unsafe { ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PhysicalDeviceMemoryProperties { @@ -5814,18 +5807,16 @@ pub struct ImageBlit { pub dst_subresource: ImageSubresourceLayers, pub dst_offsets: [Offset3D; 2], } -impl ::std::fmt::Debug for ImageBlit { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for ImageBlit { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("ImageBlit") .field("src_subresource", &self.src_subresource) .field("src_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }) - .field("dst_subresource", &self.dst_subresource) + }).field("dst_subresource", &self.dst_subresource) .field("dst_offsets", &unsafe { ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ImageBlit { @@ -6227,8 +6218,8 @@ pub struct PipelineColorBlendStateCreateInfo { pub p_attachments: *const PipelineColorBlendAttachmentState, pub blend_constants: [c_float; 4], } -impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for PipelineColorBlendStateCreateInfo { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PipelineColorBlendStateCreateInfo") .field("s_type", &self.s_type) .field("p_next", &self.p_next) @@ -6239,8 +6230,7 @@ impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { .field("p_attachments", &self.p_attachments) .field("blend_constants", &unsafe { ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for PipelineColorBlendStateCreateInfo { @@ -6560,8 +6550,8 @@ pub struct RenderPassBeginInfo { pub clear_value_count: u32, pub p_clear_values: *const ClearValue, } -impl ::std::fmt::Debug for RenderPassBeginInfo { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for RenderPassBeginInfo { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("RenderPassBeginInfo") .field("s_type", &self.s_type) .field("p_next", &self.p_next) @@ -6622,8 +6612,8 @@ pub struct ClearAttachment { pub color_attachment: u32, pub clear_value: ClearValue, } -impl ::std::fmt::Debug for ClearAttachment { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for ClearAttachment { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("ClearAttachment") .field("aspect_mask", &self.aspect_mask) .field("color_attachment", &self.color_attachment) @@ -6929,8 +6919,8 @@ pub struct PhysicalDeviceLimits { pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, pub non_coherent_atom_size: DeviceSize, } -impl ::std::fmt::Debug for PhysicalDeviceLimits { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for PhysicalDeviceLimits { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceLimits") .field("max_image_dimension1_d", &self.max_image_dimension1_d) .field("max_image_dimension2_d", &self.max_image_dimension2_d) @@ -6944,202 +6934,155 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "max_memory_allocation_count", &self.max_memory_allocation_count, - ) - .field( + ).field( "max_sampler_allocation_count", &self.max_sampler_allocation_count, - ) - .field("buffer_image_granularity", &self.buffer_image_granularity) + ).field("buffer_image_granularity", &self.buffer_image_granularity) .field("sparse_address_space_size", &self.sparse_address_space_size) .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) .field( "max_per_stage_descriptor_samplers", &self.max_per_stage_descriptor_samplers, - ) - .field( + ).field( "max_per_stage_descriptor_uniform_buffers", &self.max_per_stage_descriptor_uniform_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_storage_buffers", &self.max_per_stage_descriptor_storage_buffers, - ) - .field( + ).field( "max_per_stage_descriptor_sampled_images", &self.max_per_stage_descriptor_sampled_images, - ) - .field( + ).field( "max_per_stage_descriptor_storage_images", &self.max_per_stage_descriptor_storage_images, - ) - .field( + ).field( "max_per_stage_descriptor_input_attachments", &self.max_per_stage_descriptor_input_attachments, - ) - .field("max_per_stage_resources", &self.max_per_stage_resources) + ).field("max_per_stage_resources", &self.max_per_stage_resources) .field( "max_descriptor_set_samplers", &self.max_descriptor_set_samplers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers", &self.max_descriptor_set_uniform_buffers, - ) - .field( + ).field( "max_descriptor_set_uniform_buffers_dynamic", &self.max_descriptor_set_uniform_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_storage_buffers", &self.max_descriptor_set_storage_buffers, - ) - .field( + ).field( "max_descriptor_set_storage_buffers_dynamic", &self.max_descriptor_set_storage_buffers_dynamic, - ) - .field( + ).field( "max_descriptor_set_sampled_images", &self.max_descriptor_set_sampled_images, - ) - .field( + ).field( "max_descriptor_set_storage_images", &self.max_descriptor_set_storage_images, - ) - .field( + ).field( "max_descriptor_set_input_attachments", &self.max_descriptor_set_input_attachments, - ) - .field( + ).field( "max_vertex_input_attributes", &self.max_vertex_input_attributes, - ) - .field("max_vertex_input_bindings", &self.max_vertex_input_bindings) + ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) .field( "max_vertex_input_attribute_offset", &self.max_vertex_input_attribute_offset, - ) - .field( + ).field( "max_vertex_input_binding_stride", &self.max_vertex_input_binding_stride, - ) - .field( + ).field( "max_vertex_output_components", &self.max_vertex_output_components, - ) - .field( + ).field( "max_tessellation_generation_level", &self.max_tessellation_generation_level, - ) - .field( + ).field( "max_tessellation_patch_size", &self.max_tessellation_patch_size, - ) - .field( + ).field( "max_tessellation_control_per_vertex_input_components", &self.max_tessellation_control_per_vertex_input_components, - ) - .field( + ).field( "max_tessellation_control_per_vertex_output_components", &self.max_tessellation_control_per_vertex_output_components, - ) - .field( + ).field( "max_tessellation_control_per_patch_output_components", &self.max_tessellation_control_per_patch_output_components, - ) - .field( + ).field( "max_tessellation_control_total_output_components", &self.max_tessellation_control_total_output_components, - ) - .field( + ).field( "max_tessellation_evaluation_input_components", &self.max_tessellation_evaluation_input_components, - ) - .field( + ).field( "max_tessellation_evaluation_output_components", &self.max_tessellation_evaluation_output_components, - ) - .field( + ).field( "max_geometry_shader_invocations", &self.max_geometry_shader_invocations, - ) - .field( + ).field( "max_geometry_input_components", &self.max_geometry_input_components, - ) - .field( + ).field( "max_geometry_output_components", &self.max_geometry_output_components, - ) - .field( + ).field( "max_geometry_output_vertices", &self.max_geometry_output_vertices, - ) - .field( + ).field( "max_geometry_total_output_components", &self.max_geometry_total_output_components, - ) - .field( + ).field( "max_fragment_input_components", &self.max_fragment_input_components, - ) - .field( + ).field( "max_fragment_output_attachments", &self.max_fragment_output_attachments, - ) - .field( + ).field( "max_fragment_dual_src_attachments", &self.max_fragment_dual_src_attachments, - ) - .field( + ).field( "max_fragment_combined_output_resources", &self.max_fragment_combined_output_resources, - ) - .field( + ).field( "max_compute_shared_memory_size", &self.max_compute_shared_memory_size, - ) - .field("max_compute_work_group_count", &unsafe { + ).field("max_compute_work_group_count", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }) - .field( + }).field( "max_compute_work_group_invocations", &self.max_compute_work_group_invocations, - ) - .field("max_compute_work_group_size", &unsafe { + ).field("max_compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }) - .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) + }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) .field("mipmap_precision_bits", &self.mipmap_precision_bits) .field( "max_draw_indexed_index_value", &self.max_draw_indexed_index_value, - ) - .field("max_draw_indirect_count", &self.max_draw_indirect_count) + ).field("max_draw_indirect_count", &self.max_draw_indirect_count) .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) .field("max_viewports", &self.max_viewports) .field("max_viewport_dimensions", &unsafe { ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }) - .field("viewport_bounds_range", &unsafe { + }).field("viewport_bounds_range", &unsafe { ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }) - .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) + }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) .field("min_memory_map_alignment", &self.min_memory_map_alignment) .field( "min_texel_buffer_offset_alignment", &self.min_texel_buffer_offset_alignment, - ) - .field( + ).field( "min_uniform_buffer_offset_alignment", &self.min_uniform_buffer_offset_alignment, - ) - .field( + ).field( "min_storage_buffer_offset_alignment", &self.min_storage_buffer_offset_alignment, - ) - .field("min_texel_offset", &self.min_texel_offset) + ).field("min_texel_offset", &self.min_texel_offset) .field("max_texel_offset", &self.max_texel_offset) .field("min_texel_gather_offset", &self.min_texel_gather_offset) .field("max_texel_gather_offset", &self.max_texel_gather_offset) @@ -7148,79 +7091,63 @@ impl ::std::fmt::Debug for PhysicalDeviceLimits { .field( "sub_pixel_interpolation_offset_bits", &self.sub_pixel_interpolation_offset_bits, - ) - .field("max_framebuffer_width", &self.max_framebuffer_width) + ).field("max_framebuffer_width", &self.max_framebuffer_width) .field("max_framebuffer_height", &self.max_framebuffer_height) .field("max_framebuffer_layers", &self.max_framebuffer_layers) .field( "framebuffer_color_sample_counts", &self.framebuffer_color_sample_counts, - ) - .field( + ).field( "framebuffer_depth_sample_counts", &self.framebuffer_depth_sample_counts, - ) - .field( + ).field( "framebuffer_stencil_sample_counts", &self.framebuffer_stencil_sample_counts, - ) - .field( + ).field( "framebuffer_no_attachments_sample_counts", &self.framebuffer_no_attachments_sample_counts, - ) - .field("max_color_attachments", &self.max_color_attachments) + ).field("max_color_attachments", &self.max_color_attachments) .field( "sampled_image_color_sample_counts", &self.sampled_image_color_sample_counts, - ) - .field( + ).field( "sampled_image_integer_sample_counts", &self.sampled_image_integer_sample_counts, - ) - .field( + ).field( "sampled_image_depth_sample_counts", &self.sampled_image_depth_sample_counts, - ) - .field( + ).field( "sampled_image_stencil_sample_counts", &self.sampled_image_stencil_sample_counts, - ) - .field( + ).field( "storage_image_sample_counts", &self.storage_image_sample_counts, - ) - .field("max_sample_mask_words", &self.max_sample_mask_words) + ).field("max_sample_mask_words", &self.max_sample_mask_words) .field( "timestamp_compute_and_graphics", &self.timestamp_compute_and_graphics, - ) - .field("timestamp_period", &self.timestamp_period) + ).field("timestamp_period", &self.timestamp_period) .field("max_clip_distances", &self.max_clip_distances) .field("max_cull_distances", &self.max_cull_distances) .field( "max_combined_clip_and_cull_distances", &self.max_combined_clip_and_cull_distances, - ) - .field("discrete_queue_priorities", &self.discrete_queue_priorities) + ).field("discrete_queue_priorities", &self.discrete_queue_priorities) .field("point_size_range", &unsafe { ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }) - .field("line_width_range", &unsafe { + }).field("line_width_range", &unsafe { ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }) - .field("point_size_granularity", &self.point_size_granularity) + }).field("point_size_granularity", &self.point_size_granularity) .field("line_width_granularity", &self.line_width_granularity) .field("strict_lines", &self.strict_lines) .field("standard_sample_locations", &self.standard_sample_locations) .field( "optimal_buffer_copy_offset_alignment", &self.optimal_buffer_copy_offset_alignment, - ) - .field( + ).field( "optimal_buffer_copy_row_pitch_alignment", &self.optimal_buffer_copy_row_pitch_alignment, - ) - .field("non_coherent_atom_size", &self.non_coherent_atom_size) + ).field("non_coherent_atom_size", &self.non_coherent_atom_size) .finish() } } @@ -7814,8 +7741,8 @@ pub struct DebugReportCallbackCreateInfoEXT { pub pfn_callback: PFN_vkDebugReportCallbackEXT, pub p_user_data: *mut c_void, } -impl ::std::fmt::Debug for DebugReportCallbackCreateInfoEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for DebugReportCallbackCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DebugReportCallbackCreateInfoEXT") .field("s_type", &self.s_type) .field("p_next", &self.p_next) @@ -7922,16 +7849,15 @@ pub struct DebugMarkerMarkerInfoEXT { pub p_marker_name: *const c_char, pub color: [c_float; 4], } -impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for DebugMarkerMarkerInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DebugMarkerMarkerInfoEXT") .field("s_type", &self.s_type) .field("p_next", &self.p_next) .field("p_marker_name", &self.p_marker_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugMarkerMarkerInfoEXT { @@ -8624,21 +8550,18 @@ pub struct PhysicalDeviceIDProperties { pub device_node_mask: u32, pub device_luid_valid: Bool32, } -impl ::std::fmt::Debug for PhysicalDeviceIDProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for PhysicalDeviceIDProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceIDProperties") .field("s_type", &self.s_type) .field("p_next", &self.p_next) .field("device_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }) - .field("driver_uuid", &unsafe { + }).field("driver_uuid", &unsafe { ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }) - .field("device_luid", &unsafe { + }).field("device_luid", &unsafe { ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }) - .field("device_node_mask", &self.device_node_mask) + }).field("device_node_mask", &self.device_node_mask) .field("device_luid_valid", &self.device_luid_valid) .finish() } @@ -9361,16 +9284,15 @@ pub struct PhysicalDeviceGroupProperties { pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, } -impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for PhysicalDeviceGroupProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceGroupProperties") .field("s_type", &self.s_type) .field("p_next", &self.p_next) .field("physical_device_count", &self.physical_device_count) .field("physical_devices", &unsafe { ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }) - .field("subset_allocation", &self.subset_allocation) + }).field("subset_allocation", &self.subset_allocation) .finish() } } @@ -9571,15 +9493,14 @@ pub struct DeviceGroupPresentCapabilitiesKHR { pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE], pub modes: DeviceGroupPresentModeFlagsKHR, } -impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for DeviceGroupPresentCapabilitiesKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DeviceGroupPresentCapabilitiesKHR") .field("s_type", &self.s_type) .field("p_next", &self.p_next) .field("present_mask", &unsafe { ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }) - .field("modes", &self.modes) + }).field("modes", &self.modes) .finish() } } @@ -10665,29 +10586,25 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub sample_location_sub_pixel_bits: u32, pub variable_sample_locations: Bool32, } -impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceSampleLocationsPropertiesEXT") .field("s_type", &self.s_type) .field("p_next", &self.p_next) .field( "sample_location_sample_counts", &self.sample_location_sample_counts, - ) - .field( + ).field( "max_sample_location_grid_size", &self.max_sample_location_grid_size, - ) - .field("sample_location_coordinate_range", &unsafe { + ).field("sample_location_coordinate_range", &unsafe { ::std::ffi::CStr::from_ptr( self.sample_location_coordinate_range.as_ptr() as *const i8 ) - }) - .field( + }).field( "sample_location_sub_pixel_bits", &self.sample_location_sub_pixel_bits, - ) - .field("variable_sample_locations", &self.variable_sample_locations) + ).field("variable_sample_locations", &self.variable_sample_locations) .finish() } } @@ -10968,8 +10885,8 @@ pub struct ShaderStatisticsInfoAMD { pub num_available_sgprs: u32, pub compute_work_group_size: [u32; 3], } -impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for ShaderStatisticsInfoAMD { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("ShaderStatisticsInfoAMD") .field("shader_stage_mask", &self.shader_stage_mask) .field("resource_usage", &self.resource_usage) @@ -10979,8 +10896,7 @@ impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { .field("num_available_sgprs", &self.num_available_sgprs) .field("compute_work_group_size", &unsafe { ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for ShaderStatisticsInfoAMD { @@ -11064,16 +10980,15 @@ pub struct DebugUtilsLabelEXT { pub p_label_name: *const c_char, pub color: [c_float; 4], } -impl ::std::fmt::Debug for DebugUtilsLabelEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for DebugUtilsLabelEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DebugUtilsLabelEXT") .field("s_type", &self.s_type) .field("p_next", &self.p_next) .field("p_label_name", &self.p_label_name) .field("color", &unsafe { ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for DebugUtilsLabelEXT { @@ -11097,8 +11012,8 @@ pub struct DebugUtilsMessengerCreateInfoEXT { pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, pub p_user_data: *mut c_void, } -impl ::std::fmt::Debug for DebugUtilsMessengerCreateInfoEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { +impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT") .field("s_type", &self.s_type) .field("p_next", &self.p_next) @@ -13923,12 +13838,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: self - .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: + self.get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: self - .get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: + self.get_physical_device_surface_present_modes_khr, } } } @@ -14077,12 +13992,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -14389,10 +14304,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: self - .get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: self - .get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: + self.get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: + self.get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14675,8 +14590,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: self - .get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: + self.get_physical_device_xlib_presentation_support_khr, } } } @@ -14761,8 +14676,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: self - .get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: + self.get_physical_device_xcb_presentation_support_khr, } } } @@ -14847,8 +14762,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: self - .get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: + self.get_physical_device_wayland_presentation_support_khr, } } } @@ -14930,8 +14845,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: self - .get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: + self.get_physical_device_mir_presentation_support_khr, } } } @@ -15065,8 +14980,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: self - .get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: + self.get_physical_device_win32_presentation_support_khr, } } } @@ -16632,8 +16547,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: self - .get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: + self.get_physical_device_external_image_format_properties_nv, } } } @@ -16826,12 +16741,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17643,8 +17558,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17830,8 +17745,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } @@ -17945,8 +17860,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: self - .get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: + self.get_physical_device_generated_commands_properties_nvx, } } } @@ -18386,8 +18301,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: self - .get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: + self.get_physical_device_surface_capabilities2_ext, } } } @@ -19538,8 +19453,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: self - .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: + self.get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19670,10 +19585,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: self - .get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: self - .get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: + self.get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: + self.get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -20309,10 +20224,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: self - .get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: self - .get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: + self.get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: + self.get_memory_android_hardware_buffer_android, } } } @@ -20713,8 +20628,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: self - .get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: + self.get_physical_device_multisample_properties_ext, } } } @@ -23409,26 +23324,32 @@ fn display_flags( } Ok(()) } -impl fmt::Display for CommandPoolCreateFlags { +impl fmt::Display for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -23438,11 +23359,29 @@ impl fmt::Display for SamplerAddressMode { } } } -impl fmt::Display for IndexType { +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), _ => None, }; if let Some(x) = name { @@ -23452,31 +23391,168 @@ impl fmt::Display for IndexType { } } } -impl fmt::Display for StencilFaceFlags { +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), + (ShaderStageFlags::VERTEX.0, "VERTEX"), ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { +impl fmt::Display for CompareOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } impl fmt::Display for ImageLayout { @@ -23508,11 +23584,36 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for CommandBufferLevel { +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -23522,10 +23623,12 @@ impl fmt::Display for CommandBufferLevel { } } } -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -23535,75 +23638,95 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassDescriptionFlags { +impl fmt::Display for SamplerReductionModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for SurfaceCounterFlagsEXT { +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; display_flags(f, KNOWN, self.0) } } @@ -23622,110 +23745,6 @@ impl fmt::Display for BlendOverlapEXT { } } } -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -23738,6 +23757,95 @@ impl fmt::Display for SwapchainCreateFlagsKHR { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -23753,84 +23861,84 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for SubgroupFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DependencyFlags { +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), ]; display_flags(f, KNOWN, self.0) } @@ -23858,25 +23966,14 @@ impl fmt::Display for DescriptorBindingFlagsEXT { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -23886,12 +23983,159 @@ impl fmt::Display for PointClippingBehavior { } } } -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } @@ -23910,109 +24154,20 @@ impl fmt::Display for SamplerMipmapMode { } } } -impl fmt::Display for MemoryAllocateFlags { +impl fmt::Display for FenceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageTiling { +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -24042,10 +24197,28 @@ impl fmt::Display for IndirectCommandsTokenTypeNVX { } } } -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for BlendFactor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { + Self::ZERO => Some("ZERO"), Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), _ => None, }; if let Some(x) = name { @@ -24055,12 +24228,13 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for ImageType { +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -24094,17 +24268,255 @@ impl fmt::Display for DynamicState { } } } -impl fmt::Display for ColorComponentFlags { +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -24116,32 +24528,271 @@ impl fmt::Display for QueryResultFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentDescriptionFlags { +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } impl fmt::Display for StructureType { @@ -24584,62 +25235,11 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayEventTypeEXT { +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), _ => None, }; if let Some(x) = name { @@ -24649,44 +25249,17 @@ impl fmt::Display for DisplayEventTypeEXT { } } } -impl fmt::Display for ImageUsageFlags { +impl fmt::Display for AttachmentDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { +impl fmt::Display for FrontFace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), _ => None, }; if let Some(x) = name { @@ -24696,235 +25269,11 @@ impl fmt::Display for SamplerYcbcrModelConversion { } } } -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), _ => None, }; if let Some(x) = name { @@ -24985,283 +25334,6 @@ impl fmt::Display for QueryPipelineStatisticFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25282,366 +25354,28 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { +impl fmt::Display for CommandPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", ), ]; display_flags(f, KNOWN, self.0) @@ -25914,53 +25648,34 @@ impl fmt::Display for Format { } } } -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { +impl fmt::Display for QueueFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ChromaLocation { +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), _ => None, }; if let Some(x) = name { @@ -25970,6 +25685,34 @@ impl fmt::Display for ChromaLocation { } } } +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -25989,15 +25732,47 @@ impl fmt::Display for ExternalMemoryFeatureFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseMemoryBindFlags { +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceQueueCreateFlags { +impl fmt::Display for AttachmentStoreOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; display_flags(f, KNOWN, self.0) } } @@ -26021,6 +25796,104 @@ impl fmt::Display for StencilOp { } } } +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -26053,21 +25926,6 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -26125,3 +25983,60 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 955d364..e0102ae 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -90,7 +90,7 @@ pub fn define_handle_macro() -> Tokens { macro_rules! define_handle{ ($name: ident, $ty: ident) => { #[repr(transparent)] - #[derive(Clone, Copy, Debug)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] pub struct $name(*mut u8); impl Default for $name { fn default() -> $name { @@ -112,6 +112,18 @@ pub fn define_handle_macro() -> Tokens { $name(::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) + } + } } } } @@ -136,14 +148,15 @@ pub fn handle_nondispatchable_macro() -> Tokens { $name(0) } } - impl ::std::fmt::Pointer for $name { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + + impl fmt::Pointer for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "0x{:x}", self.0) } } - impl ::std::fmt::Debug for $name { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "0x{:x}", self.0) } } @@ -192,8 +205,8 @@ pub fn vk_bitflags_wrapped_macro() -> Tokens { $name(0) } } - impl ::std::fmt::Debug for $name { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}({:b})", stringify!($name), self.0) } } @@ -1268,8 +1281,8 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt }); let name_str = name.as_ref(); let q = quote!{ - impl ::std::fmt::Debug for #name { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + impl fmt::Debug for #name { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct(#name_str) #(#debug_fields)* .finish() From d78afd87ddb535930faa6964a3862823119c6ab1 Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sat, 29 Sep 2018 11:21:56 -0700 Subject: [PATCH 094/122] Flatten vk.rs module structure and use f32 --- ash/src/vk.rs | 23425 ++++++++++++++++++++--------------------- generator/src/lib.rs | 18 +- 2 files changed, 11690 insertions(+), 11753 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 2fc09be..f53295b 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,7 +1,3 @@ -#[doc(hidden)] -pub use self::bitflags::*; -#[doc(hidden)] -pub use self::extensions::*; use std::fmt; use std::os::raw::*; pub trait Handle { @@ -1143,19 +1139,19 @@ pub struct DeviceFnV1_0 { p_scissors: *const Rect2D, ) -> c_void, cmd_set_line_width: - extern "system" fn(command_buffer: CommandBuffer, line_width: c_float) -> c_void, + extern "system" fn(command_buffer: CommandBuffer, line_width: f32) -> c_void, cmd_set_depth_bias: extern "system" fn( command_buffer: CommandBuffer, - depth_bias_constant_factor: c_float, - depth_bias_clamp: c_float, - depth_bias_slope_factor: c_float, + depth_bias_constant_factor: f32, + depth_bias_clamp: f32, + depth_bias_slope_factor: f32, ) -> c_void, cmd_set_blend_constants: - extern "system" fn(command_buffer: CommandBuffer, blend_constants: [c_float; 4]) -> c_void, + extern "system" fn(command_buffer: CommandBuffer, blend_constants: [f32; 4]) -> c_void, cmd_set_depth_bounds: extern "system" fn( command_buffer: CommandBuffer, - min_depth_bounds: c_float, - max_depth_bounds: c_float, + min_depth_bounds: f32, + max_depth_bounds: f32, ) -> c_void, cmd_set_stencil_compare_mask: extern "system" fn( command_buffer: CommandBuffer, @@ -3317,16 +3313,16 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_set_line_width( &self, command_buffer: CommandBuffer, - line_width: c_float, + line_width: f32, ) -> c_void { (self.cmd_set_line_width)(command_buffer, line_width) } pub unsafe fn cmd_set_depth_bias( &self, command_buffer: CommandBuffer, - depth_bias_constant_factor: c_float, - depth_bias_clamp: c_float, - depth_bias_slope_factor: c_float, + depth_bias_constant_factor: f32, + depth_bias_clamp: f32, + depth_bias_slope_factor: f32, ) -> c_void { (self.cmd_set_depth_bias)( command_buffer, @@ -3338,15 +3334,15 @@ impl DeviceFnV1_0 { pub unsafe fn cmd_set_blend_constants( &self, command_buffer: CommandBuffer, - blend_constants: [c_float; 4], + blend_constants: [f32; 4], ) -> c_void { (self.cmd_set_blend_constants)(command_buffer, blend_constants) } pub unsafe fn cmd_set_depth_bounds( &self, command_buffer: CommandBuffer, - min_depth_bounds: c_float, - max_depth_bounds: c_float, + min_depth_bounds: f32, + max_depth_bounds: f32, ) -> c_void { (self.cmd_set_depth_bounds)(command_buffer, min_depth_bounds, max_depth_bounds) } @@ -4994,12 +4990,12 @@ pub struct Extent3D { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Viewport { - pub x: c_float, - pub y: c_float, - pub width: c_float, - pub height: c_float, - pub min_depth: c_float, - pub max_depth: c_float, + pub x: f32, + pub y: f32, + pub width: f32, + pub height: f32, + pub min_depth: f32, + pub max_depth: f32, } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] @@ -5188,7 +5184,7 @@ pub struct DeviceQueueCreateInfo { pub flags: DeviceQueueCreateFlags, pub queue_family_index: u32, pub queue_count: u32, - pub p_queue_priorities: *const c_float, + pub p_queue_priorities: *const f32, } impl ::std::default::Default for DeviceQueueCreateInfo { fn default() -> DeviceQueueCreateInfo { @@ -6142,10 +6138,10 @@ pub struct PipelineRasterizationStateCreateInfo { pub cull_mode: CullModeFlags, pub front_face: FrontFace, pub depth_bias_enable: Bool32, - pub depth_bias_constant_factor: c_float, - pub depth_bias_clamp: c_float, - pub depth_bias_slope_factor: c_float, - pub line_width: c_float, + pub depth_bias_constant_factor: f32, + pub depth_bias_clamp: f32, + pub depth_bias_slope_factor: f32, + pub line_width: f32, } impl ::std::default::Default for PipelineRasterizationStateCreateInfo { fn default() -> PipelineRasterizationStateCreateInfo { @@ -6159,10 +6155,10 @@ impl ::std::default::Default for PipelineRasterizationStateCreateInfo { cull_mode: CullModeFlags::default(), front_face: FrontFace::default(), depth_bias_enable: Bool32::default(), - depth_bias_constant_factor: c_float::default(), - depth_bias_clamp: c_float::default(), - depth_bias_slope_factor: c_float::default(), - line_width: c_float::default(), + depth_bias_constant_factor: f32::default(), + depth_bias_clamp: f32::default(), + depth_bias_slope_factor: f32::default(), + line_width: f32::default(), } } } @@ -6174,7 +6170,7 @@ pub struct PipelineMultisampleStateCreateInfo { pub flags: PipelineMultisampleStateCreateFlags, pub rasterization_samples: SampleCountFlags, pub sample_shading_enable: Bool32, - pub min_sample_shading: c_float, + pub min_sample_shading: f32, pub p_sample_mask: *const SampleMask, pub alpha_to_coverage_enable: Bool32, pub alpha_to_one_enable: Bool32, @@ -6187,7 +6183,7 @@ impl ::std::default::Default for PipelineMultisampleStateCreateInfo { flags: PipelineMultisampleStateCreateFlags::default(), rasterization_samples: SampleCountFlags::default(), sample_shading_enable: Bool32::default(), - min_sample_shading: c_float::default(), + min_sample_shading: f32::default(), p_sample_mask: ::std::ptr::null(), alpha_to_coverage_enable: Bool32::default(), alpha_to_one_enable: Bool32::default(), @@ -6216,7 +6212,7 @@ pub struct PipelineColorBlendStateCreateInfo { pub logic_op: LogicOp, pub attachment_count: u32, pub p_attachments: *const PipelineColorBlendAttachmentState, - pub blend_constants: [c_float; 4], + pub blend_constants: [f32; 4], } impl fmt::Debug for PipelineColorBlendStateCreateInfo { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { @@ -6291,8 +6287,8 @@ pub struct PipelineDepthStencilStateCreateInfo { pub stencil_test_enable: Bool32, pub front: StencilOpState, pub back: StencilOpState, - pub min_depth_bounds: c_float, - pub max_depth_bounds: c_float, + pub min_depth_bounds: f32, + pub max_depth_bounds: f32, } impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { fn default() -> PipelineDepthStencilStateCreateInfo { @@ -6307,8 +6303,8 @@ impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { stencil_test_enable: Bool32::default(), front: StencilOpState::default(), back: StencilOpState::default(), - min_depth_bounds: c_float::default(), - max_depth_bounds: c_float::default(), + min_depth_bounds: f32::default(), + max_depth_bounds: f32::default(), } } } @@ -6423,13 +6419,13 @@ pub struct SamplerCreateInfo { pub address_mode_u: SamplerAddressMode, pub address_mode_v: SamplerAddressMode, pub address_mode_w: SamplerAddressMode, - pub mip_lod_bias: c_float, + pub mip_lod_bias: f32, pub anisotropy_enable: Bool32, - pub max_anisotropy: c_float, + pub max_anisotropy: f32, pub compare_enable: Bool32, pub compare_op: CompareOp, - pub min_lod: c_float, - pub max_lod: c_float, + pub min_lod: f32, + pub max_lod: f32, pub border_color: BorderColor, pub unnormalized_coordinates: Bool32, } @@ -6445,13 +6441,13 @@ impl ::std::default::Default for SamplerCreateInfo { address_mode_u: SamplerAddressMode::default(), address_mode_v: SamplerAddressMode::default(), address_mode_w: SamplerAddressMode::default(), - mip_lod_bias: c_float::default(), + mip_lod_bias: f32::default(), anisotropy_enable: Bool32::default(), - max_anisotropy: c_float::default(), + max_anisotropy: f32::default(), compare_enable: Bool32::default(), compare_op: CompareOp::default(), - min_lod: c_float::default(), - max_lod: c_float::default(), + min_lod: f32::default(), + max_lod: f32::default(), border_color: BorderColor::default(), unnormalized_coordinates: Bool32::default(), } @@ -6579,7 +6575,7 @@ impl ::std::default::Default for RenderPassBeginInfo { #[repr(C)] #[derive(Copy, Clone)] pub union ClearColorValue { - pub float32: [c_float; 4], + pub float32: [f32; 4], pub int32: [i32; 4], pub uint32: [u32; 4], } @@ -6591,7 +6587,7 @@ impl ::std::default::Default for ClearColorValue { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ClearDepthStencilValue { - pub depth: c_float, + pub depth: f32, pub stencil: u32, } #[repr(C)] @@ -6872,11 +6868,11 @@ pub struct PhysicalDeviceLimits { pub mipmap_precision_bits: u32, pub max_draw_indexed_index_value: u32, pub max_draw_indirect_count: u32, - pub max_sampler_lod_bias: c_float, - pub max_sampler_anisotropy: c_float, + pub max_sampler_lod_bias: f32, + pub max_sampler_anisotropy: f32, pub max_viewports: u32, pub max_viewport_dimensions: [u32; 2], - pub viewport_bounds_range: [c_float; 2], + pub viewport_bounds_range: [f32; 2], pub viewport_sub_pixel_bits: u32, pub min_memory_map_alignment: usize, pub min_texel_buffer_offset_alignment: DeviceSize, @@ -6886,8 +6882,8 @@ pub struct PhysicalDeviceLimits { pub max_texel_offset: u32, pub min_texel_gather_offset: i32, pub max_texel_gather_offset: u32, - pub min_interpolation_offset: c_float, - pub max_interpolation_offset: c_float, + pub min_interpolation_offset: f32, + pub max_interpolation_offset: f32, pub sub_pixel_interpolation_offset_bits: u32, pub max_framebuffer_width: u32, pub max_framebuffer_height: u32, @@ -6904,15 +6900,15 @@ pub struct PhysicalDeviceLimits { pub storage_image_sample_counts: SampleCountFlags, pub max_sample_mask_words: u32, pub timestamp_compute_and_graphics: Bool32, - pub timestamp_period: c_float, + pub timestamp_period: f32, pub max_clip_distances: u32, pub max_cull_distances: u32, pub max_combined_clip_and_cull_distances: u32, pub discrete_queue_priorities: u32, - pub point_size_range: [c_float; 2], - pub line_width_range: [c_float; 2], - pub point_size_granularity: c_float, - pub line_width_granularity: c_float, + pub point_size_range: [f32; 2], + pub line_width_range: [f32; 2], + pub point_size_granularity: f32, + pub line_width_granularity: f32, pub strict_lines: Bool32, pub standard_sample_locations: Bool32, pub optimal_buffer_copy_offset_alignment: DeviceSize, @@ -7214,8 +7210,8 @@ impl ::std::default::Default for PhysicalDeviceLimits { mipmap_precision_bits: u32::default(), max_draw_indexed_index_value: u32::default(), max_draw_indirect_count: u32::default(), - max_sampler_lod_bias: c_float::default(), - max_sampler_anisotropy: c_float::default(), + max_sampler_lod_bias: f32::default(), + max_sampler_anisotropy: f32::default(), max_viewports: u32::default(), max_viewport_dimensions: unsafe { ::std::mem::zeroed() }, viewport_bounds_range: unsafe { ::std::mem::zeroed() }, @@ -7228,8 +7224,8 @@ impl ::std::default::Default for PhysicalDeviceLimits { max_texel_offset: u32::default(), min_texel_gather_offset: i32::default(), max_texel_gather_offset: u32::default(), - min_interpolation_offset: c_float::default(), - max_interpolation_offset: c_float::default(), + min_interpolation_offset: f32::default(), + max_interpolation_offset: f32::default(), sub_pixel_interpolation_offset_bits: u32::default(), max_framebuffer_width: u32::default(), max_framebuffer_height: u32::default(), @@ -7246,15 +7242,15 @@ impl ::std::default::Default for PhysicalDeviceLimits { storage_image_sample_counts: SampleCountFlags::default(), max_sample_mask_words: u32::default(), timestamp_compute_and_graphics: Bool32::default(), - timestamp_period: c_float::default(), + timestamp_period: f32::default(), max_clip_distances: u32::default(), max_cull_distances: u32::default(), max_combined_clip_and_cull_distances: u32::default(), discrete_queue_priorities: u32::default(), point_size_range: unsafe { ::std::mem::zeroed() }, line_width_range: unsafe { ::std::mem::zeroed() }, - point_size_granularity: c_float::default(), - line_width_granularity: c_float::default(), + point_size_granularity: f32::default(), + line_width_granularity: f32::default(), strict_lines: Bool32::default(), standard_sample_locations: Bool32::default(), optimal_buffer_copy_offset_alignment: DeviceSize::default(), @@ -7464,7 +7460,7 @@ pub struct DisplaySurfaceCreateInfoKHR { pub plane_index: u32, pub plane_stack_index: u32, pub transform: SurfaceTransformFlagsKHR, - pub global_alpha: c_float, + pub global_alpha: f32, pub alpha_mode: DisplayPlaneAlphaFlagsKHR, pub image_extent: Extent2D, } @@ -7478,7 +7474,7 @@ impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { plane_index: u32::default(), plane_stack_index: u32::default(), transform: SurfaceTransformFlagsKHR::default(), - global_alpha: c_float::default(), + global_alpha: f32::default(), alpha_mode: DisplayPlaneAlphaFlagsKHR::default(), image_extent: Extent2D::default(), } @@ -7847,7 +7843,7 @@ pub struct DebugMarkerMarkerInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub p_marker_name: *const c_char, - pub color: [c_float; 4], + pub color: [f32; 4], } impl fmt::Debug for DebugMarkerMarkerInfoEXT { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { @@ -9669,8 +9665,8 @@ impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct XYColorEXT { - pub x: c_float, - pub y: c_float, + pub x: f32, + pub y: f32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -9681,10 +9677,10 @@ pub struct HdrMetadataEXT { pub display_primary_green: XYColorEXT, pub display_primary_blue: XYColorEXT, pub white_point: XYColorEXT, - pub max_luminance: c_float, - pub min_luminance: c_float, - pub max_content_light_level: c_float, - pub max_frame_average_light_level: c_float, + pub max_luminance: f32, + pub min_luminance: f32, + pub max_content_light_level: f32, + pub max_frame_average_light_level: f32, } impl ::std::default::Default for HdrMetadataEXT { fn default() -> HdrMetadataEXT { @@ -9695,10 +9691,10 @@ impl ::std::default::Default for HdrMetadataEXT { display_primary_green: XYColorEXT::default(), display_primary_blue: XYColorEXT::default(), white_point: XYColorEXT::default(), - max_luminance: c_float::default(), - min_luminance: c_float::default(), - max_content_light_level: c_float::default(), - max_frame_average_light_level: c_float::default(), + max_luminance: f32::default(), + min_luminance: f32::default(), + max_content_light_level: f32::default(), + max_frame_average_light_level: f32::default(), } } } @@ -9779,8 +9775,8 @@ impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ViewportWScalingNV { - pub xcoeff: c_float, - pub ycoeff: c_float, + pub xcoeff: f32, + pub ycoeff: f32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -10498,8 +10494,8 @@ impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SampleLocationEXT { - pub x: c_float, - pub y: c_float, + pub x: f32, + pub y: f32, } #[repr(C)] #[derive(Copy, Clone, Debug)] @@ -10582,7 +10578,7 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub p_next: *mut c_void, pub sample_location_sample_counts: SampleCountFlags, pub max_sample_location_grid_size: Extent2D, - pub sample_location_coordinate_range: [c_float; 2], + pub sample_location_coordinate_range: [f32; 2], pub sample_location_sub_pixel_bits: u32, pub variable_sample_locations: Bool32, } @@ -10724,7 +10720,7 @@ pub struct PipelineCoverageModulationStateCreateInfoNV { pub coverage_modulation_mode: CoverageModulationModeNV, pub coverage_modulation_table_enable: Bool32, pub coverage_modulation_table_count: u32, - pub p_coverage_modulation_table: *const c_float, + pub p_coverage_modulation_table: *const f32, } impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { fn default() -> PipelineCoverageModulationStateCreateInfoNV { @@ -10978,7 +10974,7 @@ pub struct DebugUtilsLabelEXT { pub s_type: StructureType, pub p_next: *const c_void, pub p_label_name: *const c_char, - pub color: [c_float; 4], + pub color: [f32; 4], } impl fmt::Debug for DebugUtilsLabelEXT { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { @@ -11127,9 +11123,9 @@ impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, - pub primitive_overestimation_size: c_float, - pub max_extra_primitive_overestimation_size: c_float, - pub extra_primitive_overestimation_size_granularity: c_float, + pub primitive_overestimation_size: f32, + pub max_extra_primitive_overestimation_size: f32, + pub extra_primitive_overestimation_size_granularity: f32, pub primitive_underestimation: Bool32, pub conservative_point_and_line_rasterization: Bool32, pub degenerate_triangles_rasterized: Bool32, @@ -11142,9 +11138,9 @@ impl ::std::default::Default for PhysicalDeviceConservativeRasterizationProperti PhysicalDeviceConservativeRasterizationPropertiesEXT { s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), - primitive_overestimation_size: c_float::default(), - max_extra_primitive_overestimation_size: c_float::default(), - extra_primitive_overestimation_size_granularity: c_float::default(), + primitive_overestimation_size: f32::default(), + max_extra_primitive_overestimation_size: f32::default(), + extra_primitive_overestimation_size_granularity: f32::default(), primitive_underestimation: Bool32::default(), conservative_point_and_line_rasterization: Bool32::default(), degenerate_triangles_rasterized: Bool32::default(), @@ -11203,7 +11199,7 @@ pub struct PipelineRasterizationConservativeStateCreateInfoEXT { pub p_next: *const c_void, pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT, pub conservative_rasterization_mode: ConservativeRasterizationModeEXT, - pub extra_primitive_overestimation_size: c_float, + pub extra_primitive_overestimation_size: f32, } impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT { fn default() -> PipelineRasterizationConservativeStateCreateInfoEXT { @@ -11212,7 +11208,7 @@ impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInf p_next: ::std::ptr::null(), flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(), conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(), - extra_primitive_overestimation_size: c_float::default(), + extra_primitive_overestimation_size: f32::default(), } } } @@ -13036,744 +13032,737 @@ impl VendorId { #[doc = "Kazan Software Renderer"] pub const KAZAN: Self = VendorId(0x10003); } -pub mod bitflags { - use super::*; - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct CullModeFlags(pub(crate) Flags); - vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); - impl CullModeFlags { - pub const NONE: Self = CullModeFlags(0); - pub const FRONT: Self = CullModeFlags(0b1); - pub const BACK: Self = CullModeFlags(0b10); - pub const FRONT_AND_BACK: Self = CullModeFlags(0x00000003); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct QueueFlags(pub(crate) Flags); - vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); - impl QueueFlags { - #[doc = "Queue supports graphics operations"] - pub const GRAPHICS: Self = QueueFlags(0b1); - #[doc = "Queue supports compute operations"] - pub const COMPUTE: Self = QueueFlags(0b10); - #[doc = "Queue supports transfer operations"] - pub const TRANSFER: Self = QueueFlags(0b100); - #[doc = "Queue supports sparse resource memory management operations"] - pub const SPARSE_BINDING: Self = QueueFlags(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DeviceQueueCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); - impl DeviceQueueCreateFlags {} - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct MemoryPropertyFlags(pub(crate) Flags); - vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); - impl MemoryPropertyFlags { - #[doc = "If otherwise stated, then allocate memory on device"] - pub const DEVICE_LOCAL: Self = MemoryPropertyFlags(0b1); - #[doc = "Memory is mappable by host"] - pub const HOST_VISIBLE: Self = MemoryPropertyFlags(0b10); - #[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"] - pub const HOST_COHERENT: Self = MemoryPropertyFlags(0b100); - #[doc = "Memory will be cached by the host"] - pub const HOST_CACHED: Self = MemoryPropertyFlags(0b1000); - #[doc = "Memory may be allocated by the driver when it is required"] - pub const LAZILY_ALLOCATED: Self = MemoryPropertyFlags(0b10000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct MemoryHeapFlags(pub(crate) Flags); - vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); - impl MemoryHeapFlags { - #[doc = "If set, heap represents device memory"] - pub const DEVICE_LOCAL: Self = MemoryHeapFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct AccessFlags(pub(crate) Flags); - vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); - impl AccessFlags { - #[doc = "Controls coherency of indirect command reads"] - pub const INDIRECT_COMMAND_READ: Self = AccessFlags(0b1); - #[doc = "Controls coherency of index reads"] - pub const INDEX_READ: Self = AccessFlags(0b10); - #[doc = "Controls coherency of vertex attribute reads"] - pub const VERTEX_ATTRIBUTE_READ: Self = AccessFlags(0b100); - #[doc = "Controls coherency of uniform buffer reads"] - pub const UNIFORM_READ: Self = AccessFlags(0b1000); - #[doc = "Controls coherency of input attachment reads"] - pub const INPUT_ATTACHMENT_READ: Self = AccessFlags(0b10000); - #[doc = "Controls coherency of shader reads"] - pub const SHADER_READ: Self = AccessFlags(0b100000); - #[doc = "Controls coherency of shader writes"] - pub const SHADER_WRITE: Self = AccessFlags(0b1000000); - #[doc = "Controls coherency of color attachment reads"] - pub const COLOR_ATTACHMENT_READ: Self = AccessFlags(0b10000000); - #[doc = "Controls coherency of color attachment writes"] - pub const COLOR_ATTACHMENT_WRITE: Self = AccessFlags(0b100000000); - #[doc = "Controls coherency of depth/stencil attachment reads"] - pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = AccessFlags(0b1000000000); - #[doc = "Controls coherency of depth/stencil attachment writes"] - pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = AccessFlags(0b10000000000); - #[doc = "Controls coherency of transfer reads"] - pub const TRANSFER_READ: Self = AccessFlags(0b100000000000); - #[doc = "Controls coherency of transfer writes"] - pub const TRANSFER_WRITE: Self = AccessFlags(0b1000000000000); - #[doc = "Controls coherency of host reads"] - pub const HOST_READ: Self = AccessFlags(0b10000000000000); - #[doc = "Controls coherency of host writes"] - pub const HOST_WRITE: Self = AccessFlags(0b100000000000000); - #[doc = "Controls coherency of memory reads"] - pub const MEMORY_READ: Self = AccessFlags(0b1000000000000000); - #[doc = "Controls coherency of memory writes"] - pub const MEMORY_WRITE: Self = AccessFlags(0b10000000000000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct BufferUsageFlags(pub(crate) Flags); - vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); - impl BufferUsageFlags { - #[doc = "Can be used as a source of transfer operations"] - pub const TRANSFER_SRC: Self = BufferUsageFlags(0b1); - #[doc = "Can be used as a destination of transfer operations"] - pub const TRANSFER_DST: Self = BufferUsageFlags(0b10); - #[doc = "Can be used as TBO"] - pub const UNIFORM_TEXEL_BUFFER: Self = BufferUsageFlags(0b100); - #[doc = "Can be used as IBO"] - pub const STORAGE_TEXEL_BUFFER: Self = BufferUsageFlags(0b1000); - #[doc = "Can be used as UBO"] - pub const UNIFORM_BUFFER: Self = BufferUsageFlags(0b10000); - #[doc = "Can be used as SSBO"] - pub const STORAGE_BUFFER: Self = BufferUsageFlags(0b100000); - #[doc = "Can be used as source of fixed-function index fetch (index buffer)"] - pub const INDEX_BUFFER: Self = BufferUsageFlags(0b1000000); - #[doc = "Can be used as source of fixed-function vertex fetch (VBO)"] - pub const VERTEX_BUFFER: Self = BufferUsageFlags(0b10000000); - #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"] - pub const INDIRECT_BUFFER: Self = BufferUsageFlags(0b100000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct BufferCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); - impl BufferCreateFlags { - #[doc = "Buffer should support sparse backing"] - pub const SPARSE_BINDING: Self = BufferCreateFlags(0b1); - #[doc = "Buffer should support sparse backing with partial residency"] - pub const SPARSE_RESIDENCY: Self = BufferCreateFlags(0b10); - #[doc = "Buffer should support constent data access to physical memory ranges mapped into multiple locations of sparse buffers"] - pub const SPARSE_ALIASED: Self = BufferCreateFlags(0b100); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ShaderStageFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); - impl ShaderStageFlags { - pub const VERTEX: Self = ShaderStageFlags(0b1); - pub const TESSELLATION_CONTROL: Self = ShaderStageFlags(0b10); - pub const TESSELLATION_EVALUATION: Self = ShaderStageFlags(0b100); - pub const GEOMETRY: Self = ShaderStageFlags(0b1000); - pub const FRAGMENT: Self = ShaderStageFlags(0b10000); - pub const COMPUTE: Self = ShaderStageFlags(0b100000); - pub const ALL_GRAPHICS: Self = ShaderStageFlags(0x0000001F); - pub const ALL: Self = ShaderStageFlags(0x7FFFFFFF); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ImageUsageFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); - impl ImageUsageFlags { - #[doc = "Can be used as a source of transfer operations"] - pub const TRANSFER_SRC: Self = ImageUsageFlags(0b1); - #[doc = "Can be used as a destination of transfer operations"] - pub const TRANSFER_DST: Self = ImageUsageFlags(0b10); - #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] - pub const SAMPLED: Self = ImageUsageFlags(0b100); - #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"] - pub const STORAGE: Self = ImageUsageFlags(0b1000); - #[doc = "Can be used as framebuffer color attachment"] - pub const COLOR_ATTACHMENT: Self = ImageUsageFlags(0b10000); - #[doc = "Can be used as framebuffer depth/stencil attachment"] - pub const DEPTH_STENCIL_ATTACHMENT: Self = ImageUsageFlags(0b100000); - #[doc = "Image data not needed outside of rendering"] - pub const TRANSIENT_ATTACHMENT: Self = ImageUsageFlags(0b1000000); - #[doc = "Can be used as framebuffer input attachment"] - pub const INPUT_ATTACHMENT: Self = ImageUsageFlags(0b10000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ImageCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); - impl ImageCreateFlags { - #[doc = "Image should support sparse backing"] - pub const SPARSE_BINDING: Self = ImageCreateFlags(0b1); - #[doc = "Image should support sparse backing with partial residency"] - pub const SPARSE_RESIDENCY: Self = ImageCreateFlags(0b10); - #[doc = "Image should support constent data access to physical memory ranges mapped into multiple locations of sparse images"] - pub const SPARSE_ALIASED: Self = ImageCreateFlags(0b100); - #[doc = "Allows image views to have different format than the base image"] - pub const MUTABLE_FORMAT: Self = ImageCreateFlags(0b1000); - #[doc = "Allows creating image views with cube type from the created image"] - pub const CUBE_COMPATIBLE: Self = ImageCreateFlags(0b10000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct PipelineCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); - impl PipelineCreateFlags { - pub const DISABLE_OPTIMIZATION: Self = PipelineCreateFlags(0b1); - pub const ALLOW_DERIVATIVES: Self = PipelineCreateFlags(0b10); - pub const DERIVATIVE: Self = PipelineCreateFlags(0b100); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ColorComponentFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); - impl ColorComponentFlags { - pub const R: Self = ColorComponentFlags(0b1); - pub const G: Self = ColorComponentFlags(0b10); - pub const B: Self = ColorComponentFlags(0b100); - pub const A: Self = ColorComponentFlags(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct FenceCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); - impl FenceCreateFlags { - pub const SIGNALED: Self = FenceCreateFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct FormatFeatureFlags(pub(crate) Flags); - vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); - impl FormatFeatureFlags { - #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] - pub const SAMPLED_IMAGE: Self = FormatFeatureFlags(0b1); - #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] - pub const STORAGE_IMAGE: Self = FormatFeatureFlags(0b10); - #[doc = "Format supports atomic operations in case it is used for storage images"] - pub const STORAGE_IMAGE_ATOMIC: Self = FormatFeatureFlags(0b100); - #[doc = "Format can be used for uniform texel buffers (TBOs)"] - pub const UNIFORM_TEXEL_BUFFER: Self = FormatFeatureFlags(0b1000); - #[doc = "Format can be used for storage texel buffers (IBOs)"] - pub const STORAGE_TEXEL_BUFFER: Self = FormatFeatureFlags(0b10000); - #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] - pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = FormatFeatureFlags(0b100000); - #[doc = "Format can be used for vertex buffers (VBOs)"] - pub const VERTEX_BUFFER: Self = FormatFeatureFlags(0b1000000); - #[doc = "Format can be used for color attachment images"] - pub const COLOR_ATTACHMENT: Self = FormatFeatureFlags(0b10000000); - #[doc = "Format supports blending in case it is used for color attachment images"] - pub const COLOR_ATTACHMENT_BLEND: Self = FormatFeatureFlags(0b100000000); - #[doc = "Format can be used for depth/stencil attachment images"] - pub const DEPTH_STENCIL_ATTACHMENT: Self = FormatFeatureFlags(0b1000000000); - #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] - pub const BLIT_SRC: Self = FormatFeatureFlags(0b10000000000); - #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] - pub const BLIT_DST: Self = FormatFeatureFlags(0b100000000000); - #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] - pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = FormatFeatureFlags(0b1000000000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct QueryControlFlags(pub(crate) Flags); - vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); - impl QueryControlFlags { - #[doc = "Require precise results to be collected by the query"] - pub const PRECISE: Self = QueryControlFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct QueryResultFlags(pub(crate) Flags); - vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); - impl QueryResultFlags { - #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] - pub const TYPE_64: Self = QueryResultFlags(0b1); - #[doc = "Results of the queries are waited on before proceeding with the result copy"] - pub const WAIT: Self = QueryResultFlags(0b10); - #[doc = "Besides the results of the query, the availability of the results is also written"] - pub const WITH_AVAILABILITY: Self = QueryResultFlags(0b100); - #[doc = "Copy the partial results of the query even if the final results are not available"] - pub const PARTIAL: Self = QueryResultFlags(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct CommandBufferUsageFlags(pub(crate) Flags); - vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); - impl CommandBufferUsageFlags { - pub const ONE_TIME_SUBMIT: Self = CommandBufferUsageFlags(0b1); - pub const RENDER_PASS_CONTINUE: Self = CommandBufferUsageFlags(0b10); - #[doc = "Command buffer may be submitted/executed more than once simultaneously"] - pub const SIMULTANEOUS_USE: Self = CommandBufferUsageFlags(0b100); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct QueryPipelineStatisticFlags(pub(crate) Flags); - vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); - impl QueryPipelineStatisticFlags { - #[doc = "Optional"] - pub const INPUT_ASSEMBLY_VERTICES: Self = QueryPipelineStatisticFlags(0b1); - #[doc = "Optional"] - pub const INPUT_ASSEMBLY_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10); - #[doc = "Optional"] - pub const VERTEX_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100); - #[doc = "Optional"] - pub const GEOMETRY_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b1000); - #[doc = "Optional"] - pub const GEOMETRY_SHADER_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10000); - #[doc = "Optional"] - pub const CLIPPING_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100000); - #[doc = "Optional"] - pub const CLIPPING_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b1000000); - #[doc = "Optional"] - pub const FRAGMENT_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10000000); - #[doc = "Optional"] - pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = - QueryPipelineStatisticFlags(0b100000000); - #[doc = "Optional"] - pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = - QueryPipelineStatisticFlags(0b1000000000); - #[doc = "Optional"] - pub const COMPUTE_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10000000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ImageAspectFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); - impl ImageAspectFlags { - pub const COLOR: Self = ImageAspectFlags(0b1); - pub const DEPTH: Self = ImageAspectFlags(0b10); - pub const STENCIL: Self = ImageAspectFlags(0b100); - pub const METADATA: Self = ImageAspectFlags(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SparseImageFormatFlags(pub(crate) Flags); - vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); - impl SparseImageFormatFlags { - #[doc = "Image uses a single mip tail region for all array layers"] - pub const SINGLE_MIPTAIL: Self = SparseImageFormatFlags(0b1); - #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] - pub const ALIGNED_MIP_SIZE: Self = SparseImageFormatFlags(0b10); - #[doc = "Image uses a non-standard sparse image block dimensions"] - pub const NONSTANDARD_BLOCK_SIZE: Self = SparseImageFormatFlags(0b100); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SparseMemoryBindFlags(pub(crate) Flags); - vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); - impl SparseMemoryBindFlags { - #[doc = "Operation binds resource metadata to memory"] - pub const METADATA: Self = SparseMemoryBindFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct PipelineStageFlags(pub(crate) Flags); - vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); - impl PipelineStageFlags { - #[doc = "Before subsequent commands are processed"] - pub const TOP_OF_PIPE: Self = PipelineStageFlags(0b1); - #[doc = "Draw/DispatchIndirect command fetch"] - pub const DRAW_INDIRECT: Self = PipelineStageFlags(0b10); - #[doc = "Vertex/index fetch"] - pub const VERTEX_INPUT: Self = PipelineStageFlags(0b100); - #[doc = "Vertex shading"] - pub const VERTEX_SHADER: Self = PipelineStageFlags(0b1000); - #[doc = "Tessellation control shading"] - pub const TESSELLATION_CONTROL_SHADER: Self = PipelineStageFlags(0b10000); - #[doc = "Tessellation evaluation shading"] - pub const TESSELLATION_EVALUATION_SHADER: Self = PipelineStageFlags(0b100000); - #[doc = "Geometry shading"] - pub const GEOMETRY_SHADER: Self = PipelineStageFlags(0b1000000); - #[doc = "Fragment shading"] - pub const FRAGMENT_SHADER: Self = PipelineStageFlags(0b10000000); - #[doc = "Early fragment (depth and stencil) tests"] - pub const EARLY_FRAGMENT_TESTS: Self = PipelineStageFlags(0b100000000); - #[doc = "Late fragment (depth and stencil) tests"] - pub const LATE_FRAGMENT_TESTS: Self = PipelineStageFlags(0b1000000000); - #[doc = "Color attachment writes"] - pub const COLOR_ATTACHMENT_OUTPUT: Self = PipelineStageFlags(0b10000000000); - #[doc = "Compute shading"] - pub const COMPUTE_SHADER: Self = PipelineStageFlags(0b100000000000); - #[doc = "Transfer/copy operations"] - pub const TRANSFER: Self = PipelineStageFlags(0b1000000000000); - #[doc = "After previous commands have completed"] - pub const BOTTOM_OF_PIPE: Self = PipelineStageFlags(0b10000000000000); - #[doc = "Indicates host (CPU) is a source/sink of the dependency"] - pub const HOST: Self = PipelineStageFlags(0b100000000000000); - #[doc = "All stages of the graphics pipeline"] - pub const ALL_GRAPHICS: Self = PipelineStageFlags(0b1000000000000000); - #[doc = "All stages supported on the queue"] - pub const ALL_COMMANDS: Self = PipelineStageFlags(0b10000000000000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct CommandPoolCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); - impl CommandPoolCreateFlags { - #[doc = "Command buffers have a short lifetime"] - pub const TRANSIENT: Self = CommandPoolCreateFlags(0b1); - #[doc = "Command buffers may release their memory individually"] - pub const RESET_COMMAND_BUFFER: Self = CommandPoolCreateFlags(0b10); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct CommandPoolResetFlags(pub(crate) Flags); - vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); - impl CommandPoolResetFlags { - #[doc = "Release resources owned by the pool"] - pub const RELEASE_RESOURCES: Self = CommandPoolResetFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct CommandBufferResetFlags(pub(crate) Flags); - vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); - impl CommandBufferResetFlags { - #[doc = "Release resources owned by the buffer"] - pub const RELEASE_RESOURCES: Self = CommandBufferResetFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SampleCountFlags(pub(crate) Flags); - vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); - impl SampleCountFlags { - #[doc = "Sample count 1 supported"] - pub const TYPE_1: Self = SampleCountFlags(0b1); - #[doc = "Sample count 2 supported"] - pub const TYPE_2: Self = SampleCountFlags(0b10); - #[doc = "Sample count 4 supported"] - pub const TYPE_4: Self = SampleCountFlags(0b100); - #[doc = "Sample count 8 supported"] - pub const TYPE_8: Self = SampleCountFlags(0b1000); - #[doc = "Sample count 16 supported"] - pub const TYPE_16: Self = SampleCountFlags(0b10000); - #[doc = "Sample count 32 supported"] - pub const TYPE_32: Self = SampleCountFlags(0b100000); - #[doc = "Sample count 64 supported"] - pub const TYPE_64: Self = SampleCountFlags(0b1000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct AttachmentDescriptionFlags(pub(crate) Flags); - vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); - impl AttachmentDescriptionFlags { - #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] - pub const MAY_ALIAS: Self = AttachmentDescriptionFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct StencilFaceFlags(pub(crate) Flags); - vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); - impl StencilFaceFlags { - #[doc = "Front face"] - pub const FRONT: Self = StencilFaceFlags(0b1); - #[doc = "Back face"] - pub const BACK: Self = StencilFaceFlags(0b10); - #[doc = "Front and back faces"] - pub const STENCIL_FRONT_AND_BACK: Self = StencilFaceFlags(0x00000003); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DescriptorPoolCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); - impl DescriptorPoolCreateFlags { - #[doc = "Descriptor sets may be freed individually"] - pub const FREE_DESCRIPTOR_SET: Self = DescriptorPoolCreateFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DependencyFlags(pub(crate) Flags); - vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); - impl DependencyFlags { - #[doc = "Dependency is per pixel region "] - pub const BY_REGION: Self = DependencyFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); - vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); - impl DisplayPlaneAlphaFlagsKHR { - pub const OPAQUE: Self = DisplayPlaneAlphaFlagsKHR(0b1); - pub const GLOBAL: Self = DisplayPlaneAlphaFlagsKHR(0b10); - pub const PER_PIXEL: Self = DisplayPlaneAlphaFlagsKHR(0b100); - pub const PER_PIXEL_PREMULTIPLIED: Self = DisplayPlaneAlphaFlagsKHR(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); - vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); - impl CompositeAlphaFlagsKHR { - pub const OPAQUE: Self = CompositeAlphaFlagsKHR(0b1); - pub const PRE_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b10); - pub const POST_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b100); - pub const INHERIT: Self = CompositeAlphaFlagsKHR(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); - vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); - impl SurfaceTransformFlagsKHR { - pub const IDENTITY: Self = SurfaceTransformFlagsKHR(0b1); - pub const ROTATE_90: Self = SurfaceTransformFlagsKHR(0b10); - pub const ROTATE_180: Self = SurfaceTransformFlagsKHR(0b100); - pub const ROTATE_270: Self = SurfaceTransformFlagsKHR(0b1000); - pub const HORIZONTAL_MIRROR: Self = SurfaceTransformFlagsKHR(0b10000); - pub const HORIZONTAL_MIRROR_ROTATE_90: Self = SurfaceTransformFlagsKHR(0b100000); - pub const HORIZONTAL_MIRROR_ROTATE_180: Self = SurfaceTransformFlagsKHR(0b1000000); - pub const HORIZONTAL_MIRROR_ROTATE_270: Self = SurfaceTransformFlagsKHR(0b10000000); - pub const INHERIT: Self = SurfaceTransformFlagsKHR(0b100000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DebugReportFlagsEXT(pub(crate) Flags); - vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); - impl DebugReportFlagsEXT { - pub const INFORMATION: Self = DebugReportFlagsEXT(0b1); - pub const WARNING: Self = DebugReportFlagsEXT(0b10); - pub const PERFORMANCE_WARNING: Self = DebugReportFlagsEXT(0b100); - pub const ERROR: Self = DebugReportFlagsEXT(0b1000); - pub const DEBUG: Self = DebugReportFlagsEXT(0b10000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); - impl ExternalMemoryHandleTypeFlagsNV { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV: Self = - ExternalMemoryHandleTypeFlagsNV(0b1); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV: Self = - ExternalMemoryHandleTypeFlagsNV(0b10); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV: Self = - ExternalMemoryHandleTypeFlagsNV(0b100); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV: Self = - ExternalMemoryHandleTypeFlagsNV(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); - impl ExternalMemoryFeatureFlagsNV { - pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV: Self = - ExternalMemoryFeatureFlagsNV(0b1); - pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10); - pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SubgroupFeatureFlags(pub(crate) Flags); - vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); - impl SubgroupFeatureFlags { - #[doc = "Basic subgroup operations"] - pub const BASIC: Self = SubgroupFeatureFlags(0b1); - #[doc = "Vote subgroup operations"] - pub const VOTE: Self = SubgroupFeatureFlags(0b10); - #[doc = "Arithmetic subgroup operations"] - pub const ARITHMETIC: Self = SubgroupFeatureFlags(0b100); - #[doc = "Ballot subgroup operations"] - pub const BALLOT: Self = SubgroupFeatureFlags(0b1000); - #[doc = "Shuffle subgroup operations"] - pub const SHUFFLE: Self = SubgroupFeatureFlags(0b10000); - #[doc = "Shuffle relative subgroup operations"] - pub const SHUFFLE_RELATIVE: Self = SubgroupFeatureFlags(0b100000); - #[doc = "Clustered subgroup operations"] - pub const CLUSTERED: Self = SubgroupFeatureFlags(0b1000000); - #[doc = "Quad subgroup operations"] - pub const QUAD: Self = SubgroupFeatureFlags(0b10000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct IndirectCommandsLayoutUsageFlagsNVX(pub(crate) Flags); - vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); - impl IndirectCommandsLayoutUsageFlagsNVX { - pub const UNORDERED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1); - pub const SPARSE_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b10); - pub const EMPTY_EXECUTIONS: Self = IndirectCommandsLayoutUsageFlagsNVX(0b100); - pub const INDEXED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ObjectEntryUsageFlagsNVX(pub(crate) Flags); - vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); - impl ObjectEntryUsageFlagsNVX { - pub const GRAPHICS: Self = ObjectEntryUsageFlagsNVX(0b1); - pub const COMPUTE: Self = ObjectEntryUsageFlagsNVX(0b10); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); - impl DescriptorSetLayoutCreateFlags {} - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); - impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: Self = ExternalMemoryHandleTypeFlags(0b1); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32: Self = - ExternalMemoryHandleTypeFlags(0b10); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = - ExternalMemoryHandleTypeFlags(0b100); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE: Self = - ExternalMemoryHandleTypeFlags(0b1000); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT: Self = - ExternalMemoryHandleTypeFlags(0b10000); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP: Self = - ExternalMemoryHandleTypeFlags(0b100000); - pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: Self = - ExternalMemoryHandleTypeFlags(0b1000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); - impl ExternalMemoryFeatureFlags { - pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY: Self = ExternalMemoryFeatureFlags(0b1); - pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10); - pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); - impl ExternalSemaphoreHandleTypeFlags { - pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: Self = - ExternalSemaphoreHandleTypeFlags(0b1); - pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32: Self = - ExternalSemaphoreHandleTypeFlags(0b10); - pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = - ExternalSemaphoreHandleTypeFlags(0b100); - pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE: Self = - ExternalSemaphoreHandleTypeFlags(0b1000); - pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: Self = - ExternalSemaphoreHandleTypeFlags(0b10000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); - impl ExternalSemaphoreFeatureFlags { - pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1); - pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SemaphoreImportFlags(pub(crate) Flags); - vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); - impl SemaphoreImportFlags { - pub const TEMPORARY: Self = SemaphoreImportFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); - impl ExternalFenceHandleTypeFlags { - pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD: Self = ExternalFenceHandleTypeFlags(0b1); - pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32: Self = - ExternalFenceHandleTypeFlags(0b10); - pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = - ExternalFenceHandleTypeFlags(0b100); - pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct ExternalFenceFeatureFlags(pub(crate) Flags); - vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); - impl ExternalFenceFeatureFlags { - pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1); - pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct FenceImportFlags(pub(crate) Flags); - vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); - impl FenceImportFlags { - pub const TEMPORARY: Self = FenceImportFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); - vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); - impl SurfaceCounterFlagsEXT { - pub const VBLANK: Self = SurfaceCounterFlagsEXT(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct PeerMemoryFeatureFlags(pub(crate) Flags); - vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); - impl PeerMemoryFeatureFlags { - #[doc = "Can read with vkCmdCopy commands"] - pub const COPY_SRC: Self = PeerMemoryFeatureFlags(0b1); - #[doc = "Can write with vkCmdCopy commands"] - pub const COPY_DST: Self = PeerMemoryFeatureFlags(0b10); - #[doc = "Can read with any access type/command"] - pub const GENERIC_SRC: Self = PeerMemoryFeatureFlags(0b100); - #[doc = "Can write with and access type/command"] - pub const GENERIC_DST: Self = PeerMemoryFeatureFlags(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct MemoryAllocateFlags(pub(crate) Flags); - vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); - impl MemoryAllocateFlags { - #[doc = "Force allocation on specific devices"] - pub const DEVICE_MASK: Self = MemoryAllocateFlags(0b1); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); - vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); - impl DeviceGroupPresentModeFlagsKHR { - #[doc = "Present from local memory"] - pub const LOCAL: Self = DeviceGroupPresentModeFlagsKHR(0b1); - #[doc = "Present from remote memory"] - pub const REMOTE: Self = DeviceGroupPresentModeFlagsKHR(0b10); - #[doc = "Present sum of local and/or remote memory"] - pub const SUM: Self = DeviceGroupPresentModeFlagsKHR(0b100); - #[doc = "Each physical device presents from local memory"] - pub const LOCAL_MULTI_DEVICE: Self = DeviceGroupPresentModeFlagsKHR(0b1000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); - vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); - impl SwapchainCreateFlagsKHR {} - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SubpassDescriptionFlags(pub(crate) Flags); - vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); - impl SubpassDescriptionFlags {} - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); - vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); - impl DebugUtilsMessageSeverityFlagsEXT { - pub const VERBOSE: Self = DebugUtilsMessageSeverityFlagsEXT(0b1); - pub const INFO: Self = DebugUtilsMessageSeverityFlagsEXT(0b10000); - pub const WARNING: Self = DebugUtilsMessageSeverityFlagsEXT(0b100000000); - pub const ERROR: Self = DebugUtilsMessageSeverityFlagsEXT(0b1000000000000); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); - vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); - impl DebugUtilsMessageTypeFlagsEXT { - pub const GENERAL: Self = DebugUtilsMessageTypeFlagsEXT(0b1); - pub const VALIDATION: Self = DebugUtilsMessageTypeFlagsEXT(0b10); - pub const PERFORMANCE: Self = DebugUtilsMessageTypeFlagsEXT(0b100); - } - #[repr(transparent)] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct DescriptorBindingFlagsEXT(pub(crate) Flags); - vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); - impl DescriptorBindingFlagsEXT { - pub const UPDATE_AFTER_BIND: Self = DescriptorBindingFlagsEXT(0b1); - pub const UPDATE_UNUSED_WHILE_PENDING: Self = DescriptorBindingFlagsEXT(0b10); - pub const PARTIALLY_BOUND: Self = DescriptorBindingFlagsEXT(0b100); - pub const VARIABLE_DESCRIPTOR_COUNT: Self = DescriptorBindingFlagsEXT(0b1000); - } +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CullModeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); +impl CullModeFlags { + pub const NONE: Self = CullModeFlags(0); + pub const FRONT: Self = CullModeFlags(0b1); + pub const BACK: Self = CullModeFlags(0b10); + pub const FRONT_AND_BACK: Self = CullModeFlags(0x00000003); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueueFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); +impl QueueFlags { + #[doc = "Queue supports graphics operations"] + pub const GRAPHICS: Self = QueueFlags(0b1); + #[doc = "Queue supports compute operations"] + pub const COMPUTE: Self = QueueFlags(0b10); + #[doc = "Queue supports transfer operations"] + pub const TRANSFER: Self = QueueFlags(0b100); + #[doc = "Queue supports sparse resource memory management operations"] + pub const SPARSE_BINDING: Self = QueueFlags(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DeviceQueueCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); +impl DeviceQueueCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MemoryPropertyFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryPropertyFlags, 0b11111, Flags); +impl MemoryPropertyFlags { + #[doc = "If otherwise stated, then allocate memory on device"] + pub const DEVICE_LOCAL: Self = MemoryPropertyFlags(0b1); + #[doc = "Memory is mappable by host"] + pub const HOST_VISIBLE: Self = MemoryPropertyFlags(0b10); + #[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"] + pub const HOST_COHERENT: Self = MemoryPropertyFlags(0b100); + #[doc = "Memory will be cached by the host"] + pub const HOST_CACHED: Self = MemoryPropertyFlags(0b1000); + #[doc = "Memory may be allocated by the driver when it is required"] + pub const LAZILY_ALLOCATED: Self = MemoryPropertyFlags(0b10000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MemoryHeapFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); +impl MemoryHeapFlags { + #[doc = "If set, heap represents device memory"] + pub const DEVICE_LOCAL: Self = MemoryHeapFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct AccessFlags(pub(crate) Flags); +vk_bitflags_wrapped!(AccessFlags, 0b11111111111111111, Flags); +impl AccessFlags { + #[doc = "Controls coherency of indirect command reads"] + pub const INDIRECT_COMMAND_READ: Self = AccessFlags(0b1); + #[doc = "Controls coherency of index reads"] + pub const INDEX_READ: Self = AccessFlags(0b10); + #[doc = "Controls coherency of vertex attribute reads"] + pub const VERTEX_ATTRIBUTE_READ: Self = AccessFlags(0b100); + #[doc = "Controls coherency of uniform buffer reads"] + pub const UNIFORM_READ: Self = AccessFlags(0b1000); + #[doc = "Controls coherency of input attachment reads"] + pub const INPUT_ATTACHMENT_READ: Self = AccessFlags(0b10000); + #[doc = "Controls coherency of shader reads"] + pub const SHADER_READ: Self = AccessFlags(0b100000); + #[doc = "Controls coherency of shader writes"] + pub const SHADER_WRITE: Self = AccessFlags(0b1000000); + #[doc = "Controls coherency of color attachment reads"] + pub const COLOR_ATTACHMENT_READ: Self = AccessFlags(0b10000000); + #[doc = "Controls coherency of color attachment writes"] + pub const COLOR_ATTACHMENT_WRITE: Self = AccessFlags(0b100000000); + #[doc = "Controls coherency of depth/stencil attachment reads"] + pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = AccessFlags(0b1000000000); + #[doc = "Controls coherency of depth/stencil attachment writes"] + pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = AccessFlags(0b10000000000); + #[doc = "Controls coherency of transfer reads"] + pub const TRANSFER_READ: Self = AccessFlags(0b100000000000); + #[doc = "Controls coherency of transfer writes"] + pub const TRANSFER_WRITE: Self = AccessFlags(0b1000000000000); + #[doc = "Controls coherency of host reads"] + pub const HOST_READ: Self = AccessFlags(0b10000000000000); + #[doc = "Controls coherency of host writes"] + pub const HOST_WRITE: Self = AccessFlags(0b100000000000000); + #[doc = "Controls coherency of memory reads"] + pub const MEMORY_READ: Self = AccessFlags(0b1000000000000000); + #[doc = "Controls coherency of memory writes"] + pub const MEMORY_WRITE: Self = AccessFlags(0b10000000000000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct BufferUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferUsageFlags, 0b111111111, Flags); +impl BufferUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = BufferUsageFlags(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = BufferUsageFlags(0b10); + #[doc = "Can be used as TBO"] + pub const UNIFORM_TEXEL_BUFFER: Self = BufferUsageFlags(0b100); + #[doc = "Can be used as IBO"] + pub const STORAGE_TEXEL_BUFFER: Self = BufferUsageFlags(0b1000); + #[doc = "Can be used as UBO"] + pub const UNIFORM_BUFFER: Self = BufferUsageFlags(0b10000); + #[doc = "Can be used as SSBO"] + pub const STORAGE_BUFFER: Self = BufferUsageFlags(0b100000); + #[doc = "Can be used as source of fixed-function index fetch (index buffer)"] + pub const INDEX_BUFFER: Self = BufferUsageFlags(0b1000000); + #[doc = "Can be used as source of fixed-function vertex fetch (VBO)"] + pub const VERTEX_BUFFER: Self = BufferUsageFlags(0b10000000); + #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"] + pub const INDIRECT_BUFFER: Self = BufferUsageFlags(0b100000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct BufferCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); +impl BufferCreateFlags { + #[doc = "Buffer should support sparse backing"] + pub const SPARSE_BINDING: Self = BufferCreateFlags(0b1); + #[doc = "Buffer should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = BufferCreateFlags(0b10); + #[doc = "Buffer should support constent data access to physical memory ranges mapped into multiple locations of sparse buffers"] + pub const SPARSE_ALIASED: Self = BufferCreateFlags(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ShaderStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderStageFlags, 0b1111111111111111111111111111111, Flags); +impl ShaderStageFlags { + pub const VERTEX: Self = ShaderStageFlags(0b1); + pub const TESSELLATION_CONTROL: Self = ShaderStageFlags(0b10); + pub const TESSELLATION_EVALUATION: Self = ShaderStageFlags(0b100); + pub const GEOMETRY: Self = ShaderStageFlags(0b1000); + pub const FRAGMENT: Self = ShaderStageFlags(0b10000); + pub const COMPUTE: Self = ShaderStageFlags(0b100000); + pub const ALL_GRAPHICS: Self = ShaderStageFlags(0x0000001F); + pub const ALL: Self = ShaderStageFlags(0x7FFFFFFF); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ImageUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageUsageFlags, 0b11111111, Flags); +impl ImageUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = ImageUsageFlags(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = ImageUsageFlags(0b10); + #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED: Self = ImageUsageFlags(0b100); + #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"] + pub const STORAGE: Self = ImageUsageFlags(0b1000); + #[doc = "Can be used as framebuffer color attachment"] + pub const COLOR_ATTACHMENT: Self = ImageUsageFlags(0b10000); + #[doc = "Can be used as framebuffer depth/stencil attachment"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = ImageUsageFlags(0b100000); + #[doc = "Image data not needed outside of rendering"] + pub const TRANSIENT_ATTACHMENT: Self = ImageUsageFlags(0b1000000); + #[doc = "Can be used as framebuffer input attachment"] + pub const INPUT_ATTACHMENT: Self = ImageUsageFlags(0b10000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ImageCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCreateFlags, 0b11111, Flags); +impl ImageCreateFlags { + #[doc = "Image should support sparse backing"] + pub const SPARSE_BINDING: Self = ImageCreateFlags(0b1); + #[doc = "Image should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = ImageCreateFlags(0b10); + #[doc = "Image should support constent data access to physical memory ranges mapped into multiple locations of sparse images"] + pub const SPARSE_ALIASED: Self = ImageCreateFlags(0b100); + #[doc = "Allows image views to have different format than the base image"] + pub const MUTABLE_FORMAT: Self = ImageCreateFlags(0b1000); + #[doc = "Allows creating image views with cube type from the created image"] + pub const CUBE_COMPATIBLE: Self = ImageCreateFlags(0b10000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); +impl PipelineCreateFlags { + pub const DISABLE_OPTIMIZATION: Self = PipelineCreateFlags(0b1); + pub const ALLOW_DERIVATIVES: Self = PipelineCreateFlags(0b10); + pub const DERIVATIVE: Self = PipelineCreateFlags(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ColorComponentFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); +impl ColorComponentFlags { + pub const R: Self = ColorComponentFlags(0b1); + pub const G: Self = ColorComponentFlags(0b10); + pub const B: Self = ColorComponentFlags(0b100); + pub const A: Self = ColorComponentFlags(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FenceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); +impl FenceCreateFlags { + pub const SIGNALED: Self = FenceCreateFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FormatFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FormatFeatureFlags, 0b1111111111111, Flags); +impl FormatFeatureFlags { + #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED_IMAGE: Self = FormatFeatureFlags(0b1); + #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] + pub const STORAGE_IMAGE: Self = FormatFeatureFlags(0b10); + #[doc = "Format supports atomic operations in case it is used for storage images"] + pub const STORAGE_IMAGE_ATOMIC: Self = FormatFeatureFlags(0b100); + #[doc = "Format can be used for uniform texel buffers (TBOs)"] + pub const UNIFORM_TEXEL_BUFFER: Self = FormatFeatureFlags(0b1000); + #[doc = "Format can be used for storage texel buffers (IBOs)"] + pub const STORAGE_TEXEL_BUFFER: Self = FormatFeatureFlags(0b10000); + #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] + pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = FormatFeatureFlags(0b100000); + #[doc = "Format can be used for vertex buffers (VBOs)"] + pub const VERTEX_BUFFER: Self = FormatFeatureFlags(0b1000000); + #[doc = "Format can be used for color attachment images"] + pub const COLOR_ATTACHMENT: Self = FormatFeatureFlags(0b10000000); + #[doc = "Format supports blending in case it is used for color attachment images"] + pub const COLOR_ATTACHMENT_BLEND: Self = FormatFeatureFlags(0b100000000); + #[doc = "Format can be used for depth/stencil attachment images"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = FormatFeatureFlags(0b1000000000); + #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] + pub const BLIT_SRC: Self = FormatFeatureFlags(0b10000000000); + #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] + pub const BLIT_DST: Self = FormatFeatureFlags(0b100000000000); + #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] + pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = FormatFeatureFlags(0b1000000000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueryControlFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); +impl QueryControlFlags { + #[doc = "Require precise results to be collected by the query"] + pub const PRECISE: Self = QueryControlFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueryResultFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); +impl QueryResultFlags { + #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] + pub const TYPE_64: Self = QueryResultFlags(0b1); + #[doc = "Results of the queries are waited on before proceeding with the result copy"] + pub const WAIT: Self = QueryResultFlags(0b10); + #[doc = "Besides the results of the query, the availability of the results is also written"] + pub const WITH_AVAILABILITY: Self = QueryResultFlags(0b100); + #[doc = "Copy the partial results of the query even if the final results are not available"] + pub const PARTIAL: Self = QueryResultFlags(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandBufferUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); +impl CommandBufferUsageFlags { + pub const ONE_TIME_SUBMIT: Self = CommandBufferUsageFlags(0b1); + pub const RENDER_PASS_CONTINUE: Self = CommandBufferUsageFlags(0b10); + #[doc = "Command buffer may be submitted/executed more than once simultaneously"] + pub const SIMULTANEOUS_USE: Self = CommandBufferUsageFlags(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct QueryPipelineStatisticFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b11111111111, Flags); +impl QueryPipelineStatisticFlags { + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_VERTICES: Self = QueryPipelineStatisticFlags(0b1); + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10); + #[doc = "Optional"] + pub const VERTEX_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b1000); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10000); + #[doc = "Optional"] + pub const CLIPPING_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100000); + #[doc = "Optional"] + pub const CLIPPING_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b1000000); + #[doc = "Optional"] + pub const FRAGMENT_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10000000); + #[doc = "Optional"] + pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = QueryPipelineStatisticFlags(0b100000000); + #[doc = "Optional"] + pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = + QueryPipelineStatisticFlags(0b1000000000); + #[doc = "Optional"] + pub const COMPUTE_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10000000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ImageAspectFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); +impl ImageAspectFlags { + pub const COLOR: Self = ImageAspectFlags(0b1); + pub const DEPTH: Self = ImageAspectFlags(0b10); + pub const STENCIL: Self = ImageAspectFlags(0b100); + pub const METADATA: Self = ImageAspectFlags(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SparseImageFormatFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); +impl SparseImageFormatFlags { + #[doc = "Image uses a single mip tail region for all array layers"] + pub const SINGLE_MIPTAIL: Self = SparseImageFormatFlags(0b1); + #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] + pub const ALIGNED_MIP_SIZE: Self = SparseImageFormatFlags(0b10); + #[doc = "Image uses a non-standard sparse image block dimensions"] + pub const NONSTANDARD_BLOCK_SIZE: Self = SparseImageFormatFlags(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SparseMemoryBindFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); +impl SparseMemoryBindFlags { + #[doc = "Operation binds resource metadata to memory"] + pub const METADATA: Self = SparseMemoryBindFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PipelineStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineStageFlags, 0b11111111111111111, Flags); +impl PipelineStageFlags { + #[doc = "Before subsequent commands are processed"] + pub const TOP_OF_PIPE: Self = PipelineStageFlags(0b1); + #[doc = "Draw/DispatchIndirect command fetch"] + pub const DRAW_INDIRECT: Self = PipelineStageFlags(0b10); + #[doc = "Vertex/index fetch"] + pub const VERTEX_INPUT: Self = PipelineStageFlags(0b100); + #[doc = "Vertex shading"] + pub const VERTEX_SHADER: Self = PipelineStageFlags(0b1000); + #[doc = "Tessellation control shading"] + pub const TESSELLATION_CONTROL_SHADER: Self = PipelineStageFlags(0b10000); + #[doc = "Tessellation evaluation shading"] + pub const TESSELLATION_EVALUATION_SHADER: Self = PipelineStageFlags(0b100000); + #[doc = "Geometry shading"] + pub const GEOMETRY_SHADER: Self = PipelineStageFlags(0b1000000); + #[doc = "Fragment shading"] + pub const FRAGMENT_SHADER: Self = PipelineStageFlags(0b10000000); + #[doc = "Early fragment (depth and stencil) tests"] + pub const EARLY_FRAGMENT_TESTS: Self = PipelineStageFlags(0b100000000); + #[doc = "Late fragment (depth and stencil) tests"] + pub const LATE_FRAGMENT_TESTS: Self = PipelineStageFlags(0b1000000000); + #[doc = "Color attachment writes"] + pub const COLOR_ATTACHMENT_OUTPUT: Self = PipelineStageFlags(0b10000000000); + #[doc = "Compute shading"] + pub const COMPUTE_SHADER: Self = PipelineStageFlags(0b100000000000); + #[doc = "Transfer/copy operations"] + pub const TRANSFER: Self = PipelineStageFlags(0b1000000000000); + #[doc = "After previous commands have completed"] + pub const BOTTOM_OF_PIPE: Self = PipelineStageFlags(0b10000000000000); + #[doc = "Indicates host (CPU) is a source/sink of the dependency"] + pub const HOST: Self = PipelineStageFlags(0b100000000000000); + #[doc = "All stages of the graphics pipeline"] + pub const ALL_GRAPHICS: Self = PipelineStageFlags(0b1000000000000000); + #[doc = "All stages supported on the queue"] + pub const ALL_COMMANDS: Self = PipelineStageFlags(0b10000000000000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); +impl CommandPoolCreateFlags { + #[doc = "Command buffers have a short lifetime"] + pub const TRANSIENT: Self = CommandPoolCreateFlags(0b1); + #[doc = "Command buffers may release their memory individually"] + pub const RESET_COMMAND_BUFFER: Self = CommandPoolCreateFlags(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandPoolResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); +impl CommandPoolResetFlags { + #[doc = "Release resources owned by the pool"] + pub const RELEASE_RESOURCES: Self = CommandPoolResetFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CommandBufferResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); +impl CommandBufferResetFlags { + #[doc = "Release resources owned by the buffer"] + pub const RELEASE_RESOURCES: Self = CommandBufferResetFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SampleCountFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SampleCountFlags, 0b1111111, Flags); +impl SampleCountFlags { + #[doc = "Sample count 1 supported"] + pub const TYPE_1: Self = SampleCountFlags(0b1); + #[doc = "Sample count 2 supported"] + pub const TYPE_2: Self = SampleCountFlags(0b10); + #[doc = "Sample count 4 supported"] + pub const TYPE_4: Self = SampleCountFlags(0b100); + #[doc = "Sample count 8 supported"] + pub const TYPE_8: Self = SampleCountFlags(0b1000); + #[doc = "Sample count 16 supported"] + pub const TYPE_16: Self = SampleCountFlags(0b10000); + #[doc = "Sample count 32 supported"] + pub const TYPE_32: Self = SampleCountFlags(0b100000); + #[doc = "Sample count 64 supported"] + pub const TYPE_64: Self = SampleCountFlags(0b1000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct AttachmentDescriptionFlags(pub(crate) Flags); +vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); +impl AttachmentDescriptionFlags { + #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] + pub const MAY_ALIAS: Self = AttachmentDescriptionFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct StencilFaceFlags(pub(crate) Flags); +vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); +impl StencilFaceFlags { + #[doc = "Front face"] + pub const FRONT: Self = StencilFaceFlags(0b1); + #[doc = "Back face"] + pub const BACK: Self = StencilFaceFlags(0b10); + #[doc = "Front and back faces"] + pub const STENCIL_FRONT_AND_BACK: Self = StencilFaceFlags(0x00000003); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); +impl DescriptorPoolCreateFlags { + #[doc = "Descriptor sets may be freed individually"] + pub const FREE_DESCRIPTOR_SET: Self = DescriptorPoolCreateFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DependencyFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); +impl DependencyFlags { + #[doc = "Dependency is per pixel region "] + pub const BY_REGION: Self = DependencyFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); +impl DisplayPlaneAlphaFlagsKHR { + pub const OPAQUE: Self = DisplayPlaneAlphaFlagsKHR(0b1); + pub const GLOBAL: Self = DisplayPlaneAlphaFlagsKHR(0b10); + pub const PER_PIXEL: Self = DisplayPlaneAlphaFlagsKHR(0b100); + pub const PER_PIXEL_PREMULTIPLIED: Self = DisplayPlaneAlphaFlagsKHR(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); +impl CompositeAlphaFlagsKHR { + pub const OPAQUE: Self = CompositeAlphaFlagsKHR(0b1); + pub const PRE_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b10); + pub const POST_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b100); + pub const INHERIT: Self = CompositeAlphaFlagsKHR(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b111111111, Flags); +impl SurfaceTransformFlagsKHR { + pub const IDENTITY: Self = SurfaceTransformFlagsKHR(0b1); + pub const ROTATE_90: Self = SurfaceTransformFlagsKHR(0b10); + pub const ROTATE_180: Self = SurfaceTransformFlagsKHR(0b100); + pub const ROTATE_270: Self = SurfaceTransformFlagsKHR(0b1000); + pub const HORIZONTAL_MIRROR: Self = SurfaceTransformFlagsKHR(0b10000); + pub const HORIZONTAL_MIRROR_ROTATE_90: Self = SurfaceTransformFlagsKHR(0b100000); + pub const HORIZONTAL_MIRROR_ROTATE_180: Self = SurfaceTransformFlagsKHR(0b1000000); + pub const HORIZONTAL_MIRROR_ROTATE_270: Self = SurfaceTransformFlagsKHR(0b10000000); + pub const INHERIT: Self = SurfaceTransformFlagsKHR(0b100000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugReportFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); +impl DebugReportFlagsEXT { + pub const INFORMATION: Self = DebugReportFlagsEXT(0b1); + pub const WARNING: Self = DebugReportFlagsEXT(0b10); + pub const PERFORMANCE_WARNING: Self = DebugReportFlagsEXT(0b100); + pub const ERROR: Self = DebugReportFlagsEXT(0b1000); + pub const DEBUG: Self = DebugReportFlagsEXT(0b10000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); +impl ExternalMemoryHandleTypeFlagsNV { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b1); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b10); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b100); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV: Self = + ExternalMemoryHandleTypeFlagsNV(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); +impl ExternalMemoryFeatureFlagsNV { + pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV: Self = ExternalMemoryFeatureFlagsNV(0b1); + pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10); + pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SubgroupFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b11111111, Flags); +impl SubgroupFeatureFlags { + #[doc = "Basic subgroup operations"] + pub const BASIC: Self = SubgroupFeatureFlags(0b1); + #[doc = "Vote subgroup operations"] + pub const VOTE: Self = SubgroupFeatureFlags(0b10); + #[doc = "Arithmetic subgroup operations"] + pub const ARITHMETIC: Self = SubgroupFeatureFlags(0b100); + #[doc = "Ballot subgroup operations"] + pub const BALLOT: Self = SubgroupFeatureFlags(0b1000); + #[doc = "Shuffle subgroup operations"] + pub const SHUFFLE: Self = SubgroupFeatureFlags(0b10000); + #[doc = "Shuffle relative subgroup operations"] + pub const SHUFFLE_RELATIVE: Self = SubgroupFeatureFlags(0b100000); + #[doc = "Clustered subgroup operations"] + pub const CLUSTERED: Self = SubgroupFeatureFlags(0b1000000); + #[doc = "Quad subgroup operations"] + pub const QUAD: Self = SubgroupFeatureFlags(0b10000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct IndirectCommandsLayoutUsageFlagsNVX(pub(crate) Flags); +vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNVX, 0b1111, Flags); +impl IndirectCommandsLayoutUsageFlagsNVX { + pub const UNORDERED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1); + pub const SPARSE_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b10); + pub const EMPTY_EXECUTIONS: Self = IndirectCommandsLayoutUsageFlagsNVX(0b100); + pub const INDEXED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNVX(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ObjectEntryUsageFlagsNVX(pub(crate) Flags); +vk_bitflags_wrapped!(ObjectEntryUsageFlagsNVX, 0b11, Flags); +impl ObjectEntryUsageFlagsNVX { + pub const GRAPHICS: Self = ObjectEntryUsageFlagsNVX(0b1); + pub const COMPUTE: Self = ObjectEntryUsageFlagsNVX(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); +impl DescriptorSetLayoutCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b1111111, Flags); +impl ExternalMemoryHandleTypeFlags { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: Self = ExternalMemoryHandleTypeFlags(0b1); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32: Self = ExternalMemoryHandleTypeFlags(0b10); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = + ExternalMemoryHandleTypeFlags(0b100); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE: Self = + ExternalMemoryHandleTypeFlags(0b1000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT: Self = + ExternalMemoryHandleTypeFlags(0b10000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP: Self = + ExternalMemoryHandleTypeFlags(0b100000); + pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: Self = + ExternalMemoryHandleTypeFlags(0b1000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); +impl ExternalMemoryFeatureFlags { + pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY: Self = ExternalMemoryFeatureFlags(0b1); + pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10); + pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b11111, Flags); +impl ExternalSemaphoreHandleTypeFlags { + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: Self = + ExternalSemaphoreHandleTypeFlags(0b1); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32: Self = + ExternalSemaphoreHandleTypeFlags(0b10); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = + ExternalSemaphoreHandleTypeFlags(0b100); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE: Self = + ExternalSemaphoreHandleTypeFlags(0b1000); + pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: Self = + ExternalSemaphoreHandleTypeFlags(0b10000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); +impl ExternalSemaphoreFeatureFlags { + pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1); + pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SemaphoreImportFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); +impl SemaphoreImportFlags { + pub const TEMPORARY: Self = SemaphoreImportFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); +impl ExternalFenceHandleTypeFlags { + pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD: Self = ExternalFenceHandleTypeFlags(0b1); + pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32: Self = ExternalFenceHandleTypeFlags(0b10); + pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self = + ExternalFenceHandleTypeFlags(0b100); + pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExternalFenceFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); +impl ExternalFenceFeatureFlags { + pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1); + pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FenceImportFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); +impl FenceImportFlags { + pub const TEMPORARY: Self = FenceImportFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); +impl SurfaceCounterFlagsEXT { + pub const VBLANK: Self = SurfaceCounterFlagsEXT(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PeerMemoryFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); +impl PeerMemoryFeatureFlags { + #[doc = "Can read with vkCmdCopy commands"] + pub const COPY_SRC: Self = PeerMemoryFeatureFlags(0b1); + #[doc = "Can write with vkCmdCopy commands"] + pub const COPY_DST: Self = PeerMemoryFeatureFlags(0b10); + #[doc = "Can read with any access type/command"] + pub const GENERIC_SRC: Self = PeerMemoryFeatureFlags(0b100); + #[doc = "Can write with and access type/command"] + pub const GENERIC_DST: Self = PeerMemoryFeatureFlags(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct MemoryAllocateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); +impl MemoryAllocateFlags { + #[doc = "Force allocation on specific devices"] + pub const DEVICE_MASK: Self = MemoryAllocateFlags(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); +impl DeviceGroupPresentModeFlagsKHR { + #[doc = "Present from local memory"] + pub const LOCAL: Self = DeviceGroupPresentModeFlagsKHR(0b1); + #[doc = "Present from remote memory"] + pub const REMOTE: Self = DeviceGroupPresentModeFlagsKHR(0b10); + #[doc = "Present sum of local and/or remote memory"] + pub const SUM: Self = DeviceGroupPresentModeFlagsKHR(0b100); + #[doc = "Each physical device presents from local memory"] + pub const LOCAL_MULTI_DEVICE: Self = DeviceGroupPresentModeFlagsKHR(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); +impl SwapchainCreateFlagsKHR {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SubpassDescriptionFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); +impl SubpassDescriptionFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1000100010001, Flags); +impl DebugUtilsMessageSeverityFlagsEXT { + pub const VERBOSE: Self = DebugUtilsMessageSeverityFlagsEXT(0b1); + pub const INFO: Self = DebugUtilsMessageSeverityFlagsEXT(0b10000); + pub const WARNING: Self = DebugUtilsMessageSeverityFlagsEXT(0b100000000); + pub const ERROR: Self = DebugUtilsMessageSeverityFlagsEXT(0b1000000000000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); +impl DebugUtilsMessageTypeFlagsEXT { + pub const GENERAL: Self = DebugUtilsMessageTypeFlagsEXT(0b1); + pub const VALIDATION: Self = DebugUtilsMessageTypeFlagsEXT(0b10); + pub const PERFORMANCE: Self = DebugUtilsMessageTypeFlagsEXT(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DescriptorBindingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorBindingFlagsEXT, 0b1111, Flags); +impl DescriptorBindingFlagsEXT { + pub const UPDATE_AFTER_BIND: Self = DescriptorBindingFlagsEXT(0b1); + pub const UPDATE_UNUSED_WHILE_PENDING: Self = DescriptorBindingFlagsEXT(0b10); + pub const PARTIALLY_BOUND: Self = DescriptorBindingFlagsEXT(0b100); + pub const VARIABLE_DESCRIPTOR_COUNT: Self = DescriptorBindingFlagsEXT(0b1000); } pub const MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; pub const UUID_SIZE: usize = 16; @@ -13794,9510 +13783,9468 @@ pub const QUEUE_FAMILY_EXTERNAL: u32 = !0 - 1; pub const QUEUE_FAMILY_FOREIGN_EXT: u32 = !0 - 2; pub const SUBPASS_EXTERNAL: u32 = !0; pub const MAX_DEVICE_GROUP_SIZE: usize = 32; -pub mod extensions { - use super::*; - pub struct KhrSurfaceFn { - destroy_surface_khr: extern "system" fn( - instance: Instance, - surface: SurfaceKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - get_physical_device_surface_support_khr: - extern "system" fn( - physical_device: PhysicalDevice, - queue_family_index: u32, - surface: SurfaceKHR, - p_supported: *mut Bool32, - ) -> Result, - get_physical_device_surface_capabilities_khr: - extern "system" fn( - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_capabilities: *mut SurfaceCapabilitiesKHR, - ) -> Result, - get_physical_device_surface_formats_khr: - extern "system" fn( - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_format_count: *mut u32, - p_surface_formats: *mut SurfaceFormatKHR, - ) -> Result, - get_physical_device_surface_present_modes_khr: - extern "system" fn( - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_present_mode_count: *mut u32, - p_present_modes: *mut PresentModeKHR, - ) -> Result, - } - unsafe impl Send for KhrSurfaceFn {} - unsafe impl Sync for KhrSurfaceFn {} - impl ::std::clone::Clone for KhrSurfaceFn { - fn clone(&self) -> Self { - KhrSurfaceFn { - destroy_surface_khr: self.destroy_surface_khr, - get_physical_device_surface_support_khr: self - .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: - self.get_physical_device_surface_capabilities_khr, - get_physical_device_surface_formats_khr: self - .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: - self.get_physical_device_surface_present_modes_khr, - } - } - } - impl KhrSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSurfaceFn { - destroy_surface_khr: unsafe { - let raw_name = stringify!(vkDestroySurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_formats_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_present_modes_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn destroy_surface_khr( - &self, - instance: Instance, - surface: SurfaceKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_surface_khr)(instance, surface, p_allocator) - } - pub unsafe fn get_physical_device_surface_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: u32, - surface: SurfaceKHR, - p_supported: *mut Bool32, - ) -> Result { - (self.get_physical_device_surface_support_khr)( - physical_device, - queue_family_index, - surface, - p_supported, - ) - } - pub unsafe fn get_physical_device_surface_capabilities_khr( - &self, +pub struct KhrSurfaceFn { + destroy_surface_khr: extern "system" fn( + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + get_physical_device_surface_support_khr: extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + surface: SurfaceKHR, + p_supported: *mut Bool32, + ) -> Result, + get_physical_device_surface_capabilities_khr: + extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, p_surface_capabilities: *mut SurfaceCapabilitiesKHR, - ) -> Result { - (self.get_physical_device_surface_capabilities_khr)( - physical_device, - surface, - p_surface_capabilities, - ) - } - pub unsafe fn get_physical_device_surface_formats_khr( - &self, + ) -> Result, + get_physical_device_surface_formats_khr: + extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, p_surface_format_count: *mut u32, p_surface_formats: *mut SurfaceFormatKHR, - ) -> Result { - (self.get_physical_device_surface_formats_khr)( - physical_device, - surface, - p_surface_format_count, - p_surface_formats, - ) - } - pub unsafe fn get_physical_device_surface_present_modes_khr( - &self, + ) -> Result, + get_physical_device_surface_present_modes_khr: + extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, p_present_mode_count: *mut u32, p_present_modes: *mut PresentModeKHR, - ) -> Result { - (self.get_physical_device_surface_present_modes_khr)( - physical_device, - surface, - p_present_mode_count, - p_present_modes, - ) - } - } - #[doc = "Generated from \'VK_KHR_surface\'"] - impl Result { - pub const ERROR_SURFACE_LOST_KHR: Self = Result(-1000000000); - } - #[doc = "Generated from \'VK_KHR_surface\'"] - impl Result { - pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Result(-1000000001); - } - #[doc = "Generated from \'VK_KHR_surface\'"] - impl ObjectType { - pub const SURFACE_KHR: Self = ObjectType(1000000000); - } - pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *mut SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *mut u32 , p_swapchain_images : *mut Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : u64 , semaphore : Semaphore , fence : Fence , p_image_index : *mut u32 , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } - unsafe impl Send for KhrSwapchainFn {} - unsafe impl Sync for KhrSwapchainFn {} - impl ::std::clone::Clone for KhrSwapchainFn { - fn clone(&self) -> Self { - KhrSwapchainFn { - create_swapchain_khr: self.create_swapchain_khr, - destroy_swapchain_khr: self.destroy_swapchain_khr, - get_swapchain_images_khr: self.get_swapchain_images_khr, - acquire_next_image_khr: self.acquire_next_image_khr, - queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, - acquire_next_image2_khr: self.acquire_next_image2_khr, - } - } - } - impl KhrSwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSwapchainFn { - create_swapchain_khr: unsafe { - let raw_name = stringify!(vkCreateSwapchainKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_swapchain_khr: unsafe { - let raw_name = stringify!(vkDestroySwapchainKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_swapchain_images_khr: unsafe { - let raw_name = stringify!(vkGetSwapchainImagesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_next_image_khr: unsafe { - let raw_name = stringify!(vkAcquireNextImageKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_present_khr: unsafe { - let raw_name = stringify!(vkQueuePresentKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_device_group_present_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_device_group_surface_present_modes_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_present_rectangles_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_next_image2_khr: unsafe { - let raw_name = stringify!(vkAcquireNextImage2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_swapchain_khr( - &self, - device: Device, - p_create_info: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchain: *mut SwapchainKHR, - ) -> Result { - (self.create_swapchain_khr)(device, p_create_info, p_allocator, p_swapchain) - } - pub unsafe fn destroy_swapchain_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_swapchain_khr)(device, swapchain, p_allocator) - } - pub unsafe fn get_swapchain_images_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - p_swapchain_image_count: *mut u32, - p_swapchain_images: *mut Image, - ) -> Result { - (self.get_swapchain_images_khr)( - device, - swapchain, - p_swapchain_image_count, - p_swapchain_images, - ) - } - pub unsafe fn acquire_next_image_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - timeout: u64, - semaphore: Semaphore, - fence: Fence, - p_image_index: *mut u32, - ) -> Result { - (self.acquire_next_image_khr)( - device, - swapchain, - timeout, - semaphore, - fence, - p_image_index, - ) - } - pub unsafe fn queue_present_khr( - &self, - queue: Queue, - p_present_info: *const PresentInfoKHR, - ) -> Result { - (self.queue_present_khr)(queue, p_present_info) - } - pub unsafe fn get_device_group_present_capabilities_khr( - &self, - device: Device, - p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, - ) -> Result { - (self.get_device_group_present_capabilities_khr)( - device, - p_device_group_present_capabilities, - ) - } - pub unsafe fn get_device_group_surface_present_modes_khr( - &self, - device: Device, - surface: SurfaceKHR, - p_modes: *mut DeviceGroupPresentModeFlagsKHR, - ) -> Result { - (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) - } - pub unsafe fn get_physical_device_present_rectangles_khr( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_rect_count: *mut u32, - p_rects: *mut Rect2D, - ) -> Result { - (self.get_physical_device_present_rectangles_khr)( - physical_device, - surface, - p_rect_count, - p_rects, - ) - } - pub unsafe fn acquire_next_image2_khr( - &self, - device: Device, - p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *mut u32, - ) -> Result { - (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) - } - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000001000); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const PRESENT_INFO_KHR: Self = StructureType(1000001001); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl ImageLayout { - pub const PRESENT_SRC_KHR: Self = ImageLayout(1000001002); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl Result { - pub const SUBOPTIMAL_KHR: Self = Result(1000001003); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl Result { - pub const ERROR_OUT_OF_DATE_KHR: Self = Result(-1000001004); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl ObjectType { - pub const SWAPCHAIN_KHR: Self = ObjectType(1000001000); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = StructureType(1000060007); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000060008); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = StructureType(1000060009); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = StructureType(1000060010); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = StructureType(1000060011); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl StructureType { - pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000060012); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl SwapchainCreateFlagsKHR { - pub const SPLIT_INSTANCE_BIND_REGIONS: Self = SwapchainCreateFlagsKHR(0b1); - } - #[doc = "Generated from \'VK_KHR_swapchain\'"] - impl SwapchainCreateFlagsKHR { - pub const PROTECTED: Self = SwapchainCreateFlagsKHR(0b10); - } - pub struct KhrDisplayFn { - get_physical_device_display_properties_khr: - extern "system" fn( - physical_device: PhysicalDevice, - p_property_count: *mut u32, - p_properties: *mut DisplayPropertiesKHR, - ) -> Result, - get_physical_device_display_plane_properties_khr: - extern "system" fn( - physical_device: PhysicalDevice, - p_property_count: *mut u32, - p_properties: *mut DisplayPlanePropertiesKHR, - ) -> Result, - get_display_plane_supported_displays_khr: - extern "system" fn( - physical_device: PhysicalDevice, - plane_index: u32, - p_display_count: *mut u32, - p_displays: *mut DisplayKHR, - ) -> Result, - get_display_mode_properties_khr: - extern "system" fn( - physical_device: PhysicalDevice, - display: DisplayKHR, - p_property_count: *mut u32, - p_properties: *mut DisplayModePropertiesKHR, - ) -> Result, - create_display_mode_khr: extern "system" fn( - physical_device: PhysicalDevice, - display: DisplayKHR, - p_create_info: *const DisplayModeCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_mode: *mut DisplayModeKHR, ) -> Result, - get_display_plane_capabilities_khr: - extern "system" fn( - physical_device: PhysicalDevice, - mode: DisplayModeKHR, - plane_index: u32, - p_capabilities: *mut DisplayPlaneCapabilitiesKHR, - ) -> Result, - create_display_plane_surface_khr: - extern "system" fn( - instance: Instance, - p_create_info: *const DisplaySurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, - } - unsafe impl Send for KhrDisplayFn {} - unsafe impl Sync for KhrDisplayFn {} - impl ::std::clone::Clone for KhrDisplayFn { - fn clone(&self) -> Self { - KhrDisplayFn { - get_physical_device_display_properties_khr: - self.get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: - self.get_physical_device_display_plane_properties_khr, - get_display_plane_supported_displays_khr: self - .get_display_plane_supported_displays_khr, - get_display_mode_properties_khr: self.get_display_mode_properties_khr, - create_display_mode_khr: self.create_display_mode_khr, - get_display_plane_capabilities_khr: self.get_display_plane_capabilities_khr, - create_display_plane_surface_khr: self.create_display_plane_surface_khr, - } +} +unsafe impl Send for KhrSurfaceFn {} +unsafe impl Sync for KhrSurfaceFn {} +impl ::std::clone::Clone for KhrSurfaceFn { + fn clone(&self) -> Self { + KhrSurfaceFn { + destroy_surface_khr: self.destroy_surface_khr, + get_physical_device_surface_support_khr: self.get_physical_device_surface_support_khr, + get_physical_device_surface_capabilities_khr: + self.get_physical_device_surface_capabilities_khr, + get_physical_device_surface_formats_khr: self.get_physical_device_surface_formats_khr, + get_physical_device_surface_present_modes_khr: + self.get_physical_device_surface_present_modes_khr, } } - impl KhrDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDisplayFn { - get_physical_device_display_properties_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_display_plane_properties_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_plane_supported_displays_khr: unsafe { - let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_mode_properties_khr: unsafe { - let raw_name = stringify!(vkGetDisplayModePropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_display_mode_khr: unsafe { - let raw_name = stringify!(vkCreateDisplayModeKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_plane_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_display_plane_surface_khr: unsafe { - let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSurfaceFn { + destroy_surface_khr: unsafe { + let raw_name = stringify!(vkDestroySurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_formats_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn get_physical_device_display_properties_khr( - &self, + } + pub unsafe fn destroy_surface_khr( + &self, + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_surface_khr)(instance, surface, p_allocator) + } + pub unsafe fn get_physical_device_surface_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: u32, + surface: SurfaceKHR, + p_supported: *mut Bool32, + ) -> Result { + (self.get_physical_device_surface_support_khr)( + physical_device, + queue_family_index, + surface, + p_supported, + ) + } + pub unsafe fn get_physical_device_surface_capabilities_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *mut SurfaceCapabilitiesKHR, + ) -> Result { + (self.get_physical_device_surface_capabilities_khr)( + physical_device, + surface, + p_surface_capabilities, + ) + } + pub unsafe fn get_physical_device_surface_formats_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_format_count: *mut u32, + p_surface_formats: *mut SurfaceFormatKHR, + ) -> Result { + (self.get_physical_device_surface_formats_khr)( + physical_device, + surface, + p_surface_format_count, + p_surface_formats, + ) + } + pub unsafe fn get_physical_device_surface_present_modes_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, + ) -> Result { + (self.get_physical_device_surface_present_modes_khr)( + physical_device, + surface, + p_present_mode_count, + p_present_modes, + ) + } +} +#[doc = "Generated from \'VK_KHR_surface\'"] +impl Result { + pub const ERROR_SURFACE_LOST_KHR: Self = Result(-1000000000); +} +#[doc = "Generated from \'VK_KHR_surface\'"] +impl Result { + pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Result(-1000000001); +} +#[doc = "Generated from \'VK_KHR_surface\'"] +impl ObjectType { + pub const SURFACE_KHR: Self = ObjectType(1000000000); +} +pub struct KhrSwapchainFn { create_swapchain_khr : extern "system" fn ( device : Device , p_create_info : *const SwapchainCreateInfoKHR , p_allocator : *const AllocationCallbacks , p_swapchain : *mut SwapchainKHR , ) -> Result , destroy_swapchain_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_allocator : *const AllocationCallbacks , ) -> c_void , get_swapchain_images_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , p_swapchain_image_count : *mut u32 , p_swapchain_images : *mut Image , ) -> Result , acquire_next_image_khr : extern "system" fn ( device : Device , swapchain : SwapchainKHR , timeout : u64 , semaphore : Semaphore , fence : Fence , p_image_index : *mut u32 , ) -> Result , queue_present_khr : extern "system" fn ( queue : Queue , p_present_info : *const PresentInfoKHR , ) -> Result , get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } +unsafe impl Send for KhrSwapchainFn {} +unsafe impl Sync for KhrSwapchainFn {} +impl ::std::clone::Clone for KhrSwapchainFn { + fn clone(&self) -> Self { + KhrSwapchainFn { + create_swapchain_khr: self.create_swapchain_khr, + destroy_swapchain_khr: self.destroy_swapchain_khr, + get_swapchain_images_khr: self.get_swapchain_images_khr, + acquire_next_image_khr: self.acquire_next_image_khr, + queue_present_khr: self.queue_present_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, + acquire_next_image2_khr: self.acquire_next_image2_khr, + } + } +} +impl KhrSwapchainFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSwapchainFn { + create_swapchain_khr: unsafe { + let raw_name = stringify!(vkCreateSwapchainKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_swapchain_khr: unsafe { + let raw_name = stringify!(vkDestroySwapchainKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_swapchain_images_khr: unsafe { + let raw_name = stringify!(vkGetSwapchainImagesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImageKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_present_khr: unsafe { + let raw_name = stringify!(vkQueuePresentKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_present_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_present_rectangles_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image2_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_swapchain_khr( + &self, + device: Device, + p_create_info: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchain: *mut SwapchainKHR, + ) -> Result { + (self.create_swapchain_khr)(device, p_create_info, p_allocator, p_swapchain) + } + pub unsafe fn destroy_swapchain_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_swapchain_khr)(device, swapchain, p_allocator) + } + pub unsafe fn get_swapchain_images_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + p_swapchain_image_count: *mut u32, + p_swapchain_images: *mut Image, + ) -> Result { + (self.get_swapchain_images_khr)( + device, + swapchain, + p_swapchain_image_count, + p_swapchain_images, + ) + } + pub unsafe fn acquire_next_image_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + timeout: u64, + semaphore: Semaphore, + fence: Fence, + p_image_index: *mut u32, + ) -> Result { + (self.acquire_next_image_khr)(device, swapchain, timeout, semaphore, fence, p_image_index) + } + pub unsafe fn queue_present_khr( + &self, + queue: Queue, + p_present_info: *const PresentInfoKHR, + ) -> Result { + (self.queue_present_khr)(queue, p_present_info) + } + pub unsafe fn get_device_group_present_capabilities_khr( + &self, + device: Device, + p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + (self.get_device_group_present_capabilities_khr)( + device, + p_device_group_present_capabilities, + ) + } + pub unsafe fn get_device_group_surface_present_modes_khr( + &self, + device: Device, + surface: SurfaceKHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) + } + pub unsafe fn get_physical_device_present_rectangles_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *mut u32, + p_rects: *mut Rect2D, + ) -> Result { + (self.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + p_rect_count, + p_rects, + ) + } + pub unsafe fn acquire_next_image2_khr( + &self, + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *mut u32, + ) -> Result { + (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) + } +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000001000); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const PRESENT_INFO_KHR: Self = StructureType(1000001001); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl ImageLayout { + pub const PRESENT_SRC_KHR: Self = ImageLayout(1000001002); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl Result { + pub const SUBOPTIMAL_KHR: Self = Result(1000001003); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl Result { + pub const ERROR_OUT_OF_DATE_KHR: Self = Result(-1000001004); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl ObjectType { + pub const SWAPCHAIN_KHR: Self = ObjectType(1000001000); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = StructureType(1000060007); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000060008); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = StructureType(1000060009); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = StructureType(1000060010); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = StructureType(1000060011); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl StructureType { + pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = StructureType(1000060012); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl SwapchainCreateFlagsKHR { + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = SwapchainCreateFlagsKHR(0b1); +} +#[doc = "Generated from \'VK_KHR_swapchain\'"] +impl SwapchainCreateFlagsKHR { + pub const PROTECTED: Self = SwapchainCreateFlagsKHR(0b10); +} +pub struct KhrDisplayFn { + get_physical_device_display_properties_khr: + extern "system" fn( physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut DisplayPropertiesKHR, - ) -> Result { - (self.get_physical_device_display_properties_khr)( - physical_device, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_physical_device_display_plane_properties_khr( - &self, + ) -> Result, + get_physical_device_display_plane_properties_khr: + extern "system" fn( physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut DisplayPlanePropertiesKHR, - ) -> Result { - (self.get_physical_device_display_plane_properties_khr)( - physical_device, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_display_plane_supported_displays_khr( - &self, - physical_device: PhysicalDevice, - plane_index: u32, - p_display_count: *mut u32, - p_displays: *mut DisplayKHR, - ) -> Result { - (self.get_display_plane_supported_displays_khr)( - physical_device, - plane_index, - p_display_count, - p_displays, - ) - } - pub unsafe fn get_display_mode_properties_khr( - &self, + ) -> Result, + get_display_plane_supported_displays_khr: extern "system" fn( + physical_device: PhysicalDevice, + plane_index: u32, + p_display_count: *mut u32, + p_displays: *mut DisplayKHR, + ) -> Result, + get_display_mode_properties_khr: + extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, p_property_count: *mut u32, p_properties: *mut DisplayModePropertiesKHR, - ) -> Result { - (self.get_display_mode_properties_khr)( - physical_device, - display, - p_property_count, - p_properties, - ) - } - pub unsafe fn create_display_mode_khr( - &self, - physical_device: PhysicalDevice, - display: DisplayKHR, - p_create_info: *const DisplayModeCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_mode: *mut DisplayModeKHR, - ) -> Result { - (self.create_display_mode_khr)( - physical_device, - display, - p_create_info, - p_allocator, - p_mode, - ) - } - pub unsafe fn get_display_plane_capabilities_khr( - &self, + ) -> Result, + create_display_mode_khr: extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *mut DisplayModeKHR, + ) -> Result, + get_display_plane_capabilities_khr: + extern "system" fn( physical_device: PhysicalDevice, mode: DisplayModeKHR, plane_index: u32, p_capabilities: *mut DisplayPlaneCapabilitiesKHR, - ) -> Result { - (self.get_display_plane_capabilities_khr)( - physical_device, - mode, - plane_index, - p_capabilities, - ) - } - pub unsafe fn create_display_plane_surface_khr( - &self, + ) -> Result, + create_display_plane_surface_khr: + extern "system" fn( instance: Instance, p_create_info: *const DisplaySurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_display_plane_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - } - #[doc = "Generated from \'VK_KHR_display\'"] - impl StructureType { - pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = StructureType(1000002000); - } - #[doc = "Generated from \'VK_KHR_display\'"] - impl StructureType { - pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000002001); - } - #[doc = "Generated from \'VK_KHR_display\'"] - impl ObjectType { - pub const DISPLAY_KHR: Self = ObjectType(1000002000); - } - #[doc = "Generated from \'VK_KHR_display\'"] - impl ObjectType { - pub const DISPLAY_MODE_KHR: Self = ObjectType(1000002001); - } - pub struct KhrDisplaySwapchainFn { - create_shared_swapchains_khr: - extern "system" fn( - device: Device, - swapchain_count: u32, - p_create_infos: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchains: *mut SwapchainKHR, - ) -> Result, - } - unsafe impl Send for KhrDisplaySwapchainFn {} - unsafe impl Sync for KhrDisplaySwapchainFn {} - impl ::std::clone::Clone for KhrDisplaySwapchainFn { - fn clone(&self) -> Self { - KhrDisplaySwapchainFn { - create_shared_swapchains_khr: self.create_shared_swapchains_khr, - } - } - } - impl KhrDisplaySwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDisplaySwapchainFn { - create_shared_swapchains_khr: unsafe { - let raw_name = stringify!(vkCreateSharedSwapchainsKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_shared_swapchains_khr( - &self, - device: Device, - swapchain_count: u32, - p_create_infos: *const SwapchainCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_swapchains: *mut SwapchainKHR, - ) -> Result { - (self.create_shared_swapchains_khr)( - device, - swapchain_count, - p_create_infos, - p_allocator, - p_swapchains, - ) - } - } - #[doc = "Generated from \'VK_KHR_display_swapchain\'"] - impl StructureType { - pub const DISPLAY_PRESENT_INFO_KHR: Self = StructureType(1000003000); - } - #[doc = "Generated from \'VK_KHR_display_swapchain\'"] - impl Result { - pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Result(-1000003001); - } - pub struct KhrXlibSurfaceFn { - create_xlib_surface_khr: extern "system" fn( - instance: Instance, - p_create_info: *const XlibSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, ) -> Result, - get_physical_device_xlib_presentation_support_khr: - extern "system" fn( - physical_device: PhysicalDevice, - queue_family_index: u32, - dpy: *mut Display, - visual_id: VisualID, - ) -> Bool32, - } - unsafe impl Send for KhrXlibSurfaceFn {} - unsafe impl Sync for KhrXlibSurfaceFn {} - impl ::std::clone::Clone for KhrXlibSurfaceFn { - fn clone(&self) -> Self { - KhrXlibSurfaceFn { - create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: - self.get_physical_device_xlib_presentation_support_khr, - } +} +unsafe impl Send for KhrDisplayFn {} +unsafe impl Sync for KhrDisplayFn {} +impl ::std::clone::Clone for KhrDisplayFn { + fn clone(&self) -> Self { + KhrDisplayFn { + get_physical_device_display_properties_khr: self + .get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: + self.get_physical_device_display_plane_properties_khr, + get_display_plane_supported_displays_khr: self.get_display_plane_supported_displays_khr, + get_display_mode_properties_khr: self.get_display_mode_properties_khr, + create_display_mode_khr: self.create_display_mode_khr, + get_display_plane_capabilities_khr: self.get_display_plane_capabilities_khr, + create_display_plane_surface_khr: self.create_display_plane_surface_khr, } } - impl KhrXlibSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrXlibSurfaceFn { - create_xlib_surface_khr: unsafe { - let raw_name = stringify!(vkCreateXlibSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_xlib_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDisplayFn { + get_physical_device_display_properties_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_display_plane_properties_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_supported_displays_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_mode_properties_khr: unsafe { + let raw_name = stringify!(vkGetDisplayModePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_display_mode_khr: unsafe { + let raw_name = stringify!(vkCreateDisplayModeKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_display_plane_surface_khr: unsafe { + let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn create_xlib_surface_khr( - &self, - instance: Instance, - p_create_info: *const XlibSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_xlib_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_display_properties_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPropertiesKHR, + ) -> Result { + (self.get_physical_device_display_properties_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_physical_device_display_plane_properties_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPlanePropertiesKHR, + ) -> Result { + (self.get_physical_device_display_plane_properties_khr)( + physical_device, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_plane_supported_displays_khr( + &self, + physical_device: PhysicalDevice, + plane_index: u32, + p_display_count: *mut u32, + p_displays: *mut DisplayKHR, + ) -> Result { + (self.get_display_plane_supported_displays_khr)( + physical_device, + plane_index, + p_display_count, + p_displays, + ) + } + pub unsafe fn get_display_mode_properties_khr( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut u32, + p_properties: *mut DisplayModePropertiesKHR, + ) -> Result { + (self.get_display_mode_properties_khr)( + physical_device, + display, + p_property_count, + p_properties, + ) + } + pub unsafe fn create_display_mode_khr( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *mut DisplayModeKHR, + ) -> Result { + (self.create_display_mode_khr)(physical_device, display, p_create_info, p_allocator, p_mode) + } + pub unsafe fn get_display_plane_capabilities_khr( + &self, + physical_device: PhysicalDevice, + mode: DisplayModeKHR, + plane_index: u32, + p_capabilities: *mut DisplayPlaneCapabilitiesKHR, + ) -> Result { + (self.get_display_plane_capabilities_khr)( + physical_device, + mode, + plane_index, + p_capabilities, + ) + } + pub unsafe fn create_display_plane_surface_khr( + &self, + instance: Instance, + p_create_info: *const DisplaySurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_display_plane_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } +} +#[doc = "Generated from \'VK_KHR_display\'"] +impl StructureType { + pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = StructureType(1000002000); +} +#[doc = "Generated from \'VK_KHR_display\'"] +impl StructureType { + pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000002001); +} +#[doc = "Generated from \'VK_KHR_display\'"] +impl ObjectType { + pub const DISPLAY_KHR: Self = ObjectType(1000002000); +} +#[doc = "Generated from \'VK_KHR_display\'"] +impl ObjectType { + pub const DISPLAY_MODE_KHR: Self = ObjectType(1000002001); +} +pub struct KhrDisplaySwapchainFn { + create_shared_swapchains_khr: extern "system" fn( + device: Device, + swapchain_count: u32, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *mut SwapchainKHR, + ) -> Result, +} +unsafe impl Send for KhrDisplaySwapchainFn {} +unsafe impl Sync for KhrDisplaySwapchainFn {} +impl ::std::clone::Clone for KhrDisplaySwapchainFn { + fn clone(&self) -> Self { + KhrDisplaySwapchainFn { + create_shared_swapchains_khr: self.create_shared_swapchains_khr, } - pub unsafe fn get_physical_device_xlib_presentation_support_khr( - &self, + } +} +impl KhrDisplaySwapchainFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDisplaySwapchainFn { + create_shared_swapchains_khr: unsafe { + let raw_name = stringify!(vkCreateSharedSwapchainsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_shared_swapchains_khr( + &self, + device: Device, + swapchain_count: u32, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *mut SwapchainKHR, + ) -> Result { + (self.create_shared_swapchains_khr)( + device, + swapchain_count, + p_create_infos, + p_allocator, + p_swapchains, + ) + } +} +#[doc = "Generated from \'VK_KHR_display_swapchain\'"] +impl StructureType { + pub const DISPLAY_PRESENT_INFO_KHR: Self = StructureType(1000003000); +} +#[doc = "Generated from \'VK_KHR_display_swapchain\'"] +impl Result { + pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Result(-1000003001); +} +pub struct KhrXlibSurfaceFn { + create_xlib_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, + get_physical_device_xlib_presentation_support_khr: + extern "system" fn( physical_device: PhysicalDevice, queue_family_index: u32, dpy: *mut Display, visual_id: VisualID, - ) -> Bool32 { - (self.get_physical_device_xlib_presentation_support_khr)( - physical_device, - queue_family_index, - dpy, - visual_id, - ) + ) -> Bool32, +} +unsafe impl Send for KhrXlibSurfaceFn {} +unsafe impl Sync for KhrXlibSurfaceFn {} +impl ::std::clone::Clone for KhrXlibSurfaceFn { + fn clone(&self) -> Self { + KhrXlibSurfaceFn { + create_xlib_surface_khr: self.create_xlib_surface_khr, + get_physical_device_xlib_presentation_support_khr: + self.get_physical_device_xlib_presentation_support_khr, } } - #[doc = "Generated from \'VK_KHR_xlib_surface\'"] - impl StructureType { - pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000004000); - } - pub struct KhrXcbSurfaceFn { - create_xcb_surface_khr: extern "system" fn( - instance: Instance, - p_create_info: *const XcbSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, - get_physical_device_xcb_presentation_support_khr: - extern "system" fn( - physical_device: PhysicalDevice, - queue_family_index: u32, - connection: *mut xcb_connection_t, - visual_id: xcb_visualid_t, - ) -> Bool32, - } - unsafe impl Send for KhrXcbSurfaceFn {} - unsafe impl Sync for KhrXcbSurfaceFn {} - impl ::std::clone::Clone for KhrXcbSurfaceFn { - fn clone(&self) -> Self { - KhrXcbSurfaceFn { - create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: - self.get_physical_device_xcb_presentation_support_khr, - } +} +impl KhrXlibSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrXlibSurfaceFn { + create_xlib_surface_khr: unsafe { + let raw_name = stringify!(vkCreateXlibSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_xlib_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrXcbSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrXcbSurfaceFn { - create_xcb_surface_khr: unsafe { - let raw_name = stringify!(vkCreateXcbSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_xcb_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_xcb_surface_khr( - &self, - instance: Instance, - p_create_info: *const XcbSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_xcb_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_xcb_presentation_support_khr( - &self, + pub unsafe fn create_xlib_surface_khr( + &self, + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_xlib_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_xlib_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: u32, + dpy: *mut Display, + visual_id: VisualID, + ) -> Bool32 { + (self.get_physical_device_xlib_presentation_support_khr)( + physical_device, + queue_family_index, + dpy, + visual_id, + ) + } +} +#[doc = "Generated from \'VK_KHR_xlib_surface\'"] +impl StructureType { + pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000004000); +} +pub struct KhrXcbSurfaceFn { + create_xcb_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, + get_physical_device_xcb_presentation_support_khr: + extern "system" fn( physical_device: PhysicalDevice, queue_family_index: u32, connection: *mut xcb_connection_t, visual_id: xcb_visualid_t, - ) -> Bool32 { - (self.get_physical_device_xcb_presentation_support_khr)( - physical_device, - queue_family_index, - connection, - visual_id, - ) + ) -> Bool32, +} +unsafe impl Send for KhrXcbSurfaceFn {} +unsafe impl Sync for KhrXcbSurfaceFn {} +impl ::std::clone::Clone for KhrXcbSurfaceFn { + fn clone(&self) -> Self { + KhrXcbSurfaceFn { + create_xcb_surface_khr: self.create_xcb_surface_khr, + get_physical_device_xcb_presentation_support_khr: + self.get_physical_device_xcb_presentation_support_khr, } } - #[doc = "Generated from \'VK_KHR_xcb_surface\'"] - impl StructureType { - pub const XCB_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000005000); - } - pub struct KhrWaylandSurfaceFn { - create_wayland_surface_khr: - extern "system" fn( - instance: Instance, - p_create_info: *const WaylandSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, - get_physical_device_wayland_presentation_support_khr: - extern "system" fn( - physical_device: PhysicalDevice, - queue_family_index: u32, - display: *mut wl_display, - ) -> Bool32, - } - unsafe impl Send for KhrWaylandSurfaceFn {} - unsafe impl Sync for KhrWaylandSurfaceFn {} - impl ::std::clone::Clone for KhrWaylandSurfaceFn { - fn clone(&self) -> Self { - KhrWaylandSurfaceFn { - create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: - self.get_physical_device_wayland_presentation_support_khr, - } +} +impl KhrXcbSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrXcbSurfaceFn { + create_xcb_surface_khr: unsafe { + let raw_name = stringify!(vkCreateXcbSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_xcb_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrWaylandSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrWaylandSurfaceFn { - create_wayland_surface_khr: unsafe { - let raw_name = stringify!(vkCreateWaylandSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_wayland_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_wayland_surface_khr( - &self, + pub unsafe fn create_xcb_surface_khr( + &self, + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_xcb_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_xcb_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: u32, + connection: *mut xcb_connection_t, + visual_id: xcb_visualid_t, + ) -> Bool32 { + (self.get_physical_device_xcb_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + visual_id, + ) + } +} +#[doc = "Generated from \'VK_KHR_xcb_surface\'"] +impl StructureType { + pub const XCB_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000005000); +} +pub struct KhrWaylandSurfaceFn { + create_wayland_surface_khr: + extern "system" fn( instance: Instance, p_create_info: *const WaylandSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_wayland_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_wayland_presentation_support_khr( - &self, + ) -> Result, + get_physical_device_wayland_presentation_support_khr: + extern "system" fn( physical_device: PhysicalDevice, queue_family_index: u32, display: *mut wl_display, - ) -> Bool32 { - (self.get_physical_device_wayland_presentation_support_khr)( - physical_device, - queue_family_index, - display, - ) + ) -> Bool32, +} +unsafe impl Send for KhrWaylandSurfaceFn {} +unsafe impl Sync for KhrWaylandSurfaceFn {} +impl ::std::clone::Clone for KhrWaylandSurfaceFn { + fn clone(&self) -> Self { + KhrWaylandSurfaceFn { + create_wayland_surface_khr: self.create_wayland_surface_khr, + get_physical_device_wayland_presentation_support_khr: + self.get_physical_device_wayland_presentation_support_khr, } } - #[doc = "Generated from \'VK_KHR_wayland_surface\'"] - impl StructureType { - pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000006000); - } - pub struct KhrMirSurfaceFn { - create_mir_surface_khr: extern "system" fn( - instance: Instance, - p_create_info: *const MirSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, - get_physical_device_mir_presentation_support_khr: - extern "system" fn( - physical_device: PhysicalDevice, - queue_family_index: u32, - connection: *mut MirConnection, - ) -> Bool32, - } - unsafe impl Send for KhrMirSurfaceFn {} - unsafe impl Sync for KhrMirSurfaceFn {} - impl ::std::clone::Clone for KhrMirSurfaceFn { - fn clone(&self) -> Self { - KhrMirSurfaceFn { - create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: - self.get_physical_device_mir_presentation_support_khr, - } +} +impl KhrWaylandSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWaylandSurfaceFn { + create_wayland_surface_khr: unsafe { + let raw_name = stringify!(vkCreateWaylandSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_wayland_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrMirSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrMirSurfaceFn { - create_mir_surface_khr: unsafe { - let raw_name = stringify!(vkCreateMirSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_mir_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_mir_surface_khr( - &self, - instance: Instance, - p_create_info: *const MirSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_mir_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_mir_presentation_support_khr( - &self, + pub unsafe fn create_wayland_surface_khr( + &self, + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_wayland_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_wayland_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: u32, + display: *mut wl_display, + ) -> Bool32 { + (self.get_physical_device_wayland_presentation_support_khr)( + physical_device, + queue_family_index, + display, + ) + } +} +#[doc = "Generated from \'VK_KHR_wayland_surface\'"] +impl StructureType { + pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000006000); +} +pub struct KhrMirSurfaceFn { + create_mir_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, + get_physical_device_mir_presentation_support_khr: + extern "system" fn( physical_device: PhysicalDevice, queue_family_index: u32, connection: *mut MirConnection, - ) -> Bool32 { - (self.get_physical_device_mir_presentation_support_khr)( - physical_device, - queue_family_index, - connection, - ) + ) -> Bool32, +} +unsafe impl Send for KhrMirSurfaceFn {} +unsafe impl Sync for KhrMirSurfaceFn {} +impl ::std::clone::Clone for KhrMirSurfaceFn { + fn clone(&self) -> Self { + KhrMirSurfaceFn { + create_mir_surface_khr: self.create_mir_surface_khr, + get_physical_device_mir_presentation_support_khr: + self.get_physical_device_mir_presentation_support_khr, } } - #[doc = "Generated from \'VK_KHR_mir_surface\'"] - impl StructureType { - pub const MIR_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000007000); - } - pub struct KhrAndroidSurfaceFn { - create_android_surface_khr: - extern "system" fn( - instance: Instance, - p_create_info: *const AndroidSurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, - } - unsafe impl Send for KhrAndroidSurfaceFn {} - unsafe impl Sync for KhrAndroidSurfaceFn {} - impl ::std::clone::Clone for KhrAndroidSurfaceFn { - fn clone(&self) -> Self { - KhrAndroidSurfaceFn { - create_android_surface_khr: self.create_android_surface_khr, - } +} +impl KhrMirSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMirSurfaceFn { + create_mir_surface_khr: unsafe { + let raw_name = stringify!(vkCreateMirSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_mir_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrAndroidSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrAndroidSurfaceFn { - create_android_surface_khr: unsafe { - let raw_name = stringify!(vkCreateAndroidSurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_android_surface_khr( - &self, + pub unsafe fn create_mir_surface_khr( + &self, + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_mir_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_mir_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: u32, + connection: *mut MirConnection, + ) -> Bool32 { + (self.get_physical_device_mir_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + ) + } +} +#[doc = "Generated from \'VK_KHR_mir_surface\'"] +impl StructureType { + pub const MIR_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000007000); +} +pub struct KhrAndroidSurfaceFn { + create_android_surface_khr: + extern "system" fn( instance: Instance, p_create_info: *const AndroidSurfaceCreateInfoKHR, p_allocator: *const AllocationCallbacks, p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_android_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - } - #[doc = "Generated from \'VK_KHR_android_surface\'"] - impl StructureType { - pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000008000); - } - pub struct KhrWin32SurfaceFn { - create_win32_surface_khr: - extern "system" fn( - instance: Instance, - p_create_info: *const Win32SurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, - get_physical_device_win32_presentation_support_khr: - extern "system" fn(physical_device: PhysicalDevice, queue_family_index: u32) -> Bool32, - } - unsafe impl Send for KhrWin32SurfaceFn {} - unsafe impl Sync for KhrWin32SurfaceFn {} - impl ::std::clone::Clone for KhrWin32SurfaceFn { - fn clone(&self) -> Self { - KhrWin32SurfaceFn { - create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: - self.get_physical_device_win32_presentation_support_khr, - } - } - } - impl KhrWin32SurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrWin32SurfaceFn { - create_win32_surface_khr: unsafe { - let raw_name = stringify!(vkCreateWin32SurfaceKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_win32_presentation_support_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_win32_surface_khr( - &self, - instance: Instance, - p_create_info: *const Win32SurfaceCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_win32_surface_khr)(instance, p_create_info, p_allocator, p_surface) - } - pub unsafe fn get_physical_device_win32_presentation_support_khr( - &self, - physical_device: PhysicalDevice, - queue_family_index: u32, - ) -> Bool32 { - (self.get_physical_device_win32_presentation_support_khr)( - physical_device, - queue_family_index, - ) - } - } - #[doc = "Generated from \'VK_KHR_win32_surface\'"] - impl StructureType { - pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000009000); - } - pub struct AndroidNativeBufferFn { - get_swapchain_gralloc_usage_android: extern "system" fn( - device: Device, - format: Format, - image_usage: ImageUsageFlags, - gralloc_usage: *mut c_int, ) -> Result, - acquire_image_android: extern "system" fn( - device: Device, - image: Image, - native_fence_fd: c_int, - semaphore: Semaphore, - fence: Fence, - ) -> Result, - queue_signal_release_image_android: extern "system" fn( - queue: Queue, - wait_semaphore_count: u32, - p_wait_semaphores: *const Semaphore, - image: Image, - p_native_fence_fd: *mut c_int, - ) -> Result, - } - unsafe impl Send for AndroidNativeBufferFn {} - unsafe impl Sync for AndroidNativeBufferFn {} - impl ::std::clone::Clone for AndroidNativeBufferFn { - fn clone(&self) -> Self { - AndroidNativeBufferFn { - get_swapchain_gralloc_usage_android: self.get_swapchain_gralloc_usage_android, - acquire_image_android: self.acquire_image_android, - queue_signal_release_image_android: self.queue_signal_release_image_android, - } +} +unsafe impl Send for KhrAndroidSurfaceFn {} +unsafe impl Sync for KhrAndroidSurfaceFn {} +impl ::std::clone::Clone for KhrAndroidSurfaceFn { + fn clone(&self) -> Self { + KhrAndroidSurfaceFn { + create_android_surface_khr: self.create_android_surface_khr, } } - impl AndroidNativeBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AndroidNativeBufferFn { - get_swapchain_gralloc_usage_android: unsafe { - let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_image_android: unsafe { - let raw_name = stringify!(vkAcquireImageANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_signal_release_image_android: unsafe { - let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_swapchain_gralloc_usage_android( - &self, - device: Device, - format: Format, - image_usage: ImageUsageFlags, - gralloc_usage: *mut c_int, - ) -> Result { - (self.get_swapchain_gralloc_usage_android)(device, format, image_usage, gralloc_usage) - } - pub unsafe fn acquire_image_android( - &self, - device: Device, - image: Image, - native_fence_fd: c_int, - semaphore: Semaphore, - fence: Fence, - ) -> Result { - (self.acquire_image_android)(device, image, native_fence_fd, semaphore, fence) - } - pub unsafe fn queue_signal_release_image_android( - &self, - queue: Queue, - wait_semaphore_count: u32, - p_wait_semaphores: *const Semaphore, - image: Image, - p_native_fence_fd: *mut c_int, - ) -> Result { - (self.queue_signal_release_image_android)( - queue, - wait_semaphore_count, - p_wait_semaphores, - image, - p_native_fence_fd, - ) +} +impl KhrAndroidSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrAndroidSurfaceFn { + create_android_surface_khr: unsafe { + let raw_name = stringify!(vkCreateAndroidSurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_ANDROID_native_buffer\'"] - impl StructureType { - pub const NATIVE_BUFFER_ANDROID: Self = StructureType(1000010000); + pub unsafe fn create_android_surface_khr( + &self, + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_android_surface_khr)(instance, p_create_info, p_allocator, p_surface) } - pub struct ExtDebugReportFn { - create_debug_report_callback_ext: - extern "system" fn( - instance: Instance, - p_create_info: *const DebugReportCallbackCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_callback: *mut DebugReportCallbackEXT, - ) -> Result, - destroy_debug_report_callback_ext: - extern "system" fn( - instance: Instance, - callback: DebugReportCallbackEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - debug_report_message_ext: extern "system" fn( - instance: Instance, - flags: DebugReportFlagsEXT, - object_type: DebugReportObjectTypeEXT, - object: u64, - location: usize, - message_code: i32, - p_layer_prefix: *const c_char, - p_message: *const c_char, - ) -> c_void, - } - unsafe impl Send for ExtDebugReportFn {} - unsafe impl Sync for ExtDebugReportFn {} - impl ::std::clone::Clone for ExtDebugReportFn { - fn clone(&self) -> Self { - ExtDebugReportFn { - create_debug_report_callback_ext: self.create_debug_report_callback_ext, - destroy_debug_report_callback_ext: self.destroy_debug_report_callback_ext, - debug_report_message_ext: self.debug_report_message_ext, - } +} +#[doc = "Generated from \'VK_KHR_android_surface\'"] +impl StructureType { + pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000008000); +} +pub struct KhrWin32SurfaceFn { + create_win32_surface_khr: extern "system" fn( + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, + get_physical_device_win32_presentation_support_khr: + extern "system" fn(physical_device: PhysicalDevice, queue_family_index: u32) -> Bool32, +} +unsafe impl Send for KhrWin32SurfaceFn {} +unsafe impl Sync for KhrWin32SurfaceFn {} +impl ::std::clone::Clone for KhrWin32SurfaceFn { + fn clone(&self) -> Self { + KhrWin32SurfaceFn { + create_win32_surface_khr: self.create_win32_surface_khr, + get_physical_device_win32_presentation_support_khr: + self.get_physical_device_win32_presentation_support_khr, } } - impl ExtDebugReportFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDebugReportFn { - create_debug_report_callback_ext: unsafe { - let raw_name = stringify!(vkCreateDebugReportCallbackEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_debug_report_callback_ext: unsafe { - let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - debug_report_message_ext: unsafe { - let raw_name = stringify!(vkDebugReportMessageEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrWin32SurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWin32SurfaceFn { + create_win32_surface_khr: unsafe { + let raw_name = stringify!(vkCreateWin32SurfaceKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_win32_presentation_support_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn create_debug_report_callback_ext( - &self, + } + pub unsafe fn create_win32_surface_khr( + &self, + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_win32_surface_khr)(instance, p_create_info, p_allocator, p_surface) + } + pub unsafe fn get_physical_device_win32_presentation_support_khr( + &self, + physical_device: PhysicalDevice, + queue_family_index: u32, + ) -> Bool32 { + (self.get_physical_device_win32_presentation_support_khr)( + physical_device, + queue_family_index, + ) + } +} +#[doc = "Generated from \'VK_KHR_win32_surface\'"] +impl StructureType { + pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = StructureType(1000009000); +} +pub struct AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: extern "system" fn( + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *mut c_int, + ) -> Result, + acquire_image_android: extern "system" fn( + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, + ) -> Result, + queue_signal_release_image_android: extern "system" fn( + queue: Queue, + wait_semaphore_count: u32, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *mut c_int, + ) -> Result, +} +unsafe impl Send for AndroidNativeBufferFn {} +unsafe impl Sync for AndroidNativeBufferFn {} +impl ::std::clone::Clone for AndroidNativeBufferFn { + fn clone(&self) -> Self { + AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: self.get_swapchain_gralloc_usage_android, + acquire_image_android: self.acquire_image_android, + queue_signal_release_image_android: self.queue_signal_release_image_android, + } + } +} +impl AndroidNativeBufferFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AndroidNativeBufferFn { + get_swapchain_gralloc_usage_android: unsafe { + let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_image_android: unsafe { + let raw_name = stringify!(vkAcquireImageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_signal_release_image_android: unsafe { + let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_swapchain_gralloc_usage_android( + &self, + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *mut c_int, + ) -> Result { + (self.get_swapchain_gralloc_usage_android)(device, format, image_usage, gralloc_usage) + } + pub unsafe fn acquire_image_android( + &self, + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, + ) -> Result { + (self.acquire_image_android)(device, image, native_fence_fd, semaphore, fence) + } + pub unsafe fn queue_signal_release_image_android( + &self, + queue: Queue, + wait_semaphore_count: u32, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *mut c_int, + ) -> Result { + (self.queue_signal_release_image_android)( + queue, + wait_semaphore_count, + p_wait_semaphores, + image, + p_native_fence_fd, + ) + } +} +#[doc = "Generated from \'VK_ANDROID_native_buffer\'"] +impl StructureType { + pub const NATIVE_BUFFER_ANDROID: Self = StructureType(1000010000); +} +pub struct ExtDebugReportFn { + create_debug_report_callback_ext: + extern "system" fn( instance: Instance, p_create_info: *const DebugReportCallbackCreateInfoEXT, p_allocator: *const AllocationCallbacks, p_callback: *mut DebugReportCallbackEXT, - ) -> Result { - (self.create_debug_report_callback_ext)( - instance, - p_create_info, - p_allocator, - p_callback, - ) - } - pub unsafe fn destroy_debug_report_callback_ext( - &self, - instance: Instance, - callback: DebugReportCallbackEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_debug_report_callback_ext)(instance, callback, p_allocator) - } - pub unsafe fn debug_report_message_ext( - &self, - instance: Instance, - flags: DebugReportFlagsEXT, - object_type: DebugReportObjectTypeEXT, - object: u64, - location: usize, - message_code: i32, - p_layer_prefix: *const c_char, - p_message: *const c_char, - ) -> c_void { - (self.debug_report_message_ext)( - instance, - flags, - object_type, - object, - location, - message_code, - p_layer_prefix, - p_message, - ) - } - } - #[doc = "Generated from \'VK_EXT_debug_report\'"] - impl StructureType { - pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = StructureType(1000011000); - } - #[doc = "Generated from \'VK_EXT_debug_report\'"] - impl Result { - pub const ERROR_VALIDATION_FAILED_EXT: Self = Result(-1000011001); - } - #[doc = "Generated from \'VK_EXT_debug_report\'"] - impl ObjectType { - pub const DEBUG_REPORT_CALLBACK_EXT: Self = ObjectType(1000011000); - } - #[doc = "Generated from \'VK_EXT_debug_report\'"] - impl DebugReportObjectTypeEXT { - pub const SAMPLER_YCBCR_CONVERSION: Self = DebugReportObjectTypeEXT(1000156000); - } - #[doc = "Generated from \'VK_EXT_debug_report\'"] - impl DebugReportObjectTypeEXT { - pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = DebugReportObjectTypeEXT(1000085000); - } - pub struct NvGlslShaderFn {} - unsafe impl Send for NvGlslShaderFn {} - unsafe impl Sync for NvGlslShaderFn {} - impl ::std::clone::Clone for NvGlslShaderFn { - fn clone(&self) -> Self { - NvGlslShaderFn {} - } - } - impl NvGlslShaderFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvGlslShaderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_glsl_shader\'"] - impl Result { - pub const ERROR_INVALID_SHADER_NV: Self = Result(-1000012000); - } - pub struct ExtDepthRangeUnrestrictedFn {} - unsafe impl Send for ExtDepthRangeUnrestrictedFn {} - unsafe impl Sync for ExtDepthRangeUnrestrictedFn {} - impl ::std::clone::Clone for ExtDepthRangeUnrestrictedFn { - fn clone(&self) -> Self { - ExtDepthRangeUnrestrictedFn {} - } - } - impl ExtDepthRangeUnrestrictedFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDepthRangeUnrestrictedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrSamplerMirrorClampToEdgeFn {} - unsafe impl Send for KhrSamplerMirrorClampToEdgeFn {} - unsafe impl Sync for KhrSamplerMirrorClampToEdgeFn {} - impl ::std::clone::Clone for KhrSamplerMirrorClampToEdgeFn { - fn clone(&self) -> Self { - KhrSamplerMirrorClampToEdgeFn {} - } - } - impl KhrSamplerMirrorClampToEdgeFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSamplerMirrorClampToEdgeFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ImgFilterCubicFn {} - unsafe impl Send for ImgFilterCubicFn {} - unsafe impl Sync for ImgFilterCubicFn {} - impl ::std::clone::Clone for ImgFilterCubicFn { - fn clone(&self) -> Self { - ImgFilterCubicFn {} - } - } - impl ImgFilterCubicFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgFilterCubicFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_IMG_filter_cubic\'"] - impl Filter { - pub const CUBIC_IMG: Self = Filter(1000015000); - } - #[doc = "Generated from \'VK_IMG_filter_cubic\'"] - impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = FormatFeatureFlags(0b10000000000000); - } - pub struct AmdExtension17Fn {} - unsafe impl Send for AmdExtension17Fn {} - unsafe impl Sync for AmdExtension17Fn {} - impl ::std::clone::Clone for AmdExtension17Fn { - fn clone(&self) -> Self { - AmdExtension17Fn {} - } - } - impl AmdExtension17Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension17Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension18Fn {} - unsafe impl Send for AmdExtension18Fn {} - unsafe impl Sync for AmdExtension18Fn {} - impl ::std::clone::Clone for AmdExtension18Fn { - fn clone(&self) -> Self { - AmdExtension18Fn {} - } - } - impl AmdExtension18Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension18Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdRasterizationOrderFn {} - unsafe impl Send for AmdRasterizationOrderFn {} - unsafe impl Sync for AmdRasterizationOrderFn {} - impl ::std::clone::Clone for AmdRasterizationOrderFn { - fn clone(&self) -> Self { - AmdRasterizationOrderFn {} - } - } - impl AmdRasterizationOrderFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdRasterizationOrderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_AMD_rasterization_order\'"] - impl StructureType { - pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = - StructureType(1000018000); - } - pub struct AmdExtension20Fn {} - unsafe impl Send for AmdExtension20Fn {} - unsafe impl Sync for AmdExtension20Fn {} - impl ::std::clone::Clone for AmdExtension20Fn { - fn clone(&self) -> Self { - AmdExtension20Fn {} - } - } - impl AmdExtension20Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension20Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdShaderTrinaryMinmaxFn {} - unsafe impl Send for AmdShaderTrinaryMinmaxFn {} - unsafe impl Sync for AmdShaderTrinaryMinmaxFn {} - impl ::std::clone::Clone for AmdShaderTrinaryMinmaxFn { - fn clone(&self) -> Self { - AmdShaderTrinaryMinmaxFn {} - } - } - impl AmdShaderTrinaryMinmaxFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderTrinaryMinmaxFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdShaderExplicitVertexParameterFn {} - unsafe impl Send for AmdShaderExplicitVertexParameterFn {} - unsafe impl Sync for AmdShaderExplicitVertexParameterFn {} - impl ::std::clone::Clone for AmdShaderExplicitVertexParameterFn { - fn clone(&self) -> Self { - AmdShaderExplicitVertexParameterFn {} - } - } - impl AmdShaderExplicitVertexParameterFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderExplicitVertexParameterFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtDebugMarkerFn { - debug_marker_set_object_tag_ext: - extern "system" fn(device: Device, p_tag_info: *const DebugMarkerObjectTagInfoEXT) - -> Result, - debug_marker_set_object_name_ext: - extern "system" fn(device: Device, p_name_info: *const DebugMarkerObjectNameInfoEXT) - -> Result, - cmd_debug_marker_begin_ext: - extern "system" fn( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void, - cmd_debug_marker_end_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, - cmd_debug_marker_insert_ext: - extern "system" fn( - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void, - } - unsafe impl Send for ExtDebugMarkerFn {} - unsafe impl Sync for ExtDebugMarkerFn {} - impl ::std::clone::Clone for ExtDebugMarkerFn { - fn clone(&self) -> Self { - ExtDebugMarkerFn { - debug_marker_set_object_tag_ext: self.debug_marker_set_object_tag_ext, - debug_marker_set_object_name_ext: self.debug_marker_set_object_name_ext, - cmd_debug_marker_begin_ext: self.cmd_debug_marker_begin_ext, - cmd_debug_marker_end_ext: self.cmd_debug_marker_end_ext, - cmd_debug_marker_insert_ext: self.cmd_debug_marker_insert_ext, - } - } - } - impl ExtDebugMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDebugMarkerFn { - debug_marker_set_object_tag_ext: unsafe { - let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - debug_marker_set_object_name_ext: unsafe { - let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_debug_marker_begin_ext: unsafe { - let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_debug_marker_end_ext: unsafe { - let raw_name = stringify!(vkCmdDebugMarkerEndEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_debug_marker_insert_ext: unsafe { - let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn debug_marker_set_object_tag_ext( - &self, - device: Device, - p_tag_info: *const DebugMarkerObjectTagInfoEXT, - ) -> Result { - (self.debug_marker_set_object_tag_ext)(device, p_tag_info) - } - pub unsafe fn debug_marker_set_object_name_ext( - &self, - device: Device, - p_name_info: *const DebugMarkerObjectNameInfoEXT, - ) -> Result { - (self.debug_marker_set_object_name_ext)(device, p_name_info) - } - pub unsafe fn cmd_debug_marker_begin_ext( - &self, - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void { - (self.cmd_debug_marker_begin_ext)(command_buffer, p_marker_info) - } - pub unsafe fn cmd_debug_marker_end_ext(&self, command_buffer: CommandBuffer) -> c_void { - (self.cmd_debug_marker_end_ext)(command_buffer) - } - pub unsafe fn cmd_debug_marker_insert_ext( - &self, - command_buffer: CommandBuffer, - p_marker_info: *const DebugMarkerMarkerInfoEXT, - ) -> c_void { - (self.cmd_debug_marker_insert_ext)(command_buffer, p_marker_info) - } - } - #[doc = "Generated from \'VK_EXT_debug_marker\'"] - impl StructureType { - pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = StructureType(1000022000); - } - #[doc = "Generated from \'VK_EXT_debug_marker\'"] - impl StructureType { - pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = StructureType(1000022001); - } - #[doc = "Generated from \'VK_EXT_debug_marker\'"] - impl StructureType { - pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = StructureType(1000022002); - } - pub struct AmdExtension24Fn {} - unsafe impl Send for AmdExtension24Fn {} - unsafe impl Sync for AmdExtension24Fn {} - impl ::std::clone::Clone for AmdExtension24Fn { - fn clone(&self) -> Self { - AmdExtension24Fn {} - } - } - impl AmdExtension24Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension24Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension25Fn {} - unsafe impl Send for AmdExtension25Fn {} - unsafe impl Sync for AmdExtension25Fn {} - impl ::std::clone::Clone for AmdExtension25Fn { - fn clone(&self) -> Self { - AmdExtension25Fn {} - } - } - impl AmdExtension25Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension25Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdGcnShaderFn {} - unsafe impl Send for AmdGcnShaderFn {} - unsafe impl Sync for AmdGcnShaderFn {} - impl ::std::clone::Clone for AmdGcnShaderFn { - fn clone(&self) -> Self { - AmdGcnShaderFn {} - } - } - impl AmdGcnShaderFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdGcnShaderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvDedicatedAllocationFn {} - unsafe impl Send for NvDedicatedAllocationFn {} - unsafe impl Sync for NvDedicatedAllocationFn {} - impl ::std::clone::Clone for NvDedicatedAllocationFn { - fn clone(&self) -> Self { - NvDedicatedAllocationFn {} - } - } - impl NvDedicatedAllocationFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvDedicatedAllocationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] - impl StructureType { - pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = StructureType(1000026000); - } - #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] - impl StructureType { - pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = StructureType(1000026001); - } - #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] - impl StructureType { - pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = StructureType(1000026002); - } - pub struct ExtExtension28Fn {} - unsafe impl Send for ExtExtension28Fn {} - unsafe impl Sync for ExtExtension28Fn {} - impl ::std::clone::Clone for ExtExtension28Fn { - fn clone(&self) -> Self { - ExtExtension28Fn {} - } - } - impl ExtExtension28Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension28Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvxExtension29Fn {} - unsafe impl Send for NvxExtension29Fn {} - unsafe impl Sync for NvxExtension29Fn {} - impl ::std::clone::Clone for NvxExtension29Fn { - fn clone(&self) -> Self { - NvxExtension29Fn {} - } - } - impl NvxExtension29Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxExtension29Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvxExtension30Fn {} - unsafe impl Send for NvxExtension30Fn {} - unsafe impl Sync for NvxExtension30Fn {} - impl ::std::clone::Clone for NvxExtension30Fn { - fn clone(&self) -> Self { - NvxExtension30Fn {} - } - } - impl NvxExtension30Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxExtension30Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvxExtension31Fn {} - unsafe impl Send for NvxExtension31Fn {} - unsafe impl Sync for NvxExtension31Fn {} - impl ::std::clone::Clone for NvxExtension31Fn { - fn clone(&self) -> Self { - NvxExtension31Fn {} - } - } - impl NvxExtension31Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxExtension31Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension32Fn {} - unsafe impl Send for AmdExtension32Fn {} - unsafe impl Sync for AmdExtension32Fn {} - impl ::std::clone::Clone for AmdExtension32Fn { - fn clone(&self) -> Self { - AmdExtension32Fn {} - } - } - impl AmdExtension32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension32Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension33Fn {} - unsafe impl Send for AmdExtension33Fn {} - unsafe impl Sync for AmdExtension33Fn {} - impl ::std::clone::Clone for AmdExtension33Fn { - fn clone(&self) -> Self { - AmdExtension33Fn {} - } - } - impl AmdExtension33Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension33Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdDrawIndirectCountFn { - cmd_draw_indirect_count_amd: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void, - cmd_draw_indexed_indirect_count_amd: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void, - } - unsafe impl Send for AmdDrawIndirectCountFn {} - unsafe impl Sync for AmdDrawIndirectCountFn {} - impl ::std::clone::Clone for AmdDrawIndirectCountFn { - fn clone(&self) -> Self { - AmdDrawIndirectCountFn { - cmd_draw_indirect_count_amd: self.cmd_draw_indirect_count_amd, - cmd_draw_indexed_indirect_count_amd: self.cmd_draw_indexed_indirect_count_amd, - } - } - } - impl AmdDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdDrawIndirectCountFn { - cmd_draw_indirect_count_amd: unsafe { - let raw_name = stringify!(vkCmdDrawIndirectCountAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_draw_indexed_indirect_count_amd: unsafe { - let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_draw_indirect_count_amd( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void { - (self.cmd_draw_indirect_count_amd)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) - } - pub unsafe fn cmd_draw_indexed_indirect_count_amd( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void { - (self.cmd_draw_indexed_indirect_count_amd)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) - } - } - pub struct AmdExtension35Fn {} - unsafe impl Send for AmdExtension35Fn {} - unsafe impl Sync for AmdExtension35Fn {} - impl ::std::clone::Clone for AmdExtension35Fn { - fn clone(&self) -> Self { - AmdExtension35Fn {} - } - } - impl AmdExtension35Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension35Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdNegativeViewportHeightFn {} - unsafe impl Send for AmdNegativeViewportHeightFn {} - unsafe impl Sync for AmdNegativeViewportHeightFn {} - impl ::std::clone::Clone for AmdNegativeViewportHeightFn { - fn clone(&self) -> Self { - AmdNegativeViewportHeightFn {} - } - } - impl AmdNegativeViewportHeightFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdNegativeViewportHeightFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdGpuShaderHalfFloatFn {} - unsafe impl Send for AmdGpuShaderHalfFloatFn {} - unsafe impl Sync for AmdGpuShaderHalfFloatFn {} - impl ::std::clone::Clone for AmdGpuShaderHalfFloatFn { - fn clone(&self) -> Self { - AmdGpuShaderHalfFloatFn {} - } - } - impl AmdGpuShaderHalfFloatFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdGpuShaderHalfFloatFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdShaderBallotFn {} - unsafe impl Send for AmdShaderBallotFn {} - unsafe impl Sync for AmdShaderBallotFn {} - impl ::std::clone::Clone for AmdShaderBallotFn { - fn clone(&self) -> Self { - AmdShaderBallotFn {} - } - } - impl AmdShaderBallotFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderBallotFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension39Fn {} - unsafe impl Send for AmdExtension39Fn {} - unsafe impl Sync for AmdExtension39Fn {} - impl ::std::clone::Clone for AmdExtension39Fn { - fn clone(&self) -> Self { - AmdExtension39Fn {} - } - } - impl AmdExtension39Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension39Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension40Fn {} - unsafe impl Send for AmdExtension40Fn {} - unsafe impl Sync for AmdExtension40Fn {} - impl ::std::clone::Clone for AmdExtension40Fn { - fn clone(&self) -> Self { - AmdExtension40Fn {} - } - } - impl AmdExtension40Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension40Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension41Fn {} - unsafe impl Send for AmdExtension41Fn {} - unsafe impl Sync for AmdExtension41Fn {} - impl ::std::clone::Clone for AmdExtension41Fn { - fn clone(&self) -> Self { - AmdExtension41Fn {} - } - } - impl AmdExtension41Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension41Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdTextureGatherBiasLodFn {} - unsafe impl Send for AmdTextureGatherBiasLodFn {} - unsafe impl Sync for AmdTextureGatherBiasLodFn {} - impl ::std::clone::Clone for AmdTextureGatherBiasLodFn { - fn clone(&self) -> Self { - AmdTextureGatherBiasLodFn {} - } - } - impl AmdTextureGatherBiasLodFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdTextureGatherBiasLodFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_AMD_texture_gather_bias_lod\'"] - impl StructureType { - pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = StructureType(1000041000); - } - pub struct AmdShaderInfoFn { - get_shader_info_amd: extern "system" fn( - device: Device, - pipeline: Pipeline, - shader_stage: ShaderStageFlags, - info_type: ShaderInfoTypeAMD, - p_info_size: *mut usize, - p_info: *mut c_void, ) -> Result, - } - unsafe impl Send for AmdShaderInfoFn {} - unsafe impl Sync for AmdShaderInfoFn {} - impl ::std::clone::Clone for AmdShaderInfoFn { - fn clone(&self) -> Self { - AmdShaderInfoFn { - get_shader_info_amd: self.get_shader_info_amd, - } - } - } - impl AmdShaderInfoFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderInfoFn { - get_shader_info_amd: unsafe { - let raw_name = stringify!(vkGetShaderInfoAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_shader_info_amd( - &self, - device: Device, - pipeline: Pipeline, - shader_stage: ShaderStageFlags, - info_type: ShaderInfoTypeAMD, - p_info_size: *mut usize, - p_info: *mut c_void, - ) -> Result { - (self.get_shader_info_amd)( - device, - pipeline, - shader_stage, - info_type, - p_info_size, - p_info, - ) - } - } - pub struct AmdExtension44Fn {} - unsafe impl Send for AmdExtension44Fn {} - unsafe impl Sync for AmdExtension44Fn {} - impl ::std::clone::Clone for AmdExtension44Fn { - fn clone(&self) -> Self { - AmdExtension44Fn {} - } - } - impl AmdExtension44Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension44Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension45Fn {} - unsafe impl Send for AmdExtension45Fn {} - unsafe impl Sync for AmdExtension45Fn {} - impl ::std::clone::Clone for AmdExtension45Fn { - fn clone(&self) -> Self { - AmdExtension45Fn {} - } - } - impl AmdExtension45Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension45Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension46Fn {} - unsafe impl Send for AmdExtension46Fn {} - unsafe impl Sync for AmdExtension46Fn {} - impl ::std::clone::Clone for AmdExtension46Fn { - fn clone(&self) -> Self { - AmdExtension46Fn {} - } - } - impl AmdExtension46Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension46Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdShaderImageLoadStoreLodFn {} - unsafe impl Send for AmdShaderImageLoadStoreLodFn {} - unsafe impl Sync for AmdShaderImageLoadStoreLodFn {} - impl ::std::clone::Clone for AmdShaderImageLoadStoreLodFn { - fn clone(&self) -> Self { - AmdShaderImageLoadStoreLodFn {} - } - } - impl AmdShaderImageLoadStoreLodFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderImageLoadStoreLodFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvxExtension48Fn {} - unsafe impl Send for NvxExtension48Fn {} - unsafe impl Sync for NvxExtension48Fn {} - impl ::std::clone::Clone for NvxExtension48Fn { - fn clone(&self) -> Self { - NvxExtension48Fn {} - } - } - impl NvxExtension48Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxExtension48Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct GoogleExtension49Fn {} - unsafe impl Send for GoogleExtension49Fn {} - unsafe impl Sync for GoogleExtension49Fn {} - impl ::std::clone::Clone for GoogleExtension49Fn { - fn clone(&self) -> Self { - GoogleExtension49Fn {} - } - } - impl GoogleExtension49Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleExtension49Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct GoogleExtension50Fn {} - unsafe impl Send for GoogleExtension50Fn {} - unsafe impl Sync for GoogleExtension50Fn {} - impl ::std::clone::Clone for GoogleExtension50Fn { - fn clone(&self) -> Self { - GoogleExtension50Fn {} - } - } - impl GoogleExtension50Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleExtension50Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvxExtension51Fn {} - unsafe impl Send for NvxExtension51Fn {} - unsafe impl Sync for NvxExtension51Fn {} - impl ::std::clone::Clone for NvxExtension51Fn { - fn clone(&self) -> Self { - NvxExtension51Fn {} - } - } - impl NvxExtension51Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxExtension51Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvxExtension52Fn {} - unsafe impl Send for NvxExtension52Fn {} - unsafe impl Sync for NvxExtension52Fn {} - impl ::std::clone::Clone for NvxExtension52Fn { - fn clone(&self) -> Self { - NvxExtension52Fn {} - } - } - impl NvxExtension52Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxExtension52Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension53Fn {} - unsafe impl Send for NvExtension53Fn {} - unsafe impl Sync for NvExtension53Fn {} - impl ::std::clone::Clone for NvExtension53Fn { - fn clone(&self) -> Self { - NvExtension53Fn {} - } - } - impl NvExtension53Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension53Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrMultiviewFn {} - unsafe impl Send for KhrMultiviewFn {} - unsafe impl Sync for KhrMultiviewFn {} - impl ::std::clone::Clone for KhrMultiviewFn { - fn clone(&self) -> Self { - KhrMultiviewFn {} - } - } - impl KhrMultiviewFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrMultiviewFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ImgFormatPvrtcFn {} - unsafe impl Send for ImgFormatPvrtcFn {} - unsafe impl Sync for ImgFormatPvrtcFn {} - impl ::std::clone::Clone for ImgFormatPvrtcFn { - fn clone(&self) -> Self { - ImgFormatPvrtcFn {} - } - } - impl ImgFormatPvrtcFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgFormatPvrtcFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Format(1000054000); - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Format(1000054001); - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Format(1000054002); - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Format(1000054003); - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Format(1000054004); - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Format(1000054005); - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Format(1000054006); - } - #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] - impl Format { - pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Format(1000054007); - } - pub struct NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv : extern "system" fn ( physical_device : PhysicalDevice , format : Format , ty : ImageType , tiling : ImageTiling , usage : ImageUsageFlags , flags : ImageCreateFlags , external_handle_type : ExternalMemoryHandleTypeFlagsNV , p_external_image_format_properties : *mut ExternalImageFormatPropertiesNV , ) -> Result , } - unsafe impl Send for NvExternalMemoryCapabilitiesFn {} - unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} - impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { - fn clone(&self) -> Self { - NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: - self.get_physical_device_external_image_format_properties_nv, - } - } - } - impl NvExternalMemoryCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_physical_device_external_image_format_properties_nv( - &self, - physical_device: PhysicalDevice, - format: Format, - ty: ImageType, - tiling: ImageTiling, - usage: ImageUsageFlags, - flags: ImageCreateFlags, - external_handle_type: ExternalMemoryHandleTypeFlagsNV, - p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, - ) -> Result { - (self.get_physical_device_external_image_format_properties_nv)( - physical_device, - format, - ty, - tiling, - usage, - flags, - external_handle_type, - p_external_image_format_properties, - ) - } - } - pub struct NvExternalMemoryFn {} - unsafe impl Send for NvExternalMemoryFn {} - unsafe impl Sync for NvExternalMemoryFn {} - impl ::std::clone::Clone for NvExternalMemoryFn { - fn clone(&self) -> Self { - NvExternalMemoryFn {} - } - } - impl NvExternalMemoryFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_external_memory\'"] - impl StructureType { - pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = StructureType(1000056000); - } - #[doc = "Generated from \'VK_NV_external_memory\'"] - impl StructureType { - pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = StructureType(1000056001); - } - pub struct NvExternalMemoryWin32Fn { - get_memory_win32_handle_nv: - extern "system" fn( - device: Device, - memory: DeviceMemory, - handle_type: ExternalMemoryHandleTypeFlagsNV, - p_handle: *mut HANDLE, - ) -> Result, - } - unsafe impl Send for NvExternalMemoryWin32Fn {} - unsafe impl Sync for NvExternalMemoryWin32Fn {} - impl ::std::clone::Clone for NvExternalMemoryWin32Fn { - fn clone(&self) -> Self { - NvExternalMemoryWin32Fn { - get_memory_win32_handle_nv: self.get_memory_win32_handle_nv, - } - } - } - impl NvExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryWin32Fn { - get_memory_win32_handle_nv: unsafe { - let raw_name = stringify!(vkGetMemoryWin32HandleNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_memory_win32_handle_nv( - &self, - device: Device, - memory: DeviceMemory, - handle_type: ExternalMemoryHandleTypeFlagsNV, - p_handle: *mut HANDLE, - ) -> Result { - (self.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle) - } - } - #[doc = "Generated from \'VK_NV_external_memory_win32\'"] - impl StructureType { - pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = StructureType(1000057000); - } - #[doc = "Generated from \'VK_NV_external_memory_win32\'"] - impl StructureType { - pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = StructureType(1000057001); - } - pub struct NvWin32KeyedMutexFn {} - unsafe impl Send for NvWin32KeyedMutexFn {} - unsafe impl Sync for NvWin32KeyedMutexFn {} - impl ::std::clone::Clone for NvWin32KeyedMutexFn { - fn clone(&self) -> Self { - NvWin32KeyedMutexFn {} - } - } - impl NvWin32KeyedMutexFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvWin32KeyedMutexFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_win32_keyed_mutex\'"] - impl StructureType { - pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = StructureType(1000058000); - } - pub struct KhrGetPhysicalDeviceProperties2Fn {} - unsafe impl Send for KhrGetPhysicalDeviceProperties2Fn {} - unsafe impl Sync for KhrGetPhysicalDeviceProperties2Fn {} - impl ::std::clone::Clone for KhrGetPhysicalDeviceProperties2Fn { - fn clone(&self) -> Self { - KhrGetPhysicalDeviceProperties2Fn {} - } - } - impl KhrGetPhysicalDeviceProperties2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrGetPhysicalDeviceProperties2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } - unsafe impl Send for KhrDeviceGroupFn {} - unsafe impl Sync for KhrDeviceGroupFn {} - impl ::std::clone::Clone for KhrDeviceGroupFn { - fn clone(&self) -> Self { - KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, - acquire_next_image2_khr: self.acquire_next_image2_khr, - } - } - } - impl KhrDeviceGroupFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_device_group_surface_present_modes_khr: unsafe { - let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_present_rectangles_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - acquire_next_image2_khr: unsafe { - let raw_name = stringify!(vkAcquireNextImage2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_device_group_present_capabilities_khr( - &self, - device: Device, - p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, - ) -> Result { - (self.get_device_group_present_capabilities_khr)( - device, - p_device_group_present_capabilities, - ) - } - pub unsafe fn get_device_group_surface_present_modes_khr( - &self, - device: Device, - surface: SurfaceKHR, - p_modes: *mut DeviceGroupPresentModeFlagsKHR, - ) -> Result { - (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) - } - pub unsafe fn get_physical_device_present_rectangles_khr( - &self, - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_rect_count: *mut u32, - p_rects: *mut Rect2D, - ) -> Result { - (self.get_physical_device_present_rectangles_khr)( - physical_device, - surface, - p_rect_count, - p_rects, - ) - } - pub unsafe fn acquire_next_image2_khr( - &self, - device: Device, - p_acquire_info: *const AcquireNextImageInfoKHR, - p_image_index: *mut u32, - ) -> Result { - (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) - } - } - pub struct ExtValidationFlagsFn {} - unsafe impl Send for ExtValidationFlagsFn {} - unsafe impl Sync for ExtValidationFlagsFn {} - impl ::std::clone::Clone for ExtValidationFlagsFn { - fn clone(&self) -> Self { - ExtValidationFlagsFn {} - } - } - impl ExtValidationFlagsFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtValidationFlagsFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_EXT_validation_flags\'"] - impl StructureType { - pub const VALIDATION_FLAGS_EXT: Self = StructureType(1000061000); - } - pub struct NnViSurfaceFn { - create_vi_surface_nn: extern "system" fn( - instance: Instance, - p_create_info: *const ViSurfaceCreateInfoNN, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, - } - unsafe impl Send for NnViSurfaceFn {} - unsafe impl Sync for NnViSurfaceFn {} - impl ::std::clone::Clone for NnViSurfaceFn { - fn clone(&self) -> Self { - NnViSurfaceFn { - create_vi_surface_nn: self.create_vi_surface_nn, - } - } - } - impl NnViSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NnViSurfaceFn { - create_vi_surface_nn: unsafe { - let raw_name = stringify!(vkCreateViSurfaceNN); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_vi_surface_nn( - &self, - instance: Instance, - p_create_info: *const ViSurfaceCreateInfoNN, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_vi_surface_nn)(instance, p_create_info, p_allocator, p_surface) - } - } - #[doc = "Generated from \'VK_NN_vi_surface\'"] - impl StructureType { - pub const VI_SURFACE_CREATE_INFO_NN: Self = StructureType(1000062000); - } - pub struct KhrShaderDrawParametersFn {} - unsafe impl Send for KhrShaderDrawParametersFn {} - unsafe impl Sync for KhrShaderDrawParametersFn {} - impl ::std::clone::Clone for KhrShaderDrawParametersFn { - fn clone(&self) -> Self { - KhrShaderDrawParametersFn {} - } - } - impl KhrShaderDrawParametersFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrShaderDrawParametersFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtShaderSubgroupBallotFn {} - unsafe impl Send for ExtShaderSubgroupBallotFn {} - unsafe impl Sync for ExtShaderSubgroupBallotFn {} - impl ::std::clone::Clone for ExtShaderSubgroupBallotFn { - fn clone(&self) -> Self { - ExtShaderSubgroupBallotFn {} - } - } - impl ExtShaderSubgroupBallotFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtShaderSubgroupBallotFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtShaderSubgroupVoteFn {} - unsafe impl Send for ExtShaderSubgroupVoteFn {} - unsafe impl Sync for ExtShaderSubgroupVoteFn {} - impl ::std::clone::Clone for ExtShaderSubgroupVoteFn { - fn clone(&self) -> Self { - ExtShaderSubgroupVoteFn {} - } - } - impl ExtShaderSubgroupVoteFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtShaderSubgroupVoteFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ArmExtension01Fn {} - unsafe impl Send for ArmExtension01Fn {} - unsafe impl Sync for ArmExtension01Fn {} - impl ::std::clone::Clone for ArmExtension01Fn { - fn clone(&self) -> Self { - ArmExtension01Fn {} - } - } - impl ArmExtension01Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ArmExtension01Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ArmExtension02Fn {} - unsafe impl Send for ArmExtension02Fn {} - unsafe impl Sync for ArmExtension02Fn {} - impl ::std::clone::Clone for ArmExtension02Fn { - fn clone(&self) -> Self { - ArmExtension02Fn {} - } - } - impl ArmExtension02Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ArmExtension02Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ImgExtension69Fn {} - unsafe impl Send for ImgExtension69Fn {} - unsafe impl Sync for ImgExtension69Fn {} - impl ::std::clone::Clone for ImgExtension69Fn { - fn clone(&self) -> Self { - ImgExtension69Fn {} - } - } - impl ImgExtension69Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgExtension69Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrMaintenance1Fn {} - unsafe impl Send for KhrMaintenance1Fn {} - unsafe impl Sync for KhrMaintenance1Fn {} - impl ::std::clone::Clone for KhrMaintenance1Fn { - fn clone(&self) -> Self { - KhrMaintenance1Fn {} - } - } - impl KhrMaintenance1Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrMaintenance1Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrDeviceGroupCreationFn {} - unsafe impl Send for KhrDeviceGroupCreationFn {} - unsafe impl Sync for KhrDeviceGroupCreationFn {} - impl ::std::clone::Clone for KhrDeviceGroupCreationFn { - fn clone(&self) -> Self { - KhrDeviceGroupCreationFn {} - } - } - impl KhrDeviceGroupCreationFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDeviceGroupCreationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExternalMemoryCapabilitiesFn {} - unsafe impl Send for KhrExternalMemoryCapabilitiesFn {} - unsafe impl Sync for KhrExternalMemoryCapabilitiesFn {} - impl ::std::clone::Clone for KhrExternalMemoryCapabilitiesFn { - fn clone(&self) -> Self { - KhrExternalMemoryCapabilitiesFn {} - } - } - impl KhrExternalMemoryCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExternalMemoryFn {} - unsafe impl Send for KhrExternalMemoryFn {} - unsafe impl Sync for KhrExternalMemoryFn {} - impl ::std::clone::Clone for KhrExternalMemoryFn { - fn clone(&self) -> Self { - KhrExternalMemoryFn {} - } - } - impl KhrExternalMemoryFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExternalMemoryWin32Fn { get_memory_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const MemoryGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , get_memory_win32_handle_properties_khr : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , handle : HANDLE , p_memory_win32_handle_properties : *mut MemoryWin32HandlePropertiesKHR , ) -> Result , } - unsafe impl Send for KhrExternalMemoryWin32Fn {} - unsafe impl Sync for KhrExternalMemoryWin32Fn {} - impl ::std::clone::Clone for KhrExternalMemoryWin32Fn { - fn clone(&self) -> Self { - KhrExternalMemoryWin32Fn { - get_memory_win32_handle_khr: self.get_memory_win32_handle_khr, - get_memory_win32_handle_properties_khr: self.get_memory_win32_handle_properties_khr, - } - } - } - impl KhrExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryWin32Fn { - get_memory_win32_handle_khr: unsafe { - let raw_name = stringify!(vkGetMemoryWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_memory_win32_handle_properties_khr: unsafe { - let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_memory_win32_handle_khr( - &self, + destroy_debug_report_callback_ext: extern "system" fn( + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + debug_report_message_ext: extern "system" fn( + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: u64, + location: usize, + message_code: i32, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> c_void, +} +unsafe impl Send for ExtDebugReportFn {} +unsafe impl Sync for ExtDebugReportFn {} +impl ::std::clone::Clone for ExtDebugReportFn { + fn clone(&self) -> Self { + ExtDebugReportFn { + create_debug_report_callback_ext: self.create_debug_report_callback_ext, + destroy_debug_report_callback_ext: self.destroy_debug_report_callback_ext, + debug_report_message_ext: self.debug_report_message_ext, + } + } +} +impl ExtDebugReportFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugReportFn { + create_debug_report_callback_ext: unsafe { + let raw_name = stringify!(vkCreateDebugReportCallbackEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_debug_report_callback_ext: unsafe { + let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + debug_report_message_ext: unsafe { + let raw_name = stringify!(vkDebugReportMessageEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_debug_report_callback_ext( + &self, + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *mut DebugReportCallbackEXT, + ) -> Result { + (self.create_debug_report_callback_ext)(instance, p_create_info, p_allocator, p_callback) + } + pub unsafe fn destroy_debug_report_callback_ext( + &self, + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_debug_report_callback_ext)(instance, callback, p_allocator) + } + pub unsafe fn debug_report_message_ext( + &self, + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: u64, + location: usize, + message_code: i32, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> c_void { + (self.debug_report_message_ext)( + instance, + flags, + object_type, + object, + location, + message_code, + p_layer_prefix, + p_message, + ) + } +} +#[doc = "Generated from \'VK_EXT_debug_report\'"] +impl StructureType { + pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = StructureType(1000011000); +} +#[doc = "Generated from \'VK_EXT_debug_report\'"] +impl Result { + pub const ERROR_VALIDATION_FAILED_EXT: Self = Result(-1000011001); +} +#[doc = "Generated from \'VK_EXT_debug_report\'"] +impl ObjectType { + pub const DEBUG_REPORT_CALLBACK_EXT: Self = ObjectType(1000011000); +} +#[doc = "Generated from \'VK_EXT_debug_report\'"] +impl DebugReportObjectTypeEXT { + pub const SAMPLER_YCBCR_CONVERSION: Self = DebugReportObjectTypeEXT(1000156000); +} +#[doc = "Generated from \'VK_EXT_debug_report\'"] +impl DebugReportObjectTypeEXT { + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = DebugReportObjectTypeEXT(1000085000); +} +pub struct NvGlslShaderFn {} +unsafe impl Send for NvGlslShaderFn {} +unsafe impl Sync for NvGlslShaderFn {} +impl ::std::clone::Clone for NvGlslShaderFn { + fn clone(&self) -> Self { + NvGlslShaderFn {} + } +} +impl NvGlslShaderFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvGlslShaderFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_glsl_shader\'"] +impl Result { + pub const ERROR_INVALID_SHADER_NV: Self = Result(-1000012000); +} +pub struct ExtDepthRangeUnrestrictedFn {} +unsafe impl Send for ExtDepthRangeUnrestrictedFn {} +unsafe impl Sync for ExtDepthRangeUnrestrictedFn {} +impl ::std::clone::Clone for ExtDepthRangeUnrestrictedFn { + fn clone(&self) -> Self { + ExtDepthRangeUnrestrictedFn {} + } +} +impl ExtDepthRangeUnrestrictedFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDepthRangeUnrestrictedFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrSamplerMirrorClampToEdgeFn {} +unsafe impl Send for KhrSamplerMirrorClampToEdgeFn {} +unsafe impl Sync for KhrSamplerMirrorClampToEdgeFn {} +impl ::std::clone::Clone for KhrSamplerMirrorClampToEdgeFn { + fn clone(&self) -> Self { + KhrSamplerMirrorClampToEdgeFn {} + } +} +impl KhrSamplerMirrorClampToEdgeFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSamplerMirrorClampToEdgeFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ImgFilterCubicFn {} +unsafe impl Send for ImgFilterCubicFn {} +unsafe impl Sync for ImgFilterCubicFn {} +impl ::std::clone::Clone for ImgFilterCubicFn { + fn clone(&self) -> Self { + ImgFilterCubicFn {} + } +} +impl ImgFilterCubicFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgFilterCubicFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_IMG_filter_cubic\'"] +impl Filter { + pub const CUBIC_IMG: Self = Filter(1000015000); +} +#[doc = "Generated from \'VK_IMG_filter_cubic\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = FormatFeatureFlags(0b10000000000000); +} +pub struct AmdExtension17Fn {} +unsafe impl Send for AmdExtension17Fn {} +unsafe impl Sync for AmdExtension17Fn {} +impl ::std::clone::Clone for AmdExtension17Fn { + fn clone(&self) -> Self { + AmdExtension17Fn {} + } +} +impl AmdExtension17Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension17Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension18Fn {} +unsafe impl Send for AmdExtension18Fn {} +unsafe impl Sync for AmdExtension18Fn {} +impl ::std::clone::Clone for AmdExtension18Fn { + fn clone(&self) -> Self { + AmdExtension18Fn {} + } +} +impl AmdExtension18Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension18Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdRasterizationOrderFn {} +unsafe impl Send for AmdRasterizationOrderFn {} +unsafe impl Sync for AmdRasterizationOrderFn {} +impl ::std::clone::Clone for AmdRasterizationOrderFn { + fn clone(&self) -> Self { + AmdRasterizationOrderFn {} + } +} +impl AmdRasterizationOrderFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdRasterizationOrderFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_AMD_rasterization_order\'"] +impl StructureType { + pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = + StructureType(1000018000); +} +pub struct AmdExtension20Fn {} +unsafe impl Send for AmdExtension20Fn {} +unsafe impl Sync for AmdExtension20Fn {} +impl ::std::clone::Clone for AmdExtension20Fn { + fn clone(&self) -> Self { + AmdExtension20Fn {} + } +} +impl AmdExtension20Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension20Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdShaderTrinaryMinmaxFn {} +unsafe impl Send for AmdShaderTrinaryMinmaxFn {} +unsafe impl Sync for AmdShaderTrinaryMinmaxFn {} +impl ::std::clone::Clone for AmdShaderTrinaryMinmaxFn { + fn clone(&self) -> Self { + AmdShaderTrinaryMinmaxFn {} + } +} +impl AmdShaderTrinaryMinmaxFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderTrinaryMinmaxFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdShaderExplicitVertexParameterFn {} +unsafe impl Send for AmdShaderExplicitVertexParameterFn {} +unsafe impl Sync for AmdShaderExplicitVertexParameterFn {} +impl ::std::clone::Clone for AmdShaderExplicitVertexParameterFn { + fn clone(&self) -> Self { + AmdShaderExplicitVertexParameterFn {} + } +} +impl AmdShaderExplicitVertexParameterFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderExplicitVertexParameterFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: + extern "system" fn(device: Device, p_tag_info: *const DebugMarkerObjectTagInfoEXT) + -> Result, + debug_marker_set_object_name_ext: + extern "system" fn(device: Device, p_name_info: *const DebugMarkerObjectNameInfoEXT) + -> Result, + cmd_debug_marker_begin_ext: extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void, + cmd_debug_marker_end_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, + cmd_debug_marker_insert_ext: extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void, +} +unsafe impl Send for ExtDebugMarkerFn {} +unsafe impl Sync for ExtDebugMarkerFn {} +impl ::std::clone::Clone for ExtDebugMarkerFn { + fn clone(&self) -> Self { + ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: self.debug_marker_set_object_tag_ext, + debug_marker_set_object_name_ext: self.debug_marker_set_object_name_ext, + cmd_debug_marker_begin_ext: self.cmd_debug_marker_begin_ext, + cmd_debug_marker_end_ext: self.cmd_debug_marker_end_ext, + cmd_debug_marker_insert_ext: self.cmd_debug_marker_insert_ext, + } + } +} +impl ExtDebugMarkerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugMarkerFn { + debug_marker_set_object_tag_ext: unsafe { + let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + debug_marker_set_object_name_ext: unsafe { + let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_begin_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_end_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerEndEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_debug_marker_insert_ext: unsafe { + let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn debug_marker_set_object_tag_ext( + &self, + device: Device, + p_tag_info: *const DebugMarkerObjectTagInfoEXT, + ) -> Result { + (self.debug_marker_set_object_tag_ext)(device, p_tag_info) + } + pub unsafe fn debug_marker_set_object_name_ext( + &self, + device: Device, + p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result { + (self.debug_marker_set_object_name_ext)(device, p_name_info) + } + pub unsafe fn cmd_debug_marker_begin_ext( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + (self.cmd_debug_marker_begin_ext)(command_buffer, p_marker_info) + } + pub unsafe fn cmd_debug_marker_end_ext(&self, command_buffer: CommandBuffer) -> c_void { + (self.cmd_debug_marker_end_ext)(command_buffer) + } + pub unsafe fn cmd_debug_marker_insert_ext( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + (self.cmd_debug_marker_insert_ext)(command_buffer, p_marker_info) + } +} +#[doc = "Generated from \'VK_EXT_debug_marker\'"] +impl StructureType { + pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = StructureType(1000022000); +} +#[doc = "Generated from \'VK_EXT_debug_marker\'"] +impl StructureType { + pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = StructureType(1000022001); +} +#[doc = "Generated from \'VK_EXT_debug_marker\'"] +impl StructureType { + pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = StructureType(1000022002); +} +pub struct AmdExtension24Fn {} +unsafe impl Send for AmdExtension24Fn {} +unsafe impl Sync for AmdExtension24Fn {} +impl ::std::clone::Clone for AmdExtension24Fn { + fn clone(&self) -> Self { + AmdExtension24Fn {} + } +} +impl AmdExtension24Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension24Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension25Fn {} +unsafe impl Send for AmdExtension25Fn {} +unsafe impl Sync for AmdExtension25Fn {} +impl ::std::clone::Clone for AmdExtension25Fn { + fn clone(&self) -> Self { + AmdExtension25Fn {} + } +} +impl AmdExtension25Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension25Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdGcnShaderFn {} +unsafe impl Send for AmdGcnShaderFn {} +unsafe impl Sync for AmdGcnShaderFn {} +impl ::std::clone::Clone for AmdGcnShaderFn { + fn clone(&self) -> Self { + AmdGcnShaderFn {} + } +} +impl AmdGcnShaderFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdGcnShaderFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvDedicatedAllocationFn {} +unsafe impl Send for NvDedicatedAllocationFn {} +unsafe impl Sync for NvDedicatedAllocationFn {} +impl ::std::clone::Clone for NvDedicatedAllocationFn { + fn clone(&self) -> Self { + NvDedicatedAllocationFn {} + } +} +impl NvDedicatedAllocationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvDedicatedAllocationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_dedicated_allocation\'"] +impl StructureType { + pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = StructureType(1000026000); +} +#[doc = "Generated from \'VK_NV_dedicated_allocation\'"] +impl StructureType { + pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = StructureType(1000026001); +} +#[doc = "Generated from \'VK_NV_dedicated_allocation\'"] +impl StructureType { + pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = StructureType(1000026002); +} +pub struct ExtExtension28Fn {} +unsafe impl Send for ExtExtension28Fn {} +unsafe impl Sync for ExtExtension28Fn {} +impl ::std::clone::Clone for ExtExtension28Fn { + fn clone(&self) -> Self { + ExtExtension28Fn {} + } +} +impl ExtExtension28Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension28Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvxExtension29Fn {} +unsafe impl Send for NvxExtension29Fn {} +unsafe impl Sync for NvxExtension29Fn {} +impl ::std::clone::Clone for NvxExtension29Fn { + fn clone(&self) -> Self { + NvxExtension29Fn {} + } +} +impl NvxExtension29Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension29Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvxExtension30Fn {} +unsafe impl Send for NvxExtension30Fn {} +unsafe impl Sync for NvxExtension30Fn {} +impl ::std::clone::Clone for NvxExtension30Fn { + fn clone(&self) -> Self { + NvxExtension30Fn {} + } +} +impl NvxExtension30Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension30Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvxExtension31Fn {} +unsafe impl Send for NvxExtension31Fn {} +unsafe impl Sync for NvxExtension31Fn {} +impl ::std::clone::Clone for NvxExtension31Fn { + fn clone(&self) -> Self { + NvxExtension31Fn {} + } +} +impl NvxExtension31Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension31Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension32Fn {} +unsafe impl Send for AmdExtension32Fn {} +unsafe impl Sync for AmdExtension32Fn {} +impl ::std::clone::Clone for AmdExtension32Fn { + fn clone(&self) -> Self { + AmdExtension32Fn {} + } +} +impl AmdExtension32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension32Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension33Fn {} +unsafe impl Send for AmdExtension33Fn {} +unsafe impl Sync for AmdExtension33Fn {} +impl ::std::clone::Clone for AmdExtension33Fn { + fn clone(&self) -> Self { + AmdExtension33Fn {} + } +} +impl AmdExtension33Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension33Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void, + cmd_draw_indexed_indirect_count_amd: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void, +} +unsafe impl Send for AmdDrawIndirectCountFn {} +unsafe impl Sync for AmdDrawIndirectCountFn {} +impl ::std::clone::Clone for AmdDrawIndirectCountFn { + fn clone(&self) -> Self { + AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: self.cmd_draw_indirect_count_amd, + cmd_draw_indexed_indirect_count_amd: self.cmd_draw_indexed_indirect_count_amd, + } + } +} +impl AmdDrawIndirectCountFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdDrawIndirectCountFn { + cmd_draw_indirect_count_amd: unsafe { + let raw_name = stringify!(vkCmdDrawIndirectCountAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed_indirect_count_amd: unsafe { + let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_draw_indirect_count_amd( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_indirect_count_amd)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + pub unsafe fn cmd_draw_indexed_indirect_count_amd( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_indexed_indirect_count_amd)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } +} +pub struct AmdExtension35Fn {} +unsafe impl Send for AmdExtension35Fn {} +unsafe impl Sync for AmdExtension35Fn {} +impl ::std::clone::Clone for AmdExtension35Fn { + fn clone(&self) -> Self { + AmdExtension35Fn {} + } +} +impl AmdExtension35Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension35Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdNegativeViewportHeightFn {} +unsafe impl Send for AmdNegativeViewportHeightFn {} +unsafe impl Sync for AmdNegativeViewportHeightFn {} +impl ::std::clone::Clone for AmdNegativeViewportHeightFn { + fn clone(&self) -> Self { + AmdNegativeViewportHeightFn {} + } +} +impl AmdNegativeViewportHeightFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdNegativeViewportHeightFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdGpuShaderHalfFloatFn {} +unsafe impl Send for AmdGpuShaderHalfFloatFn {} +unsafe impl Sync for AmdGpuShaderHalfFloatFn {} +impl ::std::clone::Clone for AmdGpuShaderHalfFloatFn { + fn clone(&self) -> Self { + AmdGpuShaderHalfFloatFn {} + } +} +impl AmdGpuShaderHalfFloatFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdGpuShaderHalfFloatFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdShaderBallotFn {} +unsafe impl Send for AmdShaderBallotFn {} +unsafe impl Sync for AmdShaderBallotFn {} +impl ::std::clone::Clone for AmdShaderBallotFn { + fn clone(&self) -> Self { + AmdShaderBallotFn {} + } +} +impl AmdShaderBallotFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderBallotFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension39Fn {} +unsafe impl Send for AmdExtension39Fn {} +unsafe impl Sync for AmdExtension39Fn {} +impl ::std::clone::Clone for AmdExtension39Fn { + fn clone(&self) -> Self { + AmdExtension39Fn {} + } +} +impl AmdExtension39Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension39Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension40Fn {} +unsafe impl Send for AmdExtension40Fn {} +unsafe impl Sync for AmdExtension40Fn {} +impl ::std::clone::Clone for AmdExtension40Fn { + fn clone(&self) -> Self { + AmdExtension40Fn {} + } +} +impl AmdExtension40Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension40Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension41Fn {} +unsafe impl Send for AmdExtension41Fn {} +unsafe impl Sync for AmdExtension41Fn {} +impl ::std::clone::Clone for AmdExtension41Fn { + fn clone(&self) -> Self { + AmdExtension41Fn {} + } +} +impl AmdExtension41Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension41Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdTextureGatherBiasLodFn {} +unsafe impl Send for AmdTextureGatherBiasLodFn {} +unsafe impl Sync for AmdTextureGatherBiasLodFn {} +impl ::std::clone::Clone for AmdTextureGatherBiasLodFn { + fn clone(&self) -> Self { + AmdTextureGatherBiasLodFn {} + } +} +impl AmdTextureGatherBiasLodFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdTextureGatherBiasLodFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_AMD_texture_gather_bias_lod\'"] +impl StructureType { + pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = StructureType(1000041000); +} +pub struct AmdShaderInfoFn { + get_shader_info_amd: extern "system" fn( + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *mut usize, + p_info: *mut c_void, + ) -> Result, +} +unsafe impl Send for AmdShaderInfoFn {} +unsafe impl Sync for AmdShaderInfoFn {} +impl ::std::clone::Clone for AmdShaderInfoFn { + fn clone(&self) -> Self { + AmdShaderInfoFn { + get_shader_info_amd: self.get_shader_info_amd, + } + } +} +impl AmdShaderInfoFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderInfoFn { + get_shader_info_amd: unsafe { + let raw_name = stringify!(vkGetShaderInfoAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_shader_info_amd( + &self, + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *mut usize, + p_info: *mut c_void, + ) -> Result { + (self.get_shader_info_amd)( + device, + pipeline, + shader_stage, + info_type, + p_info_size, + p_info, + ) + } +} +pub struct AmdExtension44Fn {} +unsafe impl Send for AmdExtension44Fn {} +unsafe impl Sync for AmdExtension44Fn {} +impl ::std::clone::Clone for AmdExtension44Fn { + fn clone(&self) -> Self { + AmdExtension44Fn {} + } +} +impl AmdExtension44Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension44Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension45Fn {} +unsafe impl Send for AmdExtension45Fn {} +unsafe impl Sync for AmdExtension45Fn {} +impl ::std::clone::Clone for AmdExtension45Fn { + fn clone(&self) -> Self { + AmdExtension45Fn {} + } +} +impl AmdExtension45Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension45Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension46Fn {} +unsafe impl Send for AmdExtension46Fn {} +unsafe impl Sync for AmdExtension46Fn {} +impl ::std::clone::Clone for AmdExtension46Fn { + fn clone(&self) -> Self { + AmdExtension46Fn {} + } +} +impl AmdExtension46Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension46Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdShaderImageLoadStoreLodFn {} +unsafe impl Send for AmdShaderImageLoadStoreLodFn {} +unsafe impl Sync for AmdShaderImageLoadStoreLodFn {} +impl ::std::clone::Clone for AmdShaderImageLoadStoreLodFn { + fn clone(&self) -> Self { + AmdShaderImageLoadStoreLodFn {} + } +} +impl AmdShaderImageLoadStoreLodFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderImageLoadStoreLodFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvxExtension48Fn {} +unsafe impl Send for NvxExtension48Fn {} +unsafe impl Sync for NvxExtension48Fn {} +impl ::std::clone::Clone for NvxExtension48Fn { + fn clone(&self) -> Self { + NvxExtension48Fn {} + } +} +impl NvxExtension48Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension48Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct GoogleExtension49Fn {} +unsafe impl Send for GoogleExtension49Fn {} +unsafe impl Sync for GoogleExtension49Fn {} +impl ::std::clone::Clone for GoogleExtension49Fn { + fn clone(&self) -> Self { + GoogleExtension49Fn {} + } +} +impl GoogleExtension49Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension49Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct GoogleExtension50Fn {} +unsafe impl Send for GoogleExtension50Fn {} +unsafe impl Sync for GoogleExtension50Fn {} +impl ::std::clone::Clone for GoogleExtension50Fn { + fn clone(&self) -> Self { + GoogleExtension50Fn {} + } +} +impl GoogleExtension50Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension50Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvxExtension51Fn {} +unsafe impl Send for NvxExtension51Fn {} +unsafe impl Sync for NvxExtension51Fn {} +impl ::std::clone::Clone for NvxExtension51Fn { + fn clone(&self) -> Self { + NvxExtension51Fn {} + } +} +impl NvxExtension51Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension51Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvxExtension52Fn {} +unsafe impl Send for NvxExtension52Fn {} +unsafe impl Sync for NvxExtension52Fn {} +impl ::std::clone::Clone for NvxExtension52Fn { + fn clone(&self) -> Self { + NvxExtension52Fn {} + } +} +impl NvxExtension52Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxExtension52Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension53Fn {} +unsafe impl Send for NvExtension53Fn {} +unsafe impl Sync for NvExtension53Fn {} +impl ::std::clone::Clone for NvExtension53Fn { + fn clone(&self) -> Self { + NvExtension53Fn {} + } +} +impl NvExtension53Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension53Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrMultiviewFn {} +unsafe impl Send for KhrMultiviewFn {} +unsafe impl Sync for KhrMultiviewFn {} +impl ::std::clone::Clone for KhrMultiviewFn { + fn clone(&self) -> Self { + KhrMultiviewFn {} + } +} +impl KhrMultiviewFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMultiviewFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ImgFormatPvrtcFn {} +unsafe impl Send for ImgFormatPvrtcFn {} +unsafe impl Sync for ImgFormatPvrtcFn {} +impl ::std::clone::Clone for ImgFormatPvrtcFn { + fn clone(&self) -> Self { + ImgFormatPvrtcFn {} + } +} +impl ImgFormatPvrtcFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgFormatPvrtcFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Format(1000054000); +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Format(1000054001); +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Format(1000054002); +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Format(1000054003); +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Format(1000054004); +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Format(1000054005); +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Format(1000054006); +} +#[doc = "Generated from \'VK_IMG_format_pvrtc\'"] +impl Format { + pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Format(1000054007); +} +pub struct NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv : extern "system" fn ( physical_device : PhysicalDevice , format : Format , ty : ImageType , tiling : ImageTiling , usage : ImageUsageFlags , flags : ImageCreateFlags , external_handle_type : ExternalMemoryHandleTypeFlagsNV , p_external_image_format_properties : *mut ExternalImageFormatPropertiesNV , ) -> Result , } +unsafe impl Send for NvExternalMemoryCapabilitiesFn {} +unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} +impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { + fn clone(&self) -> Self { + NvExternalMemoryCapabilitiesFn { + get_physical_device_external_image_format_properties_nv: + self.get_physical_device_external_image_format_properties_nv, + } + } +} +impl NvExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryCapabilitiesFn { + get_physical_device_external_image_format_properties_nv: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_physical_device_external_image_format_properties_nv( + &self, + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + external_handle_type: ExternalMemoryHandleTypeFlagsNV, + p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, + ) -> Result { + (self.get_physical_device_external_image_format_properties_nv)( + physical_device, + format, + ty, + tiling, + usage, + flags, + external_handle_type, + p_external_image_format_properties, + ) + } +} +pub struct NvExternalMemoryFn {} +unsafe impl Send for NvExternalMemoryFn {} +unsafe impl Sync for NvExternalMemoryFn {} +impl ::std::clone::Clone for NvExternalMemoryFn { + fn clone(&self) -> Self { + NvExternalMemoryFn {} + } +} +impl NvExternalMemoryFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_external_memory\'"] +impl StructureType { + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = StructureType(1000056000); +} +#[doc = "Generated from \'VK_NV_external_memory\'"] +impl StructureType { + pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = StructureType(1000056001); +} +pub struct NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: extern "system" fn( + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *mut HANDLE, + ) -> Result, +} +unsafe impl Send for NvExternalMemoryWin32Fn {} +unsafe impl Sync for NvExternalMemoryWin32Fn {} +impl ::std::clone::Clone for NvExternalMemoryWin32Fn { + fn clone(&self) -> Self { + NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: self.get_memory_win32_handle_nv, + } + } +} +impl NvExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExternalMemoryWin32Fn { + get_memory_win32_handle_nv: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandleNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_win32_handle_nv( + &self, + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *mut HANDLE, + ) -> Result { + (self.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle) + } +} +#[doc = "Generated from \'VK_NV_external_memory_win32\'"] +impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = StructureType(1000057000); +} +#[doc = "Generated from \'VK_NV_external_memory_win32\'"] +impl StructureType { + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = StructureType(1000057001); +} +pub struct NvWin32KeyedMutexFn {} +unsafe impl Send for NvWin32KeyedMutexFn {} +unsafe impl Sync for NvWin32KeyedMutexFn {} +impl ::std::clone::Clone for NvWin32KeyedMutexFn { + fn clone(&self) -> Self { + NvWin32KeyedMutexFn {} + } +} +impl NvWin32KeyedMutexFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvWin32KeyedMutexFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_win32_keyed_mutex\'"] +impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = StructureType(1000058000); +} +pub struct KhrGetPhysicalDeviceProperties2Fn {} +unsafe impl Send for KhrGetPhysicalDeviceProperties2Fn {} +unsafe impl Sync for KhrGetPhysicalDeviceProperties2Fn {} +impl ::std::clone::Clone for KhrGetPhysicalDeviceProperties2Fn { + fn clone(&self) -> Self { + KhrGetPhysicalDeviceProperties2Fn {} + } +} +impl KhrGetPhysicalDeviceProperties2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetPhysicalDeviceProperties2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } +unsafe impl Send for KhrDeviceGroupFn {} +unsafe impl Sync for KhrDeviceGroupFn {} +impl ::std::clone::Clone for KhrDeviceGroupFn { + fn clone(&self) -> Self { + KhrDeviceGroupFn { + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, + acquire_next_image2_khr: self.acquire_next_image2_khr, + } + } +} +impl KhrDeviceGroupFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDeviceGroupFn { + get_device_group_present_capabilities_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_device_group_surface_present_modes_khr: unsafe { + let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_present_rectangles_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + acquire_next_image2_khr: unsafe { + let raw_name = stringify!(vkAcquireNextImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_device_group_present_capabilities_khr( + &self, + device: Device, + p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + (self.get_device_group_present_capabilities_khr)( + device, + p_device_group_present_capabilities, + ) + } + pub unsafe fn get_device_group_surface_present_modes_khr( + &self, + device: Device, + surface: SurfaceKHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes) + } + pub unsafe fn get_physical_device_present_rectangles_khr( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *mut u32, + p_rects: *mut Rect2D, + ) -> Result { + (self.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + p_rect_count, + p_rects, + ) + } + pub unsafe fn acquire_next_image2_khr( + &self, + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *mut u32, + ) -> Result { + (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index) + } +} +pub struct ExtValidationFlagsFn {} +unsafe impl Send for ExtValidationFlagsFn {} +unsafe impl Sync for ExtValidationFlagsFn {} +impl ::std::clone::Clone for ExtValidationFlagsFn { + fn clone(&self) -> Self { + ExtValidationFlagsFn {} + } +} +impl ExtValidationFlagsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtValidationFlagsFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_EXT_validation_flags\'"] +impl StructureType { + pub const VALIDATION_FLAGS_EXT: Self = StructureType(1000061000); +} +pub struct NnViSurfaceFn { + create_vi_surface_nn: extern "system" fn( + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, +} +unsafe impl Send for NnViSurfaceFn {} +unsafe impl Sync for NnViSurfaceFn {} +impl ::std::clone::Clone for NnViSurfaceFn { + fn clone(&self) -> Self { + NnViSurfaceFn { + create_vi_surface_nn: self.create_vi_surface_nn, + } + } +} +impl NnViSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NnViSurfaceFn { + create_vi_surface_nn: unsafe { + let raw_name = stringify!(vkCreateViSurfaceNN); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn create_vi_surface_nn( + &self, + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_vi_surface_nn)(instance, p_create_info, p_allocator, p_surface) + } +} +#[doc = "Generated from \'VK_NN_vi_surface\'"] +impl StructureType { + pub const VI_SURFACE_CREATE_INFO_NN: Self = StructureType(1000062000); +} +pub struct KhrShaderDrawParametersFn {} +unsafe impl Send for KhrShaderDrawParametersFn {} +unsafe impl Sync for KhrShaderDrawParametersFn {} +impl ::std::clone::Clone for KhrShaderDrawParametersFn { + fn clone(&self) -> Self { + KhrShaderDrawParametersFn {} + } +} +impl KhrShaderDrawParametersFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrShaderDrawParametersFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtShaderSubgroupBallotFn {} +unsafe impl Send for ExtShaderSubgroupBallotFn {} +unsafe impl Sync for ExtShaderSubgroupBallotFn {} +impl ::std::clone::Clone for ExtShaderSubgroupBallotFn { + fn clone(&self) -> Self { + ExtShaderSubgroupBallotFn {} + } +} +impl ExtShaderSubgroupBallotFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderSubgroupBallotFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtShaderSubgroupVoteFn {} +unsafe impl Send for ExtShaderSubgroupVoteFn {} +unsafe impl Sync for ExtShaderSubgroupVoteFn {} +impl ::std::clone::Clone for ExtShaderSubgroupVoteFn { + fn clone(&self) -> Self { + ExtShaderSubgroupVoteFn {} + } +} +impl ExtShaderSubgroupVoteFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderSubgroupVoteFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ArmExtension01Fn {} +unsafe impl Send for ArmExtension01Fn {} +unsafe impl Sync for ArmExtension01Fn {} +impl ::std::clone::Clone for ArmExtension01Fn { + fn clone(&self) -> Self { + ArmExtension01Fn {} + } +} +impl ArmExtension01Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ArmExtension01Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ArmExtension02Fn {} +unsafe impl Send for ArmExtension02Fn {} +unsafe impl Sync for ArmExtension02Fn {} +impl ::std::clone::Clone for ArmExtension02Fn { + fn clone(&self) -> Self { + ArmExtension02Fn {} + } +} +impl ArmExtension02Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ArmExtension02Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ImgExtension69Fn {} +unsafe impl Send for ImgExtension69Fn {} +unsafe impl Sync for ImgExtension69Fn {} +impl ::std::clone::Clone for ImgExtension69Fn { + fn clone(&self) -> Self { + ImgExtension69Fn {} + } +} +impl ImgExtension69Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension69Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrMaintenance1Fn {} +unsafe impl Send for KhrMaintenance1Fn {} +unsafe impl Sync for KhrMaintenance1Fn {} +impl ::std::clone::Clone for KhrMaintenance1Fn { + fn clone(&self) -> Self { + KhrMaintenance1Fn {} + } +} +impl KhrMaintenance1Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMaintenance1Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrDeviceGroupCreationFn {} +unsafe impl Send for KhrDeviceGroupCreationFn {} +unsafe impl Sync for KhrDeviceGroupCreationFn {} +impl ::std::clone::Clone for KhrDeviceGroupCreationFn { + fn clone(&self) -> Self { + KhrDeviceGroupCreationFn {} + } +} +impl KhrDeviceGroupCreationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDeviceGroupCreationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExternalMemoryCapabilitiesFn {} +unsafe impl Send for KhrExternalMemoryCapabilitiesFn {} +unsafe impl Sync for KhrExternalMemoryCapabilitiesFn {} +impl ::std::clone::Clone for KhrExternalMemoryCapabilitiesFn { + fn clone(&self) -> Self { + KhrExternalMemoryCapabilitiesFn {} + } +} +impl KhrExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryCapabilitiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExternalMemoryFn {} +unsafe impl Send for KhrExternalMemoryFn {} +unsafe impl Sync for KhrExternalMemoryFn {} +impl ::std::clone::Clone for KhrExternalMemoryFn { + fn clone(&self) -> Self { + KhrExternalMemoryFn {} + } +} +impl KhrExternalMemoryFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: + extern "system" fn( device: Device, p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, p_handle: *mut HANDLE, - ) -> Result { - (self.get_memory_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) - } - pub unsafe fn get_memory_win32_handle_properties_khr( - &self, + ) -> Result, + get_memory_win32_handle_properties_khr: + extern "system" fn( device: Device, handle_type: ExternalMemoryHandleTypeFlags, handle: HANDLE, p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, - ) -> Result { - (self.get_memory_win32_handle_properties_khr)( - device, - handle_type, - handle, - p_memory_win32_handle_properties, - ) - } - } - #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] - impl StructureType { - pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073000); - } - #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] - impl StructureType { - pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073001); - } - #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] - impl StructureType { - pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = StructureType(1000073002); - } - #[doc = "Generated from \'VK_KHR_external_memory_win32\'"] - impl StructureType { - pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073003); - } - pub struct KhrExternalMemoryFdFn { - get_memory_fd_khr: extern "system" fn( - device: Device, - p_get_fd_info: *const MemoryGetFdInfoKHR, - p_fd: *mut c_int, ) -> Result, - get_memory_fd_properties_khr: - extern "system" fn( - device: Device, - handle_type: ExternalMemoryHandleTypeFlags, - fd: c_int, - p_memory_fd_properties: *mut MemoryFdPropertiesKHR, - ) -> Result, - } - unsafe impl Send for KhrExternalMemoryFdFn {} - unsafe impl Sync for KhrExternalMemoryFdFn {} - impl ::std::clone::Clone for KhrExternalMemoryFdFn { - fn clone(&self) -> Self { - KhrExternalMemoryFdFn { - get_memory_fd_khr: self.get_memory_fd_khr, - get_memory_fd_properties_khr: self.get_memory_fd_properties_khr, - } +} +unsafe impl Send for KhrExternalMemoryWin32Fn {} +unsafe impl Sync for KhrExternalMemoryWin32Fn {} +impl ::std::clone::Clone for KhrExternalMemoryWin32Fn { + fn clone(&self) -> Self { + KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: self.get_memory_win32_handle_khr, + get_memory_win32_handle_properties_khr: self.get_memory_win32_handle_properties_khr, } } - impl KhrExternalMemoryFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryFdFn { - get_memory_fd_khr: unsafe { - let raw_name = stringify!(vkGetMemoryFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_memory_fd_properties_khr: unsafe { - let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryWin32Fn { + get_memory_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_win32_handle_properties_khr: unsafe { + let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn get_memory_fd_khr( - &self, - device: Device, - p_get_fd_info: *const MemoryGetFdInfoKHR, - p_fd: *mut c_int, - ) -> Result { - (self.get_memory_fd_khr)(device, p_get_fd_info, p_fd) - } - pub unsafe fn get_memory_fd_properties_khr( - &self, + } + pub unsafe fn get_memory_win32_handle_khr( + &self, + device: Device, + p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, + ) -> Result { + (self.get_memory_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } + pub unsafe fn get_memory_win32_handle_properties_khr( + &self, + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + handle: HANDLE, + p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, + ) -> Result { + (self.get_memory_win32_handle_properties_khr)( + device, + handle_type, + handle, + p_memory_win32_handle_properties, + ) + } +} +#[doc = "Generated from \'VK_KHR_external_memory_win32\'"] +impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073000); +} +#[doc = "Generated from \'VK_KHR_external_memory_win32\'"] +impl StructureType { + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073001); +} +#[doc = "Generated from \'VK_KHR_external_memory_win32\'"] +impl StructureType { + pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = StructureType(1000073002); +} +#[doc = "Generated from \'VK_KHR_external_memory_win32\'"] +impl StructureType { + pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000073003); +} +pub struct KhrExternalMemoryFdFn { + get_memory_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *mut c_int, + ) -> Result, + get_memory_fd_properties_khr: + extern "system" fn( device: Device, handle_type: ExternalMemoryHandleTypeFlags, fd: c_int, p_memory_fd_properties: *mut MemoryFdPropertiesKHR, - ) -> Result { - (self.get_memory_fd_properties_khr)(device, handle_type, fd, p_memory_fd_properties) - } - } - #[doc = "Generated from \'VK_KHR_external_memory_fd\'"] - impl StructureType { - pub const IMPORT_MEMORY_FD_INFO_KHR: Self = StructureType(1000074000); - } - #[doc = "Generated from \'VK_KHR_external_memory_fd\'"] - impl StructureType { - pub const MEMORY_FD_PROPERTIES_KHR: Self = StructureType(1000074001); - } - #[doc = "Generated from \'VK_KHR_external_memory_fd\'"] - impl StructureType { - pub const MEMORY_GET_FD_INFO_KHR: Self = StructureType(1000074002); - } - pub struct KhrWin32KeyedMutexFn {} - unsafe impl Send for KhrWin32KeyedMutexFn {} - unsafe impl Sync for KhrWin32KeyedMutexFn {} - impl ::std::clone::Clone for KhrWin32KeyedMutexFn { - fn clone(&self) -> Self { - KhrWin32KeyedMutexFn {} - } - } - impl KhrWin32KeyedMutexFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrWin32KeyedMutexFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_KHR_win32_keyed_mutex\'"] - impl StructureType { - pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = StructureType(1000075000); - } - pub struct KhrExternalSemaphoreCapabilitiesFn {} - unsafe impl Send for KhrExternalSemaphoreCapabilitiesFn {} - unsafe impl Sync for KhrExternalSemaphoreCapabilitiesFn {} - impl ::std::clone::Clone for KhrExternalSemaphoreCapabilitiesFn { - fn clone(&self) -> Self { - KhrExternalSemaphoreCapabilitiesFn {} - } - } - impl KhrExternalSemaphoreCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExternalSemaphoreFn {} - unsafe impl Send for KhrExternalSemaphoreFn {} - unsafe impl Sync for KhrExternalSemaphoreFn {} - impl ::std::clone::Clone for KhrExternalSemaphoreFn { - fn clone(&self) -> Self { - KhrExternalSemaphoreFn {} - } - } - impl KhrExternalSemaphoreFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } - unsafe impl Send for KhrExternalSemaphoreWin32Fn {} - unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} - impl ::std::clone::Clone for KhrExternalSemaphoreWin32Fn { - fn clone(&self) -> Self { - KhrExternalSemaphoreWin32Fn { - import_semaphore_win32_handle_khr: self.import_semaphore_win32_handle_khr, - get_semaphore_win32_handle_khr: self.get_semaphore_win32_handle_khr, - } - } - } - impl KhrExternalSemaphoreWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreWin32Fn { - import_semaphore_win32_handle_khr: unsafe { - let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_semaphore_win32_handle_khr: unsafe { - let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn import_semaphore_win32_handle_khr( - &self, - device: Device, - p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, - ) -> Result { - (self.import_semaphore_win32_handle_khr)(device, p_import_semaphore_win32_handle_info) - } - pub unsafe fn get_semaphore_win32_handle_khr( - &self, - device: Device, - p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, - p_handle: *mut HANDLE, - ) -> Result { - (self.get_semaphore_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) - } - } - #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] - impl StructureType { - pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078000); - } - #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] - impl StructureType { - pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078001); - } - #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] - impl StructureType { - pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = StructureType(1000078002); - } - #[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] - impl StructureType { - pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078003); - } - pub struct KhrExternalSemaphoreFdFn { - import_semaphore_fd_khr: - extern "system" fn( - device: Device, - p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, - ) -> Result, - get_semaphore_fd_khr: extern "system" fn( - device: Device, - p_get_fd_info: *const SemaphoreGetFdInfoKHR, - p_fd: *mut c_int, ) -> Result, - } - unsafe impl Send for KhrExternalSemaphoreFdFn {} - unsafe impl Sync for KhrExternalSemaphoreFdFn {} - impl ::std::clone::Clone for KhrExternalSemaphoreFdFn { - fn clone(&self) -> Self { - KhrExternalSemaphoreFdFn { - import_semaphore_fd_khr: self.import_semaphore_fd_khr, - get_semaphore_fd_khr: self.get_semaphore_fd_khr, - } +} +unsafe impl Send for KhrExternalMemoryFdFn {} +unsafe impl Sync for KhrExternalMemoryFdFn {} +impl ::std::clone::Clone for KhrExternalMemoryFdFn { + fn clone(&self) -> Self { + KhrExternalMemoryFdFn { + get_memory_fd_khr: self.get_memory_fd_khr, + get_memory_fd_properties_khr: self.get_memory_fd_properties_khr, } } - impl KhrExternalSemaphoreFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreFdFn { - import_semaphore_fd_khr: unsafe { - let raw_name = stringify!(vkImportSemaphoreFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_semaphore_fd_khr: unsafe { - let raw_name = stringify!(vkGetSemaphoreFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrExternalMemoryFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalMemoryFdFn { + get_memory_fd_khr: unsafe { + let raw_name = stringify!(vkGetMemoryFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_fd_properties_khr: unsafe { + let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn import_semaphore_fd_khr( - &self, + } + pub unsafe fn get_memory_fd_khr( + &self, + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *mut c_int, + ) -> Result { + (self.get_memory_fd_khr)(device, p_get_fd_info, p_fd) + } + pub unsafe fn get_memory_fd_properties_khr( + &self, + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + fd: c_int, + p_memory_fd_properties: *mut MemoryFdPropertiesKHR, + ) -> Result { + (self.get_memory_fd_properties_khr)(device, handle_type, fd, p_memory_fd_properties) + } +} +#[doc = "Generated from \'VK_KHR_external_memory_fd\'"] +impl StructureType { + pub const IMPORT_MEMORY_FD_INFO_KHR: Self = StructureType(1000074000); +} +#[doc = "Generated from \'VK_KHR_external_memory_fd\'"] +impl StructureType { + pub const MEMORY_FD_PROPERTIES_KHR: Self = StructureType(1000074001); +} +#[doc = "Generated from \'VK_KHR_external_memory_fd\'"] +impl StructureType { + pub const MEMORY_GET_FD_INFO_KHR: Self = StructureType(1000074002); +} +pub struct KhrWin32KeyedMutexFn {} +unsafe impl Send for KhrWin32KeyedMutexFn {} +unsafe impl Sync for KhrWin32KeyedMutexFn {} +impl ::std::clone::Clone for KhrWin32KeyedMutexFn { + fn clone(&self) -> Self { + KhrWin32KeyedMutexFn {} + } +} +impl KhrWin32KeyedMutexFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrWin32KeyedMutexFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_KHR_win32_keyed_mutex\'"] +impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = StructureType(1000075000); +} +pub struct KhrExternalSemaphoreCapabilitiesFn {} +unsafe impl Send for KhrExternalSemaphoreCapabilitiesFn {} +unsafe impl Sync for KhrExternalSemaphoreCapabilitiesFn {} +impl ::std::clone::Clone for KhrExternalSemaphoreCapabilitiesFn { + fn clone(&self) -> Self { + KhrExternalSemaphoreCapabilitiesFn {} + } +} +impl KhrExternalSemaphoreCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreCapabilitiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExternalSemaphoreFn {} +unsafe impl Send for KhrExternalSemaphoreFn {} +unsafe impl Sync for KhrExternalSemaphoreFn {} +impl ::std::clone::Clone for KhrExternalSemaphoreFn { + fn clone(&self) -> Self { + KhrExternalSemaphoreFn {} + } +} +impl KhrExternalSemaphoreFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } +unsafe impl Send for KhrExternalSemaphoreWin32Fn {} +unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} +impl ::std::clone::Clone for KhrExternalSemaphoreWin32Fn { + fn clone(&self) -> Self { + KhrExternalSemaphoreWin32Fn { + import_semaphore_win32_handle_khr: self.import_semaphore_win32_handle_khr, + get_semaphore_win32_handle_khr: self.get_semaphore_win32_handle_khr, + } + } +} +impl KhrExternalSemaphoreWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreWin32Fn { + import_semaphore_win32_handle_khr: unsafe { + let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_semaphore_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_semaphore_win32_handle_khr( + &self, + device: Device, + p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, + ) -> Result { + (self.import_semaphore_win32_handle_khr)(device, p_import_semaphore_win32_handle_info) + } + pub unsafe fn get_semaphore_win32_handle_khr( + &self, + device: Device, + p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, + ) -> Result { + (self.get_semaphore_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) + } +} +#[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078000); +} +#[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] +impl StructureType { + pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078001); +} +#[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] +impl StructureType { + pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = StructureType(1000078002); +} +#[doc = "Generated from \'VK_KHR_external_semaphore_win32\'"] +impl StructureType { + pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000078003); +} +pub struct KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: + extern "system" fn( device: Device, p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, - ) -> Result { - (self.import_semaphore_fd_khr)(device, p_import_semaphore_fd_info) - } - pub unsafe fn get_semaphore_fd_khr( - &self, - device: Device, - p_get_fd_info: *const SemaphoreGetFdInfoKHR, - p_fd: *mut c_int, - ) -> Result { - (self.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd) - } - } - #[doc = "Generated from \'VK_KHR_external_semaphore_fd\'"] - impl StructureType { - pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = StructureType(1000079000); - } - #[doc = "Generated from \'VK_KHR_external_semaphore_fd\'"] - impl StructureType { - pub const SEMAPHORE_GET_FD_INFO_KHR: Self = StructureType(1000079001); - } - pub struct KhrPushDescriptorFn { - cmd_push_descriptor_set_khr: - extern "system" fn( - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - layout: PipelineLayout, - set: u32, - descriptor_write_count: u32, - p_descriptor_writes: *const WriteDescriptorSet, - ) -> c_void, - cmd_push_descriptor_set_with_template_khr: - extern "system" fn( - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: u32, - p_data: *const c_void, - ) -> c_void, - } - unsafe impl Send for KhrPushDescriptorFn {} - unsafe impl Sync for KhrPushDescriptorFn {} - impl ::std::clone::Clone for KhrPushDescriptorFn { - fn clone(&self) -> Self { - KhrPushDescriptorFn { - cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, - } - } - } - impl KhrPushDescriptorFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrPushDescriptorFn { - cmd_push_descriptor_set_khr: unsafe { - let raw_name = stringify!(vkCmdPushDescriptorSetKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_push_descriptor_set_with_template_khr: unsafe { - let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_push_descriptor_set_khr( - &self, - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - layout: PipelineLayout, - set: u32, - descriptor_write_count: u32, - p_descriptor_writes: *const WriteDescriptorSet, - ) -> c_void { - (self.cmd_push_descriptor_set_khr)( - command_buffer, - pipeline_bind_point, - layout, - set, - descriptor_write_count, - p_descriptor_writes, - ) - } - pub unsafe fn cmd_push_descriptor_set_with_template_khr( - &self, - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: u32, - p_data: *const c_void, - ) -> c_void { - (self.cmd_push_descriptor_set_with_template_khr)( - command_buffer, - descriptor_update_template, - layout, - set, - p_data, - ) - } - } - #[doc = "Generated from \'VK_KHR_push_descriptor\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = StructureType(1000080000); - } - #[doc = "Generated from \'VK_KHR_push_descriptor\'"] - impl DescriptorSetLayoutCreateFlags { - pub const PUSH_DESCRIPTOR_KHR: Self = DescriptorSetLayoutCreateFlags(0b1); - } - pub struct ExtExtension82Fn {} - unsafe impl Send for ExtExtension82Fn {} - unsafe impl Sync for ExtExtension82Fn {} - impl ::std::clone::Clone for ExtExtension82Fn { - fn clone(&self) -> Self { - ExtExtension82Fn {} - } - } - impl ExtExtension82Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension82Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExtension83Fn {} - unsafe impl Send for KhrExtension83Fn {} - unsafe impl Sync for KhrExtension83Fn {} - impl ::std::clone::Clone for KhrExtension83Fn { - fn clone(&self) -> Self { - KhrExtension83Fn {} - } - } - impl KhrExtension83Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension83Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct Khr16bitStorageFn {} - unsafe impl Send for Khr16bitStorageFn {} - unsafe impl Sync for Khr16bitStorageFn {} - impl ::std::clone::Clone for Khr16bitStorageFn { - fn clone(&self) -> Self { - Khr16bitStorageFn {} - } - } - impl Khr16bitStorageFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = Khr16bitStorageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrIncrementalPresentFn {} - unsafe impl Send for KhrIncrementalPresentFn {} - unsafe impl Sync for KhrIncrementalPresentFn {} - impl ::std::clone::Clone for KhrIncrementalPresentFn { - fn clone(&self) -> Self { - KhrIncrementalPresentFn {} - } - } - impl KhrIncrementalPresentFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrIncrementalPresentFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_KHR_incremental_present\'"] - impl StructureType { - pub const PRESENT_REGIONS_KHR: Self = StructureType(1000084000); - } - pub struct KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: - extern "system" fn( - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: u32, - p_data: *const c_void, - ) -> c_void, - } - unsafe impl Send for KhrDescriptorUpdateTemplateFn {} - unsafe impl Sync for KhrDescriptorUpdateTemplateFn {} - impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { - fn clone(&self) -> Self { - KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, - } - } - } - impl KhrDescriptorUpdateTemplateFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: unsafe { - let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_push_descriptor_set_with_template_khr( - &self, - command_buffer: CommandBuffer, - descriptor_update_template: DescriptorUpdateTemplate, - layout: PipelineLayout, - set: u32, - p_data: *const c_void, - ) -> c_void { - (self.cmd_push_descriptor_set_with_template_khr)( - command_buffer, - descriptor_update_template, - layout, - set, - p_data, - ) - } - } - pub struct NvxDeviceGeneratedCommandsFn { - cmd_process_commands_nvx: - extern "system" fn( - command_buffer: CommandBuffer, - p_process_commands_info: *const CmdProcessCommandsInfoNVX, - ) -> c_void, - cmd_reserve_space_for_commands_nvx: - extern "system" fn( - command_buffer: CommandBuffer, - p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, - ) -> c_void, - create_indirect_commands_layout_nvx: - extern "system" fn( - device: Device, - p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, - p_allocator: *const AllocationCallbacks, - p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, - ) -> Result, - destroy_indirect_commands_layout_nvx: - extern "system" fn( - device: Device, - indirect_commands_layout: IndirectCommandsLayoutNVX, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - create_object_table_nvx: extern "system" fn( - device: Device, - p_create_info: *const ObjectTableCreateInfoNVX, - p_allocator: *const AllocationCallbacks, - p_object_table: *mut ObjectTableNVX, ) -> Result, - destroy_object_table_nvx: extern "system" fn( - device: Device, - object_table: ObjectTableNVX, - p_allocator: *const AllocationCallbacks, + get_semaphore_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *mut c_int, + ) -> Result, +} +unsafe impl Send for KhrExternalSemaphoreFdFn {} +unsafe impl Sync for KhrExternalSemaphoreFdFn {} +impl ::std::clone::Clone for KhrExternalSemaphoreFdFn { + fn clone(&self) -> Self { + KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: self.import_semaphore_fd_khr, + get_semaphore_fd_khr: self.get_semaphore_fd_khr, + } + } +} +impl KhrExternalSemaphoreFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalSemaphoreFdFn { + import_semaphore_fd_khr: unsafe { + let raw_name = stringify!(vkImportSemaphoreFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_semaphore_fd_khr: unsafe { + let raw_name = stringify!(vkGetSemaphoreFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn import_semaphore_fd_khr( + &self, + device: Device, + p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result { + (self.import_semaphore_fd_khr)(device, p_import_semaphore_fd_info) + } + pub unsafe fn get_semaphore_fd_khr( + &self, + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *mut c_int, + ) -> Result { + (self.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd) + } +} +#[doc = "Generated from \'VK_KHR_external_semaphore_fd\'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = StructureType(1000079000); +} +#[doc = "Generated from \'VK_KHR_external_semaphore_fd\'"] +impl StructureType { + pub const SEMAPHORE_GET_FD_INFO_KHR: Self = StructureType(1000079001); +} +pub struct KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, + descriptor_write_count: u32, + p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void, + cmd_push_descriptor_set_with_template_khr: + extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: u32, + p_data: *const c_void, ) -> c_void, - register_objects_nvx: - extern "system" fn( - device: Device, - object_table: ObjectTableNVX, - object_count: u32, - pp_object_table_entries: *const *const ObjectTableEntryNVX, - p_object_indices: *const u32, - ) -> Result, - unregister_objects_nvx: extern "system" fn( - device: Device, - object_table: ObjectTableNVX, - object_count: u32, - p_object_entry_types: *const ObjectEntryTypeNVX, - p_object_indices: *const u32, - ) -> Result, - get_physical_device_generated_commands_properties_nvx: - extern "system" fn( - physical_device: PhysicalDevice, - p_features: *mut DeviceGeneratedCommandsFeaturesNVX, - p_limits: *mut DeviceGeneratedCommandsLimitsNVX, - ) -> c_void, - } - unsafe impl Send for NvxDeviceGeneratedCommandsFn {} - unsafe impl Sync for NvxDeviceGeneratedCommandsFn {} - impl ::std::clone::Clone for NvxDeviceGeneratedCommandsFn { - fn clone(&self) -> Self { - NvxDeviceGeneratedCommandsFn { - cmd_process_commands_nvx: self.cmd_process_commands_nvx, - cmd_reserve_space_for_commands_nvx: self.cmd_reserve_space_for_commands_nvx, - create_indirect_commands_layout_nvx: self.create_indirect_commands_layout_nvx, - destroy_indirect_commands_layout_nvx: self.destroy_indirect_commands_layout_nvx, - create_object_table_nvx: self.create_object_table_nvx, - destroy_object_table_nvx: self.destroy_object_table_nvx, - register_objects_nvx: self.register_objects_nvx, - unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: - self.get_physical_device_generated_commands_properties_nvx, - } +} +unsafe impl Send for KhrPushDescriptorFn {} +unsafe impl Sync for KhrPushDescriptorFn {} +impl ::std::clone::Clone for KhrPushDescriptorFn { + fn clone(&self) -> Self { + KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } - impl NvxDeviceGeneratedCommandsFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxDeviceGeneratedCommandsFn { - cmd_process_commands_nvx: unsafe { - let raw_name = stringify!(vkCmdProcessCommandsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_reserve_space_for_commands_nvx: unsafe { - let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_indirect_commands_layout_nvx: unsafe { - let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_indirect_commands_layout_nvx: unsafe { - let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_object_table_nvx: unsafe { - let raw_name = stringify!(vkCreateObjectTableNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_object_table_nvx: unsafe { - let raw_name = stringify!(vkDestroyObjectTableNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - register_objects_nvx: unsafe { - let raw_name = stringify!(vkRegisterObjectsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - unregister_objects_nvx: unsafe { - let raw_name = stringify!(vkUnregisterObjectsNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_generated_commands_properties_nvx: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrPushDescriptorFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrPushDescriptorFn { + cmd_push_descriptor_set_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_push_descriptor_set_with_template_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn cmd_process_commands_nvx( - &self, + } + pub unsafe fn cmd_push_descriptor_set_khr( + &self, + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, + descriptor_write_count: u32, + p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void { + (self.cmd_push_descriptor_set_khr)( + command_buffer, + pipeline_bind_point, + layout, + set, + descriptor_write_count, + p_descriptor_writes, + ) + } + pub unsafe fn cmd_push_descriptor_set_with_template_khr( + &self, + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: u32, + p_data: *const c_void, + ) -> c_void { + (self.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ) + } +} +#[doc = "Generated from \'VK_KHR_push_descriptor\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = StructureType(1000080000); +} +#[doc = "Generated from \'VK_KHR_push_descriptor\'"] +impl DescriptorSetLayoutCreateFlags { + pub const PUSH_DESCRIPTOR_KHR: Self = DescriptorSetLayoutCreateFlags(0b1); +} +pub struct ExtExtension82Fn {} +unsafe impl Send for ExtExtension82Fn {} +unsafe impl Sync for ExtExtension82Fn {} +impl ::std::clone::Clone for ExtExtension82Fn { + fn clone(&self) -> Self { + ExtExtension82Fn {} + } +} +impl ExtExtension82Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension82Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExtension83Fn {} +unsafe impl Send for KhrExtension83Fn {} +unsafe impl Sync for KhrExtension83Fn {} +impl ::std::clone::Clone for KhrExtension83Fn { + fn clone(&self) -> Self { + KhrExtension83Fn {} + } +} +impl KhrExtension83Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension83Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct Khr16bitStorageFn {} +unsafe impl Send for Khr16bitStorageFn {} +unsafe impl Sync for Khr16bitStorageFn {} +impl ::std::clone::Clone for Khr16bitStorageFn { + fn clone(&self) -> Self { + Khr16bitStorageFn {} + } +} +impl Khr16bitStorageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = Khr16bitStorageFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrIncrementalPresentFn {} +unsafe impl Send for KhrIncrementalPresentFn {} +unsafe impl Sync for KhrIncrementalPresentFn {} +impl ::std::clone::Clone for KhrIncrementalPresentFn { + fn clone(&self) -> Self { + KhrIncrementalPresentFn {} + } +} +impl KhrIncrementalPresentFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrIncrementalPresentFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_KHR_incremental_present\'"] +impl StructureType { + pub const PRESENT_REGIONS_KHR: Self = StructureType(1000084000); +} +pub struct KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: + extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: u32, + p_data: *const c_void, + ) -> c_void, +} +unsafe impl Send for KhrDescriptorUpdateTemplateFn {} +unsafe impl Sync for KhrDescriptorUpdateTemplateFn {} +impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { + fn clone(&self) -> Self { + KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, + } + } +} +impl KhrDescriptorUpdateTemplateFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDescriptorUpdateTemplateFn { + cmd_push_descriptor_set_with_template_khr: unsafe { + let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_push_descriptor_set_with_template_khr( + &self, + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: u32, + p_data: *const c_void, + ) -> c_void { + (self.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ) + } +} +pub struct NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: + extern "system" fn( command_buffer: CommandBuffer, p_process_commands_info: *const CmdProcessCommandsInfoNVX, - ) -> c_void { - (self.cmd_process_commands_nvx)(command_buffer, p_process_commands_info) - } - pub unsafe fn cmd_reserve_space_for_commands_nvx( - &self, + ) -> c_void, + cmd_reserve_space_for_commands_nvx: + extern "system" fn( command_buffer: CommandBuffer, p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, - ) -> c_void { - (self.cmd_reserve_space_for_commands_nvx)(command_buffer, p_reserve_space_info) - } - pub unsafe fn create_indirect_commands_layout_nvx( - &self, + ) -> c_void, + create_indirect_commands_layout_nvx: + extern "system" fn( device: Device, p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, p_allocator: *const AllocationCallbacks, p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, - ) -> Result { - (self.create_indirect_commands_layout_nvx)( - device, - p_create_info, - p_allocator, - p_indirect_commands_layout, - ) - } - pub unsafe fn destroy_indirect_commands_layout_nvx( - &self, + ) -> Result, + destroy_indirect_commands_layout_nvx: + extern "system" fn( device: Device, indirect_commands_layout: IndirectCommandsLayoutNVX, p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_indirect_commands_layout_nvx)( - device, - indirect_commands_layout, - p_allocator, - ) - } - pub unsafe fn create_object_table_nvx( - &self, - device: Device, - p_create_info: *const ObjectTableCreateInfoNVX, - p_allocator: *const AllocationCallbacks, - p_object_table: *mut ObjectTableNVX, - ) -> Result { - (self.create_object_table_nvx)(device, p_create_info, p_allocator, p_object_table) - } - pub unsafe fn destroy_object_table_nvx( - &self, - device: Device, - object_table: ObjectTableNVX, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_object_table_nvx)(device, object_table, p_allocator) - } - pub unsafe fn register_objects_nvx( - &self, + ) -> c_void, + create_object_table_nvx: extern "system" fn( + device: Device, + p_create_info: *const ObjectTableCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_object_table: *mut ObjectTableNVX, + ) -> Result, + destroy_object_table_nvx: extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + register_objects_nvx: + extern "system" fn( device: Device, object_table: ObjectTableNVX, object_count: u32, pp_object_table_entries: *const *const ObjectTableEntryNVX, p_object_indices: *const u32, - ) -> Result { - (self.register_objects_nvx)( - device, - object_table, - object_count, - pp_object_table_entries, - p_object_indices, - ) - } - pub unsafe fn unregister_objects_nvx( - &self, - device: Device, - object_table: ObjectTableNVX, - object_count: u32, - p_object_entry_types: *const ObjectEntryTypeNVX, - p_object_indices: *const u32, - ) -> Result { - (self.unregister_objects_nvx)( - device, - object_table, - object_count, - p_object_entry_types, - p_object_indices, - ) - } - pub unsafe fn get_physical_device_generated_commands_properties_nvx( - &self, + ) -> Result, + unregister_objects_nvx: extern "system" fn( + device: Device, + object_table: ObjectTableNVX, + object_count: u32, + p_object_entry_types: *const ObjectEntryTypeNVX, + p_object_indices: *const u32, + ) -> Result, + get_physical_device_generated_commands_properties_nvx: + extern "system" fn( physical_device: PhysicalDevice, p_features: *mut DeviceGeneratedCommandsFeaturesNVX, p_limits: *mut DeviceGeneratedCommandsLimitsNVX, - ) -> c_void { - (self.get_physical_device_generated_commands_properties_nvx)( - physical_device, - p_features, - p_limits, - ) + ) -> c_void, +} +unsafe impl Send for NvxDeviceGeneratedCommandsFn {} +unsafe impl Sync for NvxDeviceGeneratedCommandsFn {} +impl ::std::clone::Clone for NvxDeviceGeneratedCommandsFn { + fn clone(&self) -> Self { + NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: self.cmd_process_commands_nvx, + cmd_reserve_space_for_commands_nvx: self.cmd_reserve_space_for_commands_nvx, + create_indirect_commands_layout_nvx: self.create_indirect_commands_layout_nvx, + destroy_indirect_commands_layout_nvx: self.destroy_indirect_commands_layout_nvx, + create_object_table_nvx: self.create_object_table_nvx, + destroy_object_table_nvx: self.destroy_object_table_nvx, + register_objects_nvx: self.register_objects_nvx, + unregister_objects_nvx: self.unregister_objects_nvx, + get_physical_device_generated_commands_properties_nvx: + self.get_physical_device_generated_commands_properties_nvx, } } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl StructureType { - pub const OBJECT_TABLE_CREATE_INFO_NVX: Self = StructureType(1000086000); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl StructureType { - pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: Self = StructureType(1000086001); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl StructureType { - pub const CMD_PROCESS_COMMANDS_INFO_NVX: Self = StructureType(1000086002); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl StructureType { - pub const CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX: Self = StructureType(1000086003); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl StructureType { - pub const DEVICE_GENERATED_COMMANDS_LIMITS_NVX: Self = StructureType(1000086004); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl StructureType { - pub const DEVICE_GENERATED_COMMANDS_FEATURES_NVX: Self = StructureType(1000086005); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl PipelineStageFlags { - pub const COMMAND_PROCESS_NVX: Self = PipelineStageFlags(0b100000000000000000); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl AccessFlags { - pub const COMMAND_PROCESS_READ_NVX: Self = AccessFlags(0b100000000000000000); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl AccessFlags { - pub const COMMAND_PROCESS_WRITE_NVX: Self = AccessFlags(0b1000000000000000000); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl ObjectType { - pub const OBJECT_TABLE_NVX: Self = ObjectType(1000086000); - } - #[doc = "Generated from \'VK_NVX_device_generated_commands\'"] - impl ObjectType { - pub const INDIRECT_COMMANDS_LAYOUT_NVX: Self = ObjectType(1000086001); - } - pub struct NvClipSpaceWScalingFn { - cmd_set_viewport_w_scaling_nv: - extern "system" fn( - command_buffer: CommandBuffer, - first_viewport: u32, - viewport_count: u32, - p_viewport_w_scalings: *const ViewportWScalingNV, - ) -> c_void, - } - unsafe impl Send for NvClipSpaceWScalingFn {} - unsafe impl Sync for NvClipSpaceWScalingFn {} - impl ::std::clone::Clone for NvClipSpaceWScalingFn { - fn clone(&self) -> Self { - NvClipSpaceWScalingFn { - cmd_set_viewport_w_scaling_nv: self.cmd_set_viewport_w_scaling_nv, - } +} +impl NvxDeviceGeneratedCommandsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxDeviceGeneratedCommandsFn { + cmd_process_commands_nvx: unsafe { + let raw_name = stringify!(vkCmdProcessCommandsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_reserve_space_for_commands_nvx: unsafe { + let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_indirect_commands_layout_nvx: unsafe { + let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_indirect_commands_layout_nvx: unsafe { + let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_object_table_nvx: unsafe { + let raw_name = stringify!(vkCreateObjectTableNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_object_table_nvx: unsafe { + let raw_name = stringify!(vkDestroyObjectTableNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_objects_nvx: unsafe { + let raw_name = stringify!(vkRegisterObjectsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + unregister_objects_nvx: unsafe { + let raw_name = stringify!(vkUnregisterObjectsNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_generated_commands_properties_nvx: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvClipSpaceWScalingFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvClipSpaceWScalingFn { - cmd_set_viewport_w_scaling_nv: unsafe { - let raw_name = stringify!(vkCmdSetViewportWScalingNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_set_viewport_w_scaling_nv( - &self, + pub unsafe fn cmd_process_commands_nvx( + &self, + command_buffer: CommandBuffer, + p_process_commands_info: *const CmdProcessCommandsInfoNVX, + ) -> c_void { + (self.cmd_process_commands_nvx)(command_buffer, p_process_commands_info) + } + pub unsafe fn cmd_reserve_space_for_commands_nvx( + &self, + command_buffer: CommandBuffer, + p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, + ) -> c_void { + (self.cmd_reserve_space_for_commands_nvx)(command_buffer, p_reserve_space_info) + } + pub unsafe fn create_indirect_commands_layout_nvx( + &self, + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, + ) -> Result { + (self.create_indirect_commands_layout_nvx)( + device, + p_create_info, + p_allocator, + p_indirect_commands_layout, + ) + } + pub unsafe fn destroy_indirect_commands_layout_nvx( + &self, + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_indirect_commands_layout_nvx)(device, indirect_commands_layout, p_allocator) + } + pub unsafe fn create_object_table_nvx( + &self, + device: Device, + p_create_info: *const ObjectTableCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_object_table: *mut ObjectTableNVX, + ) -> Result { + (self.create_object_table_nvx)(device, p_create_info, p_allocator, p_object_table) + } + pub unsafe fn destroy_object_table_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_object_table_nvx)(device, object_table, p_allocator) + } + pub unsafe fn register_objects_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + object_count: u32, + pp_object_table_entries: *const *const ObjectTableEntryNVX, + p_object_indices: *const u32, + ) -> Result { + (self.register_objects_nvx)( + device, + object_table, + object_count, + pp_object_table_entries, + p_object_indices, + ) + } + pub unsafe fn unregister_objects_nvx( + &self, + device: Device, + object_table: ObjectTableNVX, + object_count: u32, + p_object_entry_types: *const ObjectEntryTypeNVX, + p_object_indices: *const u32, + ) -> Result { + (self.unregister_objects_nvx)( + device, + object_table, + object_count, + p_object_entry_types, + p_object_indices, + ) + } + pub unsafe fn get_physical_device_generated_commands_properties_nvx( + &self, + physical_device: PhysicalDevice, + p_features: *mut DeviceGeneratedCommandsFeaturesNVX, + p_limits: *mut DeviceGeneratedCommandsLimitsNVX, + ) -> c_void { + (self.get_physical_device_generated_commands_properties_nvx)( + physical_device, + p_features, + p_limits, + ) + } +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl StructureType { + pub const OBJECT_TABLE_CREATE_INFO_NVX: Self = StructureType(1000086000); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl StructureType { + pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: Self = StructureType(1000086001); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl StructureType { + pub const CMD_PROCESS_COMMANDS_INFO_NVX: Self = StructureType(1000086002); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl StructureType { + pub const CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX: Self = StructureType(1000086003); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl StructureType { + pub const DEVICE_GENERATED_COMMANDS_LIMITS_NVX: Self = StructureType(1000086004); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl StructureType { + pub const DEVICE_GENERATED_COMMANDS_FEATURES_NVX: Self = StructureType(1000086005); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl PipelineStageFlags { + pub const COMMAND_PROCESS_NVX: Self = PipelineStageFlags(0b100000000000000000); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl AccessFlags { + pub const COMMAND_PROCESS_READ_NVX: Self = AccessFlags(0b100000000000000000); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl AccessFlags { + pub const COMMAND_PROCESS_WRITE_NVX: Self = AccessFlags(0b1000000000000000000); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl ObjectType { + pub const OBJECT_TABLE_NVX: Self = ObjectType(1000086000); +} +#[doc = "Generated from \'VK_NVX_device_generated_commands\'"] +impl ObjectType { + pub const INDIRECT_COMMANDS_LAYOUT_NVX: Self = ObjectType(1000086001); +} +pub struct NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: + extern "system" fn( command_buffer: CommandBuffer, first_viewport: u32, viewport_count: u32, p_viewport_w_scalings: *const ViewportWScalingNV, - ) -> c_void { - (self.cmd_set_viewport_w_scaling_nv)( - command_buffer, - first_viewport, - viewport_count, - p_viewport_w_scalings, - ) + ) -> c_void, +} +unsafe impl Send for NvClipSpaceWScalingFn {} +unsafe impl Sync for NvClipSpaceWScalingFn {} +impl ::std::clone::Clone for NvClipSpaceWScalingFn { + fn clone(&self) -> Self { + NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: self.cmd_set_viewport_w_scaling_nv, } } - #[doc = "Generated from \'VK_NV_clip_space_w_scaling\'"] - impl StructureType { - pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = - StructureType(1000087000); - } - #[doc = "Generated from \'VK_NV_clip_space_w_scaling\'"] - impl DynamicState { - pub const VIEWPORT_W_SCALING_NV: Self = DynamicState(1000087000); - } - pub struct ExtDirectModeDisplayFn { - release_display_ext: - extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result, - } - unsafe impl Send for ExtDirectModeDisplayFn {} - unsafe impl Sync for ExtDirectModeDisplayFn {} - impl ::std::clone::Clone for ExtDirectModeDisplayFn { - fn clone(&self) -> Self { - ExtDirectModeDisplayFn { - release_display_ext: self.release_display_ext, - } +} +impl NvClipSpaceWScalingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvClipSpaceWScalingFn { + cmd_set_viewport_w_scaling_nv: unsafe { + let raw_name = stringify!(vkCmdSetViewportWScalingNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtDirectModeDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDirectModeDisplayFn { - release_display_ext: unsafe { - let raw_name = stringify!(vkReleaseDisplayEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn release_display_ext( - &self, - physical_device: PhysicalDevice, - display: DisplayKHR, - ) -> Result { - (self.release_display_ext)(physical_device, display) + pub unsafe fn cmd_set_viewport_w_scaling_nv( + &self, + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewport_w_scalings: *const ViewportWScalingNV, + ) -> c_void { + (self.cmd_set_viewport_w_scaling_nv)( + command_buffer, + first_viewport, + viewport_count, + p_viewport_w_scalings, + ) + } +} +#[doc = "Generated from \'VK_NV_clip_space_w_scaling\'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = StructureType(1000087000); +} +#[doc = "Generated from \'VK_NV_clip_space_w_scaling\'"] +impl DynamicState { + pub const VIEWPORT_W_SCALING_NV: Self = DynamicState(1000087000); +} +pub struct ExtDirectModeDisplayFn { + release_display_ext: + extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result, +} +unsafe impl Send for ExtDirectModeDisplayFn {} +unsafe impl Sync for ExtDirectModeDisplayFn {} +impl ::std::clone::Clone for ExtDirectModeDisplayFn { + fn clone(&self) -> Self { + ExtDirectModeDisplayFn { + release_display_ext: self.release_display_ext, } } - pub struct ExtAcquireXlibDisplayFn { - acquire_xlib_display_ext: extern "system" fn( - physical_device: PhysicalDevice, - dpy: *mut Display, - display: DisplayKHR, - ) -> Result, - get_rand_r_output_display_ext: extern "system" fn( - physical_device: PhysicalDevice, - dpy: *mut Display, - rr_output: RROutput, - p_display: *mut DisplayKHR, - ) -> Result, - } - unsafe impl Send for ExtAcquireXlibDisplayFn {} - unsafe impl Sync for ExtAcquireXlibDisplayFn {} - impl ::std::clone::Clone for ExtAcquireXlibDisplayFn { - fn clone(&self) -> Self { - ExtAcquireXlibDisplayFn { - acquire_xlib_display_ext: self.acquire_xlib_display_ext, - get_rand_r_output_display_ext: self.get_rand_r_output_display_ext, - } +} +impl ExtDirectModeDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDirectModeDisplayFn { + release_display_ext: unsafe { + let raw_name = stringify!(vkReleaseDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtAcquireXlibDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtAcquireXlibDisplayFn { - acquire_xlib_display_ext: unsafe { - let raw_name = stringify!(vkAcquireXlibDisplayEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_rand_r_output_display_ext: unsafe { - let raw_name = stringify!(vkGetRandROutputDisplayEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn acquire_xlib_display_ext( - &self, - physical_device: PhysicalDevice, - dpy: *mut Display, - display: DisplayKHR, - ) -> Result { - (self.acquire_xlib_display_ext)(physical_device, dpy, display) - } - pub unsafe fn get_rand_r_output_display_ext( - &self, - physical_device: PhysicalDevice, - dpy: *mut Display, - rr_output: RROutput, - p_display: *mut DisplayKHR, - ) -> Result { - (self.get_rand_r_output_display_ext)(physical_device, dpy, rr_output, p_display) + pub unsafe fn release_display_ext( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + ) -> Result { + (self.release_display_ext)(physical_device, display) + } +} +pub struct ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: + extern "system" fn(physical_device: PhysicalDevice, dpy: *mut Display, display: DisplayKHR) + -> Result, + get_rand_r_output_display_ext: extern "system" fn( + physical_device: PhysicalDevice, + dpy: *mut Display, + rr_output: RROutput, + p_display: *mut DisplayKHR, + ) -> Result, +} +unsafe impl Send for ExtAcquireXlibDisplayFn {} +unsafe impl Sync for ExtAcquireXlibDisplayFn {} +impl ::std::clone::Clone for ExtAcquireXlibDisplayFn { + fn clone(&self) -> Self { + ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: self.acquire_xlib_display_ext, + get_rand_r_output_display_ext: self.get_rand_r_output_display_ext, } } - pub struct ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: - extern "system" fn( - physical_device: PhysicalDevice, - surface: SurfaceKHR, - p_surface_capabilities: *mut SurfaceCapabilities2EXT, - ) -> Result, - } - unsafe impl Send for ExtDisplaySurfaceCounterFn {} - unsafe impl Sync for ExtDisplaySurfaceCounterFn {} - impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { - fn clone(&self) -> Self { - ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: - self.get_physical_device_surface_capabilities2_ext, - } +} +impl ExtAcquireXlibDisplayFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtAcquireXlibDisplayFn { + acquire_xlib_display_ext: unsafe { + let raw_name = stringify!(vkAcquireXlibDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_rand_r_output_display_ext: unsafe { + let raw_name = stringify!(vkGetRandROutputDisplayEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtDisplaySurfaceCounterFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_physical_device_surface_capabilities2_ext( - &self, + pub unsafe fn acquire_xlib_display_ext( + &self, + physical_device: PhysicalDevice, + dpy: *mut Display, + display: DisplayKHR, + ) -> Result { + (self.acquire_xlib_display_ext)(physical_device, dpy, display) + } + pub unsafe fn get_rand_r_output_display_ext( + &self, + physical_device: PhysicalDevice, + dpy: *mut Display, + rr_output: RROutput, + p_display: *mut DisplayKHR, + ) -> Result { + (self.get_rand_r_output_display_ext)(physical_device, dpy, rr_output, p_display) + } +} +pub struct ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: + extern "system" fn( physical_device: PhysicalDevice, surface: SurfaceKHR, p_surface_capabilities: *mut SurfaceCapabilities2EXT, - ) -> Result { - (self.get_physical_device_surface_capabilities2_ext)( - physical_device, - surface, - p_surface_capabilities, - ) - } - } - #[doc = "Generated from \'VK_EXT_display_surface_counter\'"] - impl StructureType { - pub const SURFACE_CAPABILITIES_2_EXT: Self = StructureType(1000090000); - } - pub struct ExtDisplayControlFn { - display_power_control_ext: - extern "system" fn( - device: Device, - display: DisplayKHR, - p_display_power_info: *const DisplayPowerInfoEXT, - ) -> Result, - register_device_event_ext: - extern "system" fn( - device: Device, - p_device_event_info: *const DeviceEventInfoEXT, - p_allocator: *const AllocationCallbacks, - p_fence: *mut Fence, - ) -> Result, - register_display_event_ext: - extern "system" fn( - device: Device, - display: DisplayKHR, - p_display_event_info: *const DisplayEventInfoEXT, - p_allocator: *const AllocationCallbacks, - p_fence: *mut Fence, - ) -> Result, - get_swapchain_counter_ext: extern "system" fn( - device: Device, - swapchain: SwapchainKHR, - counter: SurfaceCounterFlagsEXT, - p_counter_value: *mut u64, ) -> Result, - } - unsafe impl Send for ExtDisplayControlFn {} - unsafe impl Sync for ExtDisplayControlFn {} - impl ::std::clone::Clone for ExtDisplayControlFn { - fn clone(&self) -> Self { - ExtDisplayControlFn { - display_power_control_ext: self.display_power_control_ext, - register_device_event_ext: self.register_device_event_ext, - register_display_event_ext: self.register_display_event_ext, - get_swapchain_counter_ext: self.get_swapchain_counter_ext, - } +} +unsafe impl Send for ExtDisplaySurfaceCounterFn {} +unsafe impl Sync for ExtDisplaySurfaceCounterFn {} +impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { + fn clone(&self) -> Self { + ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: + self.get_physical_device_surface_capabilities2_ext, } } - impl ExtDisplayControlFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDisplayControlFn { - display_power_control_ext: unsafe { - let raw_name = stringify!(vkDisplayPowerControlEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - register_device_event_ext: unsafe { - let raw_name = stringify!(vkRegisterDeviceEventEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - register_display_event_ext: unsafe { - let raw_name = stringify!(vkRegisterDisplayEventEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_swapchain_counter_ext: unsafe { - let raw_name = stringify!(vkGetSwapchainCounterEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl ExtDisplaySurfaceCounterFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDisplaySurfaceCounterFn { + get_physical_device_surface_capabilities2_ext: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn display_power_control_ext( - &self, - device: Device, - display: DisplayKHR, - p_display_power_info: *const DisplayPowerInfoEXT, - ) -> Result { - (self.display_power_control_ext)(device, display, p_display_power_info) - } - pub unsafe fn register_device_event_ext( - &self, - device: Device, - p_device_event_info: *const DeviceEventInfoEXT, - p_allocator: *const AllocationCallbacks, - p_fence: *mut Fence, - ) -> Result { - (self.register_device_event_ext)(device, p_device_event_info, p_allocator, p_fence) - } - pub unsafe fn register_display_event_ext( - &self, + } + pub unsafe fn get_physical_device_surface_capabilities2_ext( + &self, + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *mut SurfaceCapabilities2EXT, + ) -> Result { + (self.get_physical_device_surface_capabilities2_ext)( + physical_device, + surface, + p_surface_capabilities, + ) + } +} +#[doc = "Generated from \'VK_EXT_display_surface_counter\'"] +impl StructureType { + pub const SURFACE_CAPABILITIES_2_EXT: Self = StructureType(1000090000); +} +pub struct ExtDisplayControlFn { + display_power_control_ext: extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result, + register_device_event_ext: extern "system" fn( + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, + ) -> Result, + register_display_event_ext: + extern "system" fn( device: Device, display: DisplayKHR, p_display_event_info: *const DisplayEventInfoEXT, p_allocator: *const AllocationCallbacks, p_fence: *mut Fence, - ) -> Result { - (self.register_display_event_ext)( - device, - display, - p_display_event_info, - p_allocator, - p_fence, - ) - } - pub unsafe fn get_swapchain_counter_ext( - &self, - device: Device, - swapchain: SwapchainKHR, - counter: SurfaceCounterFlagsEXT, - p_counter_value: *mut u64, - ) -> Result { - (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value) + ) -> Result, + get_swapchain_counter_ext: extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *mut u64, + ) -> Result, +} +unsafe impl Send for ExtDisplayControlFn {} +unsafe impl Sync for ExtDisplayControlFn {} +impl ::std::clone::Clone for ExtDisplayControlFn { + fn clone(&self) -> Self { + ExtDisplayControlFn { + display_power_control_ext: self.display_power_control_ext, + register_device_event_ext: self.register_device_event_ext, + register_display_event_ext: self.register_display_event_ext, + get_swapchain_counter_ext: self.get_swapchain_counter_ext, } } - #[doc = "Generated from \'VK_EXT_display_control\'"] - impl StructureType { - pub const DISPLAY_POWER_INFO_EXT: Self = StructureType(1000091000); - } - #[doc = "Generated from \'VK_EXT_display_control\'"] - impl StructureType { - pub const DEVICE_EVENT_INFO_EXT: Self = StructureType(1000091001); - } - #[doc = "Generated from \'VK_EXT_display_control\'"] - impl StructureType { - pub const DISPLAY_EVENT_INFO_EXT: Self = StructureType(1000091002); - } - #[doc = "Generated from \'VK_EXT_display_control\'"] - impl StructureType { - pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = StructureType(1000091003); - } - pub struct GoogleDisplayTimingFn { - get_refresh_cycle_duration_google: - extern "system" fn( - device: Device, - swapchain: SwapchainKHR, - p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, - ) -> Result, - get_past_presentation_timing_google: - extern "system" fn( - device: Device, - swapchain: SwapchainKHR, - p_presentation_timing_count: *mut u32, - p_presentation_timings: *mut PastPresentationTimingGOOGLE, - ) -> Result, - } - unsafe impl Send for GoogleDisplayTimingFn {} - unsafe impl Sync for GoogleDisplayTimingFn {} - impl ::std::clone::Clone for GoogleDisplayTimingFn { - fn clone(&self) -> Self { - GoogleDisplayTimingFn { - get_refresh_cycle_duration_google: self.get_refresh_cycle_duration_google, - get_past_presentation_timing_google: self.get_past_presentation_timing_google, - } +} +impl ExtDisplayControlFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDisplayControlFn { + display_power_control_ext: unsafe { + let raw_name = stringify!(vkDisplayPowerControlEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_device_event_ext: unsafe { + let raw_name = stringify!(vkRegisterDeviceEventEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + register_display_event_ext: unsafe { + let raw_name = stringify!(vkRegisterDisplayEventEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_swapchain_counter_ext: unsafe { + let raw_name = stringify!(vkGetSwapchainCounterEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl GoogleDisplayTimingFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleDisplayTimingFn { - get_refresh_cycle_duration_google: unsafe { - let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_past_presentation_timing_google: unsafe { - let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_refresh_cycle_duration_google( - &self, + pub unsafe fn display_power_control_ext( + &self, + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result { + (self.display_power_control_ext)(device, display, p_display_power_info) + } + pub unsafe fn register_device_event_ext( + &self, + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, + ) -> Result { + (self.register_device_event_ext)(device, p_device_event_info, p_allocator, p_fence) + } + pub unsafe fn register_display_event_ext( + &self, + device: Device, + display: DisplayKHR, + p_display_event_info: *const DisplayEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, + ) -> Result { + (self.register_display_event_ext)( + device, + display, + p_display_event_info, + p_allocator, + p_fence, + ) + } + pub unsafe fn get_swapchain_counter_ext( + &self, + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *mut u64, + ) -> Result { + (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value) + } +} +#[doc = "Generated from \'VK_EXT_display_control\'"] +impl StructureType { + pub const DISPLAY_POWER_INFO_EXT: Self = StructureType(1000091000); +} +#[doc = "Generated from \'VK_EXT_display_control\'"] +impl StructureType { + pub const DEVICE_EVENT_INFO_EXT: Self = StructureType(1000091001); +} +#[doc = "Generated from \'VK_EXT_display_control\'"] +impl StructureType { + pub const DISPLAY_EVENT_INFO_EXT: Self = StructureType(1000091002); +} +#[doc = "Generated from \'VK_EXT_display_control\'"] +impl StructureType { + pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = StructureType(1000091003); +} +pub struct GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: + extern "system" fn( device: Device, swapchain: SwapchainKHR, p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, - ) -> Result { - (self.get_refresh_cycle_duration_google)(device, swapchain, p_display_timing_properties) - } - pub unsafe fn get_past_presentation_timing_google( - &self, + ) -> Result, + get_past_presentation_timing_google: + extern "system" fn( device: Device, swapchain: SwapchainKHR, p_presentation_timing_count: *mut u32, p_presentation_timings: *mut PastPresentationTimingGOOGLE, - ) -> Result { - (self.get_past_presentation_timing_google)( - device, - swapchain, - p_presentation_timing_count, - p_presentation_timings, - ) + ) -> Result, +} +unsafe impl Send for GoogleDisplayTimingFn {} +unsafe impl Sync for GoogleDisplayTimingFn {} +impl ::std::clone::Clone for GoogleDisplayTimingFn { + fn clone(&self) -> Self { + GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: self.get_refresh_cycle_duration_google, + get_past_presentation_timing_google: self.get_past_presentation_timing_google, } } - #[doc = "Generated from \'VK_GOOGLE_display_timing\'"] - impl StructureType { - pub const PRESENT_TIMES_INFO_GOOGLE: Self = StructureType(1000092000); - } - pub struct NvSampleMaskOverrideCoverageFn {} - unsafe impl Send for NvSampleMaskOverrideCoverageFn {} - unsafe impl Sync for NvSampleMaskOverrideCoverageFn {} - impl ::std::clone::Clone for NvSampleMaskOverrideCoverageFn { - fn clone(&self) -> Self { - NvSampleMaskOverrideCoverageFn {} +} +impl GoogleDisplayTimingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleDisplayTimingFn { + get_refresh_cycle_duration_google: unsafe { + let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_past_presentation_timing_google: unsafe { + let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvSampleMaskOverrideCoverageFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvSampleMaskOverrideCoverageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + pub unsafe fn get_refresh_cycle_duration_google( + &self, + device: Device, + swapchain: SwapchainKHR, + p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, + ) -> Result { + (self.get_refresh_cycle_duration_google)(device, swapchain, p_display_timing_properties) + } + pub unsafe fn get_past_presentation_timing_google( + &self, + device: Device, + swapchain: SwapchainKHR, + p_presentation_timing_count: *mut u32, + p_presentation_timings: *mut PastPresentationTimingGOOGLE, + ) -> Result { + (self.get_past_presentation_timing_google)( + device, + swapchain, + p_presentation_timing_count, + p_presentation_timings, + ) + } +} +#[doc = "Generated from \'VK_GOOGLE_display_timing\'"] +impl StructureType { + pub const PRESENT_TIMES_INFO_GOOGLE: Self = StructureType(1000092000); +} +pub struct NvSampleMaskOverrideCoverageFn {} +unsafe impl Send for NvSampleMaskOverrideCoverageFn {} +unsafe impl Sync for NvSampleMaskOverrideCoverageFn {} +impl ::std::clone::Clone for NvSampleMaskOverrideCoverageFn { + fn clone(&self) -> Self { + NvSampleMaskOverrideCoverageFn {} + } +} +impl NvSampleMaskOverrideCoverageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvSampleMaskOverrideCoverageFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvGeometryShaderPassthroughFn {} - unsafe impl Send for NvGeometryShaderPassthroughFn {} - unsafe impl Sync for NvGeometryShaderPassthroughFn {} - impl ::std::clone::Clone for NvGeometryShaderPassthroughFn { - fn clone(&self) -> Self { - NvGeometryShaderPassthroughFn {} +} +pub struct NvGeometryShaderPassthroughFn {} +unsafe impl Send for NvGeometryShaderPassthroughFn {} +unsafe impl Sync for NvGeometryShaderPassthroughFn {} +impl ::std::clone::Clone for NvGeometryShaderPassthroughFn { + fn clone(&self) -> Self { + NvGeometryShaderPassthroughFn {} + } +} +impl NvGeometryShaderPassthroughFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvGeometryShaderPassthroughFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvGeometryShaderPassthroughFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvGeometryShaderPassthroughFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct NvViewportArray2Fn {} +unsafe impl Send for NvViewportArray2Fn {} +unsafe impl Sync for NvViewportArray2Fn {} +impl ::std::clone::Clone for NvViewportArray2Fn { + fn clone(&self) -> Self { + NvViewportArray2Fn {} + } +} +impl NvViewportArray2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvViewportArray2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvViewportArray2Fn {} - unsafe impl Send for NvViewportArray2Fn {} - unsafe impl Sync for NvViewportArray2Fn {} - impl ::std::clone::Clone for NvViewportArray2Fn { - fn clone(&self) -> Self { - NvViewportArray2Fn {} +} +pub struct NvxMultiviewPerViewAttributesFn {} +unsafe impl Send for NvxMultiviewPerViewAttributesFn {} +unsafe impl Sync for NvxMultiviewPerViewAttributesFn {} +impl ::std::clone::Clone for NvxMultiviewPerViewAttributesFn { + fn clone(&self) -> Self { + NvxMultiviewPerViewAttributesFn {} + } +} +impl NvxMultiviewPerViewAttributesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvxMultiviewPerViewAttributesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvViewportArray2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvViewportArray2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +#[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self = + StructureType(1000097000); +} +#[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] +impl SubpassDescriptionFlags { + pub const PER_VIEW_ATTRIBUTES_NVX: Self = SubpassDescriptionFlags(0b1); +} +#[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] +impl SubpassDescriptionFlags { + pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = SubpassDescriptionFlags(0b10); +} +pub struct NvViewportSwizzleFn {} +unsafe impl Send for NvViewportSwizzleFn {} +unsafe impl Sync for NvViewportSwizzleFn {} +impl ::std::clone::Clone for NvViewportSwizzleFn { + fn clone(&self) -> Self { + NvViewportSwizzleFn {} + } +} +impl NvViewportSwizzleFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvViewportSwizzleFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvxMultiviewPerViewAttributesFn {} - unsafe impl Send for NvxMultiviewPerViewAttributesFn {} - unsafe impl Sync for NvxMultiviewPerViewAttributesFn {} - impl ::std::clone::Clone for NvxMultiviewPerViewAttributesFn { - fn clone(&self) -> Self { - NvxMultiviewPerViewAttributesFn {} +} +#[doc = "Generated from \'VK_NV_viewport_swizzle\'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = StructureType(1000098000); +} +pub struct ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: extern "system" fn( + command_buffer: CommandBuffer, + first_discard_rectangle: u32, + discard_rectangle_count: u32, + p_discard_rectangles: *const Rect2D, + ) -> c_void, +} +unsafe impl Send for ExtDiscardRectanglesFn {} +unsafe impl Sync for ExtDiscardRectanglesFn {} +impl ::std::clone::Clone for ExtDiscardRectanglesFn { + fn clone(&self) -> Self { + ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: self.cmd_set_discard_rectangle_ext, } } - impl NvxMultiviewPerViewAttributesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvxMultiviewPerViewAttributesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl ExtDiscardRectanglesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDiscardRectanglesFn { + cmd_set_discard_rectangle_ext: unsafe { + let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self = - StructureType(1000097000); + pub unsafe fn cmd_set_discard_rectangle_ext( + &self, + command_buffer: CommandBuffer, + first_discard_rectangle: u32, + discard_rectangle_count: u32, + p_discard_rectangles: *const Rect2D, + ) -> c_void { + (self.cmd_set_discard_rectangle_ext)( + command_buffer, + first_discard_rectangle, + discard_rectangle_count, + p_discard_rectangles, + ) } - #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] - impl SubpassDescriptionFlags { - pub const PER_VIEW_ATTRIBUTES_NVX: Self = SubpassDescriptionFlags(0b1); +} +#[doc = "Generated from \'VK_EXT_discard_rectangles\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = StructureType(1000099000); +} +#[doc = "Generated from \'VK_EXT_discard_rectangles\'"] +impl StructureType { + pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = StructureType(1000099001); +} +#[doc = "Generated from \'VK_EXT_discard_rectangles\'"] +impl DynamicState { + pub const DISCARD_RECTANGLE_EXT: Self = DynamicState(1000099000); +} +pub struct NvExtension101Fn {} +unsafe impl Send for NvExtension101Fn {} +unsafe impl Sync for NvExtension101Fn {} +impl ::std::clone::Clone for NvExtension101Fn { + fn clone(&self) -> Self { + NvExtension101Fn {} } - #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] - impl SubpassDescriptionFlags { - pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = SubpassDescriptionFlags(0b10); - } - pub struct NvViewportSwizzleFn {} - unsafe impl Send for NvViewportSwizzleFn {} - unsafe impl Sync for NvViewportSwizzleFn {} - impl ::std::clone::Clone for NvViewportSwizzleFn { - fn clone(&self) -> Self { - NvViewportSwizzleFn {} +} +impl NvExtension101Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension101Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvViewportSwizzleFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvViewportSwizzleFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct ExtConservativeRasterizationFn {} +unsafe impl Send for ExtConservativeRasterizationFn {} +unsafe impl Sync for ExtConservativeRasterizationFn {} +impl ::std::clone::Clone for ExtConservativeRasterizationFn { + fn clone(&self) -> Self { + ExtConservativeRasterizationFn {} + } +} +impl ExtConservativeRasterizationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtConservativeRasterizationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_NV_viewport_swizzle\'"] - impl StructureType { - pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = StructureType(1000098000); +} +#[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = + StructureType(1000101000); +} +#[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] +impl StructureType { + pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = + StructureType(1000101001); +} +pub struct NvExtension103Fn {} +unsafe impl Send for NvExtension103Fn {} +unsafe impl Sync for NvExtension103Fn {} +impl ::std::clone::Clone for NvExtension103Fn { + fn clone(&self) -> Self { + NvExtension103Fn {} } - pub struct ExtDiscardRectanglesFn { - cmd_set_discard_rectangle_ext: extern "system" fn( - command_buffer: CommandBuffer, - first_discard_rectangle: u32, - discard_rectangle_count: u32, - p_discard_rectangles: *const Rect2D, - ) -> c_void, - } - unsafe impl Send for ExtDiscardRectanglesFn {} - unsafe impl Sync for ExtDiscardRectanglesFn {} - impl ::std::clone::Clone for ExtDiscardRectanglesFn { - fn clone(&self) -> Self { - ExtDiscardRectanglesFn { - cmd_set_discard_rectangle_ext: self.cmd_set_discard_rectangle_ext, - } +} +impl NvExtension103Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension103Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtDiscardRectanglesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDiscardRectanglesFn { - cmd_set_discard_rectangle_ext: unsafe { - let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_set_discard_rectangle_ext( - &self, - command_buffer: CommandBuffer, - first_discard_rectangle: u32, - discard_rectangle_count: u32, - p_discard_rectangles: *const Rect2D, - ) -> c_void { - (self.cmd_set_discard_rectangle_ext)( - command_buffer, - first_discard_rectangle, - discard_rectangle_count, - p_discard_rectangles, - ) +} +pub struct NvExtension104Fn {} +unsafe impl Send for NvExtension104Fn {} +unsafe impl Sync for NvExtension104Fn {} +impl ::std::clone::Clone for NvExtension104Fn { + fn clone(&self) -> Self { + NvExtension104Fn {} + } +} +impl NvExtension104Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension104Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_EXT_discard_rectangles\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = - StructureType(1000099000); +} +pub struct ExtSwapchainColorspaceFn {} +unsafe impl Send for ExtSwapchainColorspaceFn {} +unsafe impl Sync for ExtSwapchainColorspaceFn {} +impl ::std::clone::Clone for ExtSwapchainColorspaceFn { + fn clone(&self) -> Self { + ExtSwapchainColorspaceFn {} } - #[doc = "Generated from \'VK_EXT_discard_rectangles\'"] - impl StructureType { - pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = - StructureType(1000099001); - } - #[doc = "Generated from \'VK_EXT_discard_rectangles\'"] - impl DynamicState { - pub const DISCARD_RECTANGLE_EXT: Self = DynamicState(1000099000); - } - pub struct NvExtension101Fn {} - unsafe impl Send for NvExtension101Fn {} - unsafe impl Sync for NvExtension101Fn {} - impl ::std::clone::Clone for NvExtension101Fn { - fn clone(&self) -> Self { - NvExtension101Fn {} +} +impl ExtSwapchainColorspaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtSwapchainColorspaceFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension101Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension101Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const DISPLAY_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104001); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const EXTENDED_SRGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104002); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const DCI_P3_LINEAR_EXT: Self = ColorSpaceKHR(1000104003); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const DCI_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104004); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const BT709_LINEAR_EXT: Self = ColorSpaceKHR(1000104005); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const BT709_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104006); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const BT2020_LINEAR_EXT: Self = ColorSpaceKHR(1000104007); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const HDR10_ST2084_EXT: Self = ColorSpaceKHR(1000104008); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const DOLBYVISION_EXT: Self = ColorSpaceKHR(1000104009); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const HDR10_HLG_EXT: Self = ColorSpaceKHR(1000104010); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const ADOBERGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104011); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const ADOBERGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104012); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const PASS_THROUGH_EXT: Self = ColorSpaceKHR(1000104013); +} +#[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] +impl ColorSpaceKHR { + pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104014); +} +pub struct ExtHdrMetadataFn { + set_hdr_metadata_ext: extern "system" fn( + device: Device, + swapchain_count: u32, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, + ) -> c_void, +} +unsafe impl Send for ExtHdrMetadataFn {} +unsafe impl Sync for ExtHdrMetadataFn {} +impl ::std::clone::Clone for ExtHdrMetadataFn { + fn clone(&self) -> Self { + ExtHdrMetadataFn { + set_hdr_metadata_ext: self.set_hdr_metadata_ext, } } - pub struct ExtConservativeRasterizationFn {} - unsafe impl Send for ExtConservativeRasterizationFn {} - unsafe impl Sync for ExtConservativeRasterizationFn {} - impl ::std::clone::Clone for ExtConservativeRasterizationFn { - fn clone(&self) -> Self { - ExtConservativeRasterizationFn {} +} +impl ExtHdrMetadataFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtHdrMetadataFn { + set_hdr_metadata_ext: unsafe { + let raw_name = stringify!(vkSetHdrMetadataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtConservativeRasterizationFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtConservativeRasterizationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + pub unsafe fn set_hdr_metadata_ext( + &self, + device: Device, + swapchain_count: u32, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, + ) -> c_void { + (self.set_hdr_metadata_ext)(device, swapchain_count, p_swapchains, p_metadata) + } +} +#[doc = "Generated from \'VK_EXT_hdr_metadata\'"] +impl StructureType { + pub const HDR_METADATA_EXT: Self = StructureType(1000105000); +} +pub struct ImgExtension107Fn {} +unsafe impl Send for ImgExtension107Fn {} +unsafe impl Sync for ImgExtension107Fn {} +impl ::std::clone::Clone for ImgExtension107Fn { + fn clone(&self) -> Self { + ImgExtension107Fn {} + } +} +impl ImgExtension107Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension107Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = - StructureType(1000101000); +} +pub struct ImgExtension108Fn {} +unsafe impl Send for ImgExtension108Fn {} +unsafe impl Sync for ImgExtension108Fn {} +impl ::std::clone::Clone for ImgExtension108Fn { + fn clone(&self) -> Self { + ImgExtension108Fn {} } - #[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] - impl StructureType { - pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = - StructureType(1000101001); - } - pub struct NvExtension103Fn {} - unsafe impl Send for NvExtension103Fn {} - unsafe impl Sync for NvExtension103Fn {} - impl ::std::clone::Clone for NvExtension103Fn { - fn clone(&self) -> Self { - NvExtension103Fn {} +} +impl ImgExtension108Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension108Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension103Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension103Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct ImgExtension109Fn {} +unsafe impl Send for ImgExtension109Fn {} +unsafe impl Sync for ImgExtension109Fn {} +impl ::std::clone::Clone for ImgExtension109Fn { + fn clone(&self) -> Self { + ImgExtension109Fn {} + } +} +impl ImgExtension109Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension109Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvExtension104Fn {} - unsafe impl Send for NvExtension104Fn {} - unsafe impl Sync for NvExtension104Fn {} - impl ::std::clone::Clone for NvExtension104Fn { - fn clone(&self) -> Self { - NvExtension104Fn {} +} +pub struct ImgExtension110Fn {} +unsafe impl Send for ImgExtension110Fn {} +unsafe impl Sync for ImgExtension110Fn {} +impl ::std::clone::Clone for ImgExtension110Fn { + fn clone(&self) -> Self { + ImgExtension110Fn {} + } +} +impl ImgExtension110Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension110Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension104Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension104Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct ImgExtension111Fn {} +unsafe impl Send for ImgExtension111Fn {} +unsafe impl Sync for ImgExtension111Fn {} +impl ::std::clone::Clone for ImgExtension111Fn { + fn clone(&self) -> Self { + ImgExtension111Fn {} + } +} +impl ImgExtension111Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ImgExtension111Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct ExtSwapchainColorspaceFn {} - unsafe impl Send for ExtSwapchainColorspaceFn {} - unsafe impl Sync for ExtSwapchainColorspaceFn {} - impl ::std::clone::Clone for ExtSwapchainColorspaceFn { - fn clone(&self) -> Self { - ExtSwapchainColorspaceFn {} +} +pub struct KhrSharedPresentableImageFn { + get_swapchain_status_khr: extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, +} +unsafe impl Send for KhrSharedPresentableImageFn {} +unsafe impl Sync for KhrSharedPresentableImageFn {} +impl ::std::clone::Clone for KhrSharedPresentableImageFn { + fn clone(&self) -> Self { + KhrSharedPresentableImageFn { + get_swapchain_status_khr: self.get_swapchain_status_khr, } } - impl ExtSwapchainColorspaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtSwapchainColorspaceFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrSharedPresentableImageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSharedPresentableImageFn { + get_swapchain_status_khr: unsafe { + let raw_name = stringify!(vkGetSwapchainStatusKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const DISPLAY_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104001); + pub unsafe fn get_swapchain_status_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + ) -> Result { + (self.get_swapchain_status_khr)(device, swapchain) } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const EXTENDED_SRGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104002); +} +#[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] +impl StructureType { + pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = StructureType(1000111000); +} +#[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] +impl PresentModeKHR { + pub const SHARED_DEMAND_REFRESH: Self = PresentModeKHR(1000111000); +} +#[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] +impl PresentModeKHR { + pub const SHARED_CONTINUOUS_REFRESH: Self = PresentModeKHR(1000111001); +} +#[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] +impl ImageLayout { + pub const SHARED_PRESENT_KHR: Self = ImageLayout(1000111000); +} +pub struct KhrExternalFenceCapabilitiesFn {} +unsafe impl Send for KhrExternalFenceCapabilitiesFn {} +unsafe impl Sync for KhrExternalFenceCapabilitiesFn {} +impl ::std::clone::Clone for KhrExternalFenceCapabilitiesFn { + fn clone(&self) -> Self { + KhrExternalFenceCapabilitiesFn {} } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const DCI_P3_LINEAR_EXT: Self = ColorSpaceKHR(1000104003); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const DCI_P3_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104004); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const BT709_LINEAR_EXT: Self = ColorSpaceKHR(1000104005); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const BT709_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104006); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const BT2020_LINEAR_EXT: Self = ColorSpaceKHR(1000104007); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const HDR10_ST2084_EXT: Self = ColorSpaceKHR(1000104008); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const DOLBYVISION_EXT: Self = ColorSpaceKHR(1000104009); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const HDR10_HLG_EXT: Self = ColorSpaceKHR(1000104010); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const ADOBERGB_LINEAR_EXT: Self = ColorSpaceKHR(1000104011); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const ADOBERGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104012); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const PASS_THROUGH_EXT: Self = ColorSpaceKHR(1000104013); - } - #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] - impl ColorSpaceKHR { - pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = ColorSpaceKHR(1000104014); - } - pub struct ExtHdrMetadataFn { - set_hdr_metadata_ext: extern "system" fn( - device: Device, - swapchain_count: u32, - p_swapchains: *const SwapchainKHR, - p_metadata: *const HdrMetadataEXT, - ) -> c_void, - } - unsafe impl Send for ExtHdrMetadataFn {} - unsafe impl Sync for ExtHdrMetadataFn {} - impl ::std::clone::Clone for ExtHdrMetadataFn { - fn clone(&self) -> Self { - ExtHdrMetadataFn { - set_hdr_metadata_ext: self.set_hdr_metadata_ext, - } +} +impl KhrExternalFenceCapabilitiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceCapabilitiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtHdrMetadataFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtHdrMetadataFn { - set_hdr_metadata_ext: unsafe { - let raw_name = stringify!(vkSetHdrMetadataEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn set_hdr_metadata_ext( - &self, - device: Device, - swapchain_count: u32, - p_swapchains: *const SwapchainKHR, - p_metadata: *const HdrMetadataEXT, - ) -> c_void { - (self.set_hdr_metadata_ext)(device, swapchain_count, p_swapchains, p_metadata) +} +pub struct KhrExternalFenceFn {} +unsafe impl Send for KhrExternalFenceFn {} +unsafe impl Sync for KhrExternalFenceFn {} +impl ::std::clone::Clone for KhrExternalFenceFn { + fn clone(&self) -> Self { + KhrExternalFenceFn {} + } +} +impl KhrExternalFenceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_EXT_hdr_metadata\'"] - impl StructureType { - pub const HDR_METADATA_EXT: Self = StructureType(1000105000); - } - pub struct ImgExtension107Fn {} - unsafe impl Send for ImgExtension107Fn {} - unsafe impl Sync for ImgExtension107Fn {} - impl ::std::clone::Clone for ImgExtension107Fn { - fn clone(&self) -> Self { - ImgExtension107Fn {} - } - } - impl ImgExtension107Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgExtension107Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ImgExtension108Fn {} - unsafe impl Send for ImgExtension108Fn {} - unsafe impl Sync for ImgExtension108Fn {} - impl ::std::clone::Clone for ImgExtension108Fn { - fn clone(&self) -> Self { - ImgExtension108Fn {} - } - } - impl ImgExtension108Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgExtension108Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ImgExtension109Fn {} - unsafe impl Send for ImgExtension109Fn {} - unsafe impl Sync for ImgExtension109Fn {} - impl ::std::clone::Clone for ImgExtension109Fn { - fn clone(&self) -> Self { - ImgExtension109Fn {} - } - } - impl ImgExtension109Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgExtension109Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ImgExtension110Fn {} - unsafe impl Send for ImgExtension110Fn {} - unsafe impl Sync for ImgExtension110Fn {} - impl ::std::clone::Clone for ImgExtension110Fn { - fn clone(&self) -> Self { - ImgExtension110Fn {} - } - } - impl ImgExtension110Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgExtension110Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ImgExtension111Fn {} - unsafe impl Send for ImgExtension111Fn {} - unsafe impl Sync for ImgExtension111Fn {} - impl ::std::clone::Clone for ImgExtension111Fn { - fn clone(&self) -> Self { - ImgExtension111Fn {} - } - } - impl ImgExtension111Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ImgExtension111Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrSharedPresentableImageFn { - get_swapchain_status_khr: - extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, - } - unsafe impl Send for KhrSharedPresentableImageFn {} - unsafe impl Sync for KhrSharedPresentableImageFn {} - impl ::std::clone::Clone for KhrSharedPresentableImageFn { - fn clone(&self) -> Self { - KhrSharedPresentableImageFn { - get_swapchain_status_khr: self.get_swapchain_status_khr, - } - } - } - impl KhrSharedPresentableImageFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSharedPresentableImageFn { - get_swapchain_status_khr: unsafe { - let raw_name = stringify!(vkGetSwapchainStatusKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_swapchain_status_khr( - &self, - device: Device, - swapchain: SwapchainKHR, - ) -> Result { - (self.get_swapchain_status_khr)(device, swapchain) - } - } - #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] - impl StructureType { - pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = StructureType(1000111000); - } - #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] - impl PresentModeKHR { - pub const SHARED_DEMAND_REFRESH: Self = PresentModeKHR(1000111000); - } - #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] - impl PresentModeKHR { - pub const SHARED_CONTINUOUS_REFRESH: Self = PresentModeKHR(1000111001); - } - #[doc = "Generated from \'VK_KHR_shared_presentable_image\'"] - impl ImageLayout { - pub const SHARED_PRESENT_KHR: Self = ImageLayout(1000111000); - } - pub struct KhrExternalFenceCapabilitiesFn {} - unsafe impl Send for KhrExternalFenceCapabilitiesFn {} - unsafe impl Sync for KhrExternalFenceCapabilitiesFn {} - impl ::std::clone::Clone for KhrExternalFenceCapabilitiesFn { - fn clone(&self) -> Self { - KhrExternalFenceCapabilitiesFn {} - } - } - impl KhrExternalFenceCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExternalFenceFn {} - unsafe impl Send for KhrExternalFenceFn {} - unsafe impl Sync for KhrExternalFenceFn {} - impl ::std::clone::Clone for KhrExternalFenceFn { - fn clone(&self) -> Self { - KhrExternalFenceFn {} - } - } - impl KhrExternalFenceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExternalFenceWin32Fn { import_fence_win32_handle_khr : extern "system" fn ( device : Device , p_import_fence_win32_handle_info : *const ImportFenceWin32HandleInfoKHR , ) -> Result , get_fence_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const FenceGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } - unsafe impl Send for KhrExternalFenceWin32Fn {} - unsafe impl Sync for KhrExternalFenceWin32Fn {} - impl ::std::clone::Clone for KhrExternalFenceWin32Fn { - fn clone(&self) -> Self { - KhrExternalFenceWin32Fn { - import_fence_win32_handle_khr: self.import_fence_win32_handle_khr, - get_fence_win32_handle_khr: self.get_fence_win32_handle_khr, - } - } - } - impl KhrExternalFenceWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceWin32Fn { - import_fence_win32_handle_khr: unsafe { - let raw_name = stringify!(vkImportFenceWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_fence_win32_handle_khr: unsafe { - let raw_name = stringify!(vkGetFenceWin32HandleKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn import_fence_win32_handle_khr( - &self, +} +pub struct KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: + extern "system" fn( device: Device, p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, - ) -> Result { - (self.import_fence_win32_handle_khr)(device, p_import_fence_win32_handle_info) - } - pub unsafe fn get_fence_win32_handle_khr( - &self, + ) -> Result, + get_fence_win32_handle_khr: + extern "system" fn( device: Device, p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, p_handle: *mut HANDLE, - ) -> Result { - (self.get_fence_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) - } - } - #[doc = "Generated from \'VK_KHR_external_fence_win32\'"] - impl StructureType { - pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114000); - } - #[doc = "Generated from \'VK_KHR_external_fence_win32\'"] - impl StructureType { - pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114001); - } - #[doc = "Generated from \'VK_KHR_external_fence_win32\'"] - impl StructureType { - pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114002); - } - pub struct KhrExternalFenceFdFn { - import_fence_fd_khr: - extern "system" fn(device: Device, p_import_fence_fd_info: *const ImportFenceFdInfoKHR) - -> Result, - get_fence_fd_khr: extern "system" fn( - device: Device, - p_get_fd_info: *const FenceGetFdInfoKHR, - p_fd: *mut c_int, ) -> Result, - } - unsafe impl Send for KhrExternalFenceFdFn {} - unsafe impl Sync for KhrExternalFenceFdFn {} - impl ::std::clone::Clone for KhrExternalFenceFdFn { - fn clone(&self) -> Self { - KhrExternalFenceFdFn { - import_fence_fd_khr: self.import_fence_fd_khr, - get_fence_fd_khr: self.get_fence_fd_khr, - } +} +unsafe impl Send for KhrExternalFenceWin32Fn {} +unsafe impl Sync for KhrExternalFenceWin32Fn {} +impl ::std::clone::Clone for KhrExternalFenceWin32Fn { + fn clone(&self) -> Self { + KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: self.import_fence_win32_handle_khr, + get_fence_win32_handle_khr: self.get_fence_win32_handle_khr, } } - impl KhrExternalFenceFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceFdFn { - import_fence_fd_khr: unsafe { - let raw_name = stringify!(vkImportFenceFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_fence_fd_khr: unsafe { - let raw_name = stringify!(vkGetFenceFdKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn import_fence_fd_khr( - &self, - device: Device, - p_import_fence_fd_info: *const ImportFenceFdInfoKHR, - ) -> Result { - (self.import_fence_fd_khr)(device, p_import_fence_fd_info) - } - pub unsafe fn get_fence_fd_khr( - &self, - device: Device, - p_get_fd_info: *const FenceGetFdInfoKHR, - p_fd: *mut c_int, - ) -> Result { - (self.get_fence_fd_khr)(device, p_get_fd_info, p_fd) +} +impl KhrExternalFenceWin32Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceWin32Fn { + import_fence_win32_handle_khr: unsafe { + let raw_name = stringify!(vkImportFenceWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_fence_win32_handle_khr: unsafe { + let raw_name = stringify!(vkGetFenceWin32HandleKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_KHR_external_fence_fd\'"] - impl StructureType { - pub const IMPORT_FENCE_FD_INFO_KHR: Self = StructureType(1000115000); + pub unsafe fn import_fence_win32_handle_khr( + &self, + device: Device, + p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, + ) -> Result { + (self.import_fence_win32_handle_khr)(device, p_import_fence_win32_handle_info) } - #[doc = "Generated from \'VK_KHR_external_fence_fd\'"] - impl StructureType { - pub const FENCE_GET_FD_INFO_KHR: Self = StructureType(1000115001); + pub unsafe fn get_fence_win32_handle_khr( + &self, + device: Device, + p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, + ) -> Result { + (self.get_fence_win32_handle_khr)(device, p_get_win32_handle_info, p_handle) } - pub struct KhrExtension117Fn {} - unsafe impl Send for KhrExtension117Fn {} - unsafe impl Sync for KhrExtension117Fn {} - impl ::std::clone::Clone for KhrExtension117Fn { - fn clone(&self) -> Self { - KhrExtension117Fn {} +} +#[doc = "Generated from \'VK_KHR_external_fence_win32\'"] +impl StructureType { + pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114000); +} +#[doc = "Generated from \'VK_KHR_external_fence_win32\'"] +impl StructureType { + pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114001); +} +#[doc = "Generated from \'VK_KHR_external_fence_win32\'"] +impl StructureType { + pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = StructureType(1000114002); +} +pub struct KhrExternalFenceFdFn { + import_fence_fd_khr: + extern "system" fn(device: Device, p_import_fence_fd_info: *const ImportFenceFdInfoKHR) + -> Result, + get_fence_fd_khr: extern "system" fn( + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *mut c_int, + ) -> Result, +} +unsafe impl Send for KhrExternalFenceFdFn {} +unsafe impl Sync for KhrExternalFenceFdFn {} +impl ::std::clone::Clone for KhrExternalFenceFdFn { + fn clone(&self) -> Self { + KhrExternalFenceFdFn { + import_fence_fd_khr: self.import_fence_fd_khr, + get_fence_fd_khr: self.get_fence_fd_khr, } } - impl KhrExtension117Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension117Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl KhrExternalFenceFdFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExternalFenceFdFn { + import_fence_fd_khr: unsafe { + let raw_name = stringify!(vkImportFenceFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_fence_fd_khr: unsafe { + let raw_name = stringify!(vkGetFenceFdKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct KhrMaintenance2Fn {} - unsafe impl Send for KhrMaintenance2Fn {} - unsafe impl Sync for KhrMaintenance2Fn {} - impl ::std::clone::Clone for KhrMaintenance2Fn { - fn clone(&self) -> Self { - KhrMaintenance2Fn {} + pub unsafe fn import_fence_fd_khr( + &self, + device: Device, + p_import_fence_fd_info: *const ImportFenceFdInfoKHR, + ) -> Result { + (self.import_fence_fd_khr)(device, p_import_fence_fd_info) + } + pub unsafe fn get_fence_fd_khr( + &self, + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *mut c_int, + ) -> Result { + (self.get_fence_fd_khr)(device, p_get_fd_info, p_fd) + } +} +#[doc = "Generated from \'VK_KHR_external_fence_fd\'"] +impl StructureType { + pub const IMPORT_FENCE_FD_INFO_KHR: Self = StructureType(1000115000); +} +#[doc = "Generated from \'VK_KHR_external_fence_fd\'"] +impl StructureType { + pub const FENCE_GET_FD_INFO_KHR: Self = StructureType(1000115001); +} +pub struct KhrExtension117Fn {} +unsafe impl Send for KhrExtension117Fn {} +unsafe impl Sync for KhrExtension117Fn {} +impl ::std::clone::Clone for KhrExtension117Fn { + fn clone(&self) -> Self { + KhrExtension117Fn {} + } +} +impl KhrExtension117Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension117Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrMaintenance2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrMaintenance2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct KhrMaintenance2Fn {} +unsafe impl Send for KhrMaintenance2Fn {} +unsafe impl Sync for KhrMaintenance2Fn {} +impl ::std::clone::Clone for KhrMaintenance2Fn { + fn clone(&self) -> Self { + KhrMaintenance2Fn {} + } +} +impl KhrMaintenance2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMaintenance2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct KhrExtension119Fn {} - unsafe impl Send for KhrExtension119Fn {} - unsafe impl Sync for KhrExtension119Fn {} - impl ::std::clone::Clone for KhrExtension119Fn { - fn clone(&self) -> Self { - KhrExtension119Fn {} +} +pub struct KhrExtension119Fn {} +unsafe impl Send for KhrExtension119Fn {} +unsafe impl Sync for KhrExtension119Fn {} +impl ::std::clone::Clone for KhrExtension119Fn { + fn clone(&self) -> Self { + KhrExtension119Fn {} + } +} +impl KhrExtension119Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension119Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrExtension119Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension119Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: - extern "system" fn( - physical_device: PhysicalDevice, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_capabilities: *mut SurfaceCapabilities2KHR, - ) -> Result, - get_physical_device_surface_formats2_khr: - extern "system" fn( - physical_device: PhysicalDevice, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_surface_format_count: *mut u32, - p_surface_formats: *mut SurfaceFormat2KHR, - ) -> Result, - } - unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} - unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {} - impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { - fn clone(&self) -> Self { - KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: - self.get_physical_device_surface_capabilities2_khr, - get_physical_device_surface_formats2_khr: self - .get_physical_device_surface_formats2_khr, - } - } - } - impl KhrGetSurfaceCapabilities2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_surface_formats2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_physical_device_surface_capabilities2_khr( - &self, +} +pub struct KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: + extern "system" fn( physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, p_surface_capabilities: *mut SurfaceCapabilities2KHR, - ) -> Result { - (self.get_physical_device_surface_capabilities2_khr)( - physical_device, - p_surface_info, - p_surface_capabilities, - ) - } - pub unsafe fn get_physical_device_surface_formats2_khr( - &self, + ) -> Result, + get_physical_device_surface_formats2_khr: + extern "system" fn( physical_device: PhysicalDevice, p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, p_surface_format_count: *mut u32, p_surface_formats: *mut SurfaceFormat2KHR, - ) -> Result { - (self.get_physical_device_surface_formats2_khr)( - physical_device, - p_surface_info, - p_surface_format_count, - p_surface_formats, - ) + ) -> Result, +} +unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} +unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {} +impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { + fn clone(&self) -> Self { + KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: + self.get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_formats2_khr: self.get_physical_device_surface_formats2_khr, } } - #[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = StructureType(1000119000); - } - #[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] - impl StructureType { - pub const SURFACE_CAPABILITIES_2_KHR: Self = StructureType(1000119001); - } - #[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] - impl StructureType { - pub const SURFACE_FORMAT_2_KHR: Self = StructureType(1000119002); - } - pub struct KhrVariablePointersFn {} - unsafe impl Send for KhrVariablePointersFn {} - unsafe impl Sync for KhrVariablePointersFn {} - impl ::std::clone::Clone for KhrVariablePointersFn { - fn clone(&self) -> Self { - KhrVariablePointersFn {} +} +impl KhrGetSurfaceCapabilities2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetSurfaceCapabilities2Fn { + get_physical_device_surface_capabilities2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_surface_formats2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrVariablePointersFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrVariablePointersFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + pub unsafe fn get_physical_device_surface_capabilities2_khr( + &self, + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_capabilities: *mut SurfaceCapabilities2KHR, + ) -> Result { + (self.get_physical_device_surface_capabilities2_khr)( + physical_device, + p_surface_info, + p_surface_capabilities, + ) + } + pub unsafe fn get_physical_device_surface_formats2_khr( + &self, + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_format_count: *mut u32, + p_surface_formats: *mut SurfaceFormat2KHR, + ) -> Result { + (self.get_physical_device_surface_formats2_khr)( + physical_device, + p_surface_info, + p_surface_format_count, + p_surface_formats, + ) + } +} +#[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = StructureType(1000119000); +} +#[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] +impl StructureType { + pub const SURFACE_CAPABILITIES_2_KHR: Self = StructureType(1000119001); +} +#[doc = "Generated from \'VK_KHR_get_surface_capabilities2\'"] +impl StructureType { + pub const SURFACE_FORMAT_2_KHR: Self = StructureType(1000119002); +} +pub struct KhrVariablePointersFn {} +unsafe impl Send for KhrVariablePointersFn {} +unsafe impl Sync for KhrVariablePointersFn {} +impl ::std::clone::Clone for KhrVariablePointersFn { + fn clone(&self) -> Self { + KhrVariablePointersFn {} + } +} +impl KhrVariablePointersFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrVariablePointersFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: - extern "system" fn( - physical_device: PhysicalDevice, - p_property_count: *mut u32, - p_properties: *mut DisplayProperties2KHR, - ) -> Result, - get_physical_device_display_plane_properties2_khr: - extern "system" fn( - physical_device: PhysicalDevice, - p_property_count: *mut u32, - p_properties: *mut DisplayPlaneProperties2KHR, - ) -> Result, - get_display_mode_properties2_khr: - extern "system" fn( - physical_device: PhysicalDevice, - display: DisplayKHR, - p_property_count: *mut u32, - p_properties: *mut DisplayModeProperties2KHR, - ) -> Result, - get_display_plane_capabilities2_khr: - extern "system" fn( - physical_device: PhysicalDevice, - p_display_plane_info: *const DisplayPlaneInfo2KHR, - p_capabilities: *mut DisplayPlaneCapabilities2KHR, - ) -> Result, - } - unsafe impl Send for KhrGetDisplayProperties2Fn {} - unsafe impl Sync for KhrGetDisplayProperties2Fn {} - impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { - fn clone(&self) -> Self { - KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: - self.get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: - self.get_physical_device_display_plane_properties2_khr, - get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, - get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, - } - } - } - impl KhrGetDisplayProperties2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_display_plane_properties2_khr: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_mode_properties2_khr: unsafe { - let raw_name = stringify!(vkGetDisplayModeProperties2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_display_plane_capabilities2_khr: unsafe { - let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_physical_device_display_properties2_khr( - &self, +} +pub struct KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: + extern "system" fn( physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut DisplayProperties2KHR, - ) -> Result { - (self.get_physical_device_display_properties2_khr)( - physical_device, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_physical_device_display_plane_properties2_khr( - &self, + ) -> Result, + get_physical_device_display_plane_properties2_khr: + extern "system" fn( physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut DisplayPlaneProperties2KHR, - ) -> Result { - (self.get_physical_device_display_plane_properties2_khr)( - physical_device, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_display_mode_properties2_khr( - &self, + ) -> Result, + get_display_mode_properties2_khr: + extern "system" fn( physical_device: PhysicalDevice, display: DisplayKHR, p_property_count: *mut u32, p_properties: *mut DisplayModeProperties2KHR, - ) -> Result { - (self.get_display_mode_properties2_khr)( - physical_device, - display, - p_property_count, - p_properties, - ) - } - pub unsafe fn get_display_plane_capabilities2_khr( - &self, + ) -> Result, + get_display_plane_capabilities2_khr: + extern "system" fn( physical_device: PhysicalDevice, p_display_plane_info: *const DisplayPlaneInfo2KHR, p_capabilities: *mut DisplayPlaneCapabilities2KHR, - ) -> Result { - (self.get_display_plane_capabilities2_khr)( - physical_device, - p_display_plane_info, - p_capabilities, - ) - } - } - #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] - impl StructureType { - pub const DISPLAY_PROPERTIES_2_KHR: Self = StructureType(1000121000); - } - #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] - impl StructureType { - pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = StructureType(1000121001); - } - #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] - impl StructureType { - pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = StructureType(1000121002); - } - #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] - impl StructureType { - pub const DISPLAY_PLANE_INFO_2_KHR: Self = StructureType(1000121003); - } - #[doc = "Generated from \'VK_KHR_get_display_properties2\'"] - impl StructureType { - pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = StructureType(1000121004); - } - pub struct MvkIosSurfaceFn { - create_ios_surface_mvk: extern "system" fn( - instance: Instance, - p_create_info: *const IOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, ) -> Result, - } - unsafe impl Send for MvkIosSurfaceFn {} - unsafe impl Sync for MvkIosSurfaceFn {} - impl ::std::clone::Clone for MvkIosSurfaceFn { - fn clone(&self) -> Self { - MvkIosSurfaceFn { - create_ios_surface_mvk: self.create_ios_surface_mvk, - } +} +unsafe impl Send for KhrGetDisplayProperties2Fn {} +unsafe impl Sync for KhrGetDisplayProperties2Fn {} +impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { + fn clone(&self) -> Self { + KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: + self.get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: + self.get_physical_device_display_plane_properties2_khr, + get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, + get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } } - impl MvkIosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = MvkIosSurfaceFn { - create_ios_surface_mvk: unsafe { - let raw_name = stringify!(vkCreateIOSSurfaceMVK); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_ios_surface_mvk( - &self, - instance: Instance, - p_create_info: *const IOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_ios_surface_mvk)(instance, p_create_info, p_allocator, p_surface) +} +impl KhrGetDisplayProperties2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetDisplayProperties2Fn { + get_physical_device_display_properties2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_display_plane_properties2_khr: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_mode_properties2_khr: unsafe { + let raw_name = stringify!(vkGetDisplayModeProperties2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_display_plane_capabilities2_khr: unsafe { + let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_MVK_ios_surface\'"] - impl StructureType { - pub const IOS_SURFACE_CREATE_INFO_M: Self = StructureType(1000122000); + pub unsafe fn get_physical_device_display_properties2_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayProperties2KHR, + ) -> Result { + (self.get_physical_device_display_properties2_khr)( + physical_device, + p_property_count, + p_properties, + ) } - pub struct MvkMacosSurfaceFn { - create_mac_os_surface_mvk: - extern "system" fn( - instance: Instance, - p_create_info: *const MacOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, + pub unsafe fn get_physical_device_display_plane_properties2_khr( + &self, + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPlaneProperties2KHR, + ) -> Result { + (self.get_physical_device_display_plane_properties2_khr)( + physical_device, + p_property_count, + p_properties, + ) } - unsafe impl Send for MvkMacosSurfaceFn {} - unsafe impl Sync for MvkMacosSurfaceFn {} - impl ::std::clone::Clone for MvkMacosSurfaceFn { - fn clone(&self) -> Self { - MvkMacosSurfaceFn { - create_mac_os_surface_mvk: self.create_mac_os_surface_mvk, - } + pub unsafe fn get_display_mode_properties2_khr( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut u32, + p_properties: *mut DisplayModeProperties2KHR, + ) -> Result { + (self.get_display_mode_properties2_khr)( + physical_device, + display, + p_property_count, + p_properties, + ) + } + pub unsafe fn get_display_plane_capabilities2_khr( + &self, + physical_device: PhysicalDevice, + p_display_plane_info: *const DisplayPlaneInfo2KHR, + p_capabilities: *mut DisplayPlaneCapabilities2KHR, + ) -> Result { + (self.get_display_plane_capabilities2_khr)( + physical_device, + p_display_plane_info, + p_capabilities, + ) + } +} +#[doc = "Generated from \'VK_KHR_get_display_properties2\'"] +impl StructureType { + pub const DISPLAY_PROPERTIES_2_KHR: Self = StructureType(1000121000); +} +#[doc = "Generated from \'VK_KHR_get_display_properties2\'"] +impl StructureType { + pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = StructureType(1000121001); +} +#[doc = "Generated from \'VK_KHR_get_display_properties2\'"] +impl StructureType { + pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = StructureType(1000121002); +} +#[doc = "Generated from \'VK_KHR_get_display_properties2\'"] +impl StructureType { + pub const DISPLAY_PLANE_INFO_2_KHR: Self = StructureType(1000121003); +} +#[doc = "Generated from \'VK_KHR_get_display_properties2\'"] +impl StructureType { + pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = StructureType(1000121004); +} +pub struct MvkIosSurfaceFn { + create_ios_surface_mvk: extern "system" fn( + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, +} +unsafe impl Send for MvkIosSurfaceFn {} +unsafe impl Sync for MvkIosSurfaceFn {} +impl ::std::clone::Clone for MvkIosSurfaceFn { + fn clone(&self) -> Self { + MvkIosSurfaceFn { + create_ios_surface_mvk: self.create_ios_surface_mvk, } } - impl MvkMacosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = MvkMacosSurfaceFn { - create_mac_os_surface_mvk: unsafe { - let raw_name = stringify!(vkCreateMacOSSurfaceMVK); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn create_mac_os_surface_mvk( - &self, - instance: Instance, - p_create_info: *const MacOSSurfaceCreateInfoMVK, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_mac_os_surface_mvk)(instance, p_create_info, p_allocator, p_surface) +} +impl MvkIosSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkIosSurfaceFn { + create_ios_surface_mvk: unsafe { + let raw_name = stringify!(vkCreateIOSSurfaceMVK); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_MVK_macos_surface\'"] - impl StructureType { - pub const MACOS_SURFACE_CREATE_INFO_M: Self = StructureType(1000123000); + pub unsafe fn create_ios_surface_mvk( + &self, + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_ios_surface_mvk)(instance, p_create_info, p_allocator, p_surface) } - pub struct MvkMoltenvkFn {} - unsafe impl Send for MvkMoltenvkFn {} - unsafe impl Sync for MvkMoltenvkFn {} - impl ::std::clone::Clone for MvkMoltenvkFn { - fn clone(&self) -> Self { - MvkMoltenvkFn {} +} +#[doc = "Generated from \'VK_MVK_ios_surface\'"] +impl StructureType { + pub const IOS_SURFACE_CREATE_INFO_M: Self = StructureType(1000122000); +} +pub struct MvkMacosSurfaceFn { + create_mac_os_surface_mvk: extern "system" fn( + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, +} +unsafe impl Send for MvkMacosSurfaceFn {} +unsafe impl Sync for MvkMacosSurfaceFn {} +impl ::std::clone::Clone for MvkMacosSurfaceFn { + fn clone(&self) -> Self { + MvkMacosSurfaceFn { + create_mac_os_surface_mvk: self.create_mac_os_surface_mvk, } } - impl MvkMoltenvkFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = MvkMoltenvkFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl MvkMacosSurfaceFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkMacosSurfaceFn { + create_mac_os_surface_mvk: unsafe { + let raw_name = stringify!(vkCreateMacOSSurfaceMVK); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct ExtExternalMemoryDmaBufFn {} - unsafe impl Send for ExtExternalMemoryDmaBufFn {} - unsafe impl Sync for ExtExternalMemoryDmaBufFn {} - impl ::std::clone::Clone for ExtExternalMemoryDmaBufFn { - fn clone(&self) -> Self { - ExtExternalMemoryDmaBufFn {} + pub unsafe fn create_mac_os_surface_mvk( + &self, + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_mac_os_surface_mvk)(instance, p_create_info, p_allocator, p_surface) + } +} +#[doc = "Generated from \'VK_MVK_macos_surface\'"] +impl StructureType { + pub const MACOS_SURFACE_CREATE_INFO_M: Self = StructureType(1000123000); +} +pub struct MvkMoltenvkFn {} +unsafe impl Send for MvkMoltenvkFn {} +unsafe impl Sync for MvkMoltenvkFn {} +impl ::std::clone::Clone for MvkMoltenvkFn { + fn clone(&self) -> Self { + MvkMoltenvkFn {} + } +} +impl MvkMoltenvkFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = MvkMoltenvkFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtExternalMemoryDmaBufFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExternalMemoryDmaBufFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct ExtExternalMemoryDmaBufFn {} +unsafe impl Send for ExtExternalMemoryDmaBufFn {} +unsafe impl Sync for ExtExternalMemoryDmaBufFn {} +impl ::std::clone::Clone for ExtExternalMemoryDmaBufFn { + fn clone(&self) -> Self { + ExtExternalMemoryDmaBufFn {} + } +} +impl ExtExternalMemoryDmaBufFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExternalMemoryDmaBufFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_EXT_external_memory_dma_buf\'"] - impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF: Self = - ExternalMemoryHandleTypeFlags(0b1000000000); +} +#[doc = "Generated from \'VK_EXT_external_memory_dma_buf\'"] +impl ExternalMemoryHandleTypeFlags { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF: Self = + ExternalMemoryHandleTypeFlags(0b1000000000); +} +pub struct ExtQueueFamilyForeignFn {} +unsafe impl Send for ExtQueueFamilyForeignFn {} +unsafe impl Sync for ExtQueueFamilyForeignFn {} +impl ::std::clone::Clone for ExtQueueFamilyForeignFn { + fn clone(&self) -> Self { + ExtQueueFamilyForeignFn {} } - pub struct ExtQueueFamilyForeignFn {} - unsafe impl Send for ExtQueueFamilyForeignFn {} - unsafe impl Sync for ExtQueueFamilyForeignFn {} - impl ::std::clone::Clone for ExtQueueFamilyForeignFn { - fn clone(&self) -> Self { - ExtQueueFamilyForeignFn {} +} +impl ExtQueueFamilyForeignFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtQueueFamilyForeignFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtQueueFamilyForeignFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtQueueFamilyForeignFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct KhrDedicatedAllocationFn {} +unsafe impl Send for KhrDedicatedAllocationFn {} +unsafe impl Sync for KhrDedicatedAllocationFn {} +impl ::std::clone::Clone for KhrDedicatedAllocationFn { + fn clone(&self) -> Self { + KhrDedicatedAllocationFn {} + } +} +impl KhrDedicatedAllocationFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDedicatedAllocationFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct KhrDedicatedAllocationFn {} - unsafe impl Send for KhrDedicatedAllocationFn {} - unsafe impl Sync for KhrDedicatedAllocationFn {} - impl ::std::clone::Clone for KhrDedicatedAllocationFn { - fn clone(&self) -> Self { - KhrDedicatedAllocationFn {} - } - } - impl KhrDedicatedAllocationFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDedicatedAllocationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtDebugUtilsFn { - set_debug_utils_object_name_ext: - extern "system" fn(device: Device, p_name_info: *const DebugUtilsObjectNameInfoEXT) - -> Result, - set_debug_utils_object_tag_ext: - extern "system" fn(device: Device, p_tag_info: *const DebugUtilsObjectTagInfoEXT) - -> Result, - queue_begin_debug_utils_label_ext: - extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, - queue_end_debug_utils_label_ext: extern "system" fn(queue: Queue) -> c_void, - queue_insert_debug_utils_label_ext: - extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, - cmd_begin_debug_utils_label_ext: - extern "system" fn( - command_buffer: CommandBuffer, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void, - cmd_end_debug_utils_label_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, - cmd_insert_debug_utils_label_ext: - extern "system" fn( - command_buffer: CommandBuffer, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void, - create_debug_utils_messenger_ext: - extern "system" fn( - instance: Instance, - p_create_info: *const DebugUtilsMessengerCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_messenger: *mut DebugUtilsMessengerEXT, - ) -> Result, - destroy_debug_utils_messenger_ext: - extern "system" fn( - instance: Instance, - messenger: DebugUtilsMessengerEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - submit_debug_utils_message_ext: - extern "system" fn( - instance: Instance, - message_severity: DebugUtilsMessageSeverityFlagsEXT, - message_types: DebugUtilsMessageTypeFlagsEXT, - p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, - ) -> c_void, - } - unsafe impl Send for ExtDebugUtilsFn {} - unsafe impl Sync for ExtDebugUtilsFn {} - impl ::std::clone::Clone for ExtDebugUtilsFn { - fn clone(&self) -> Self { - ExtDebugUtilsFn { - set_debug_utils_object_name_ext: self.set_debug_utils_object_name_ext, - set_debug_utils_object_tag_ext: self.set_debug_utils_object_tag_ext, - queue_begin_debug_utils_label_ext: self.queue_begin_debug_utils_label_ext, - queue_end_debug_utils_label_ext: self.queue_end_debug_utils_label_ext, - queue_insert_debug_utils_label_ext: self.queue_insert_debug_utils_label_ext, - cmd_begin_debug_utils_label_ext: self.cmd_begin_debug_utils_label_ext, - cmd_end_debug_utils_label_ext: self.cmd_end_debug_utils_label_ext, - cmd_insert_debug_utils_label_ext: self.cmd_insert_debug_utils_label_ext, - create_debug_utils_messenger_ext: self.create_debug_utils_messenger_ext, - destroy_debug_utils_messenger_ext: self.destroy_debug_utils_messenger_ext, - submit_debug_utils_message_ext: self.submit_debug_utils_message_ext, - } - } - } - impl ExtDebugUtilsFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDebugUtilsFn { - set_debug_utils_object_name_ext: unsafe { - let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - set_debug_utils_object_tag_ext: unsafe { - let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_begin_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_end_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - queue_insert_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_begin_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_end_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_insert_debug_utils_label_ext: unsafe { - let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - create_debug_utils_messenger_ext: unsafe { - let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_debug_utils_messenger_ext: unsafe { - let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - submit_debug_utils_message_ext: unsafe { - let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn set_debug_utils_object_name_ext( - &self, - device: Device, - p_name_info: *const DebugUtilsObjectNameInfoEXT, - ) -> Result { - (self.set_debug_utils_object_name_ext)(device, p_name_info) - } - pub unsafe fn set_debug_utils_object_tag_ext( - &self, - device: Device, - p_tag_info: *const DebugUtilsObjectTagInfoEXT, - ) -> Result { - (self.set_debug_utils_object_tag_ext)(device, p_tag_info) - } - pub unsafe fn queue_begin_debug_utils_label_ext( - &self, - queue: Queue, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.queue_begin_debug_utils_label_ext)(queue, p_label_info) - } - pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: Queue) -> c_void { - (self.queue_end_debug_utils_label_ext)(queue) - } - pub unsafe fn queue_insert_debug_utils_label_ext( - &self, - queue: Queue, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.queue_insert_debug_utils_label_ext)(queue, p_label_info) - } - pub unsafe fn cmd_begin_debug_utils_label_ext( - &self, - command_buffer: CommandBuffer, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.cmd_begin_debug_utils_label_ext)(command_buffer, p_label_info) - } - pub unsafe fn cmd_end_debug_utils_label_ext( - &self, - command_buffer: CommandBuffer, - ) -> c_void { - (self.cmd_end_debug_utils_label_ext)(command_buffer) - } - pub unsafe fn cmd_insert_debug_utils_label_ext( - &self, - command_buffer: CommandBuffer, - p_label_info: *const DebugUtilsLabelEXT, - ) -> c_void { - (self.cmd_insert_debug_utils_label_ext)(command_buffer, p_label_info) - } - pub unsafe fn create_debug_utils_messenger_ext( - &self, +} +pub struct ExtDebugUtilsFn { + set_debug_utils_object_name_ext: + extern "system" fn(device: Device, p_name_info: *const DebugUtilsObjectNameInfoEXT) + -> Result, + set_debug_utils_object_tag_ext: + extern "system" fn(device: Device, p_tag_info: *const DebugUtilsObjectTagInfoEXT) -> Result, + queue_begin_debug_utils_label_ext: + extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, + queue_end_debug_utils_label_ext: extern "system" fn(queue: Queue) -> c_void, + queue_insert_debug_utils_label_ext: + extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT) -> c_void, + cmd_begin_debug_utils_label_ext: + extern "system" fn(command_buffer: CommandBuffer, p_label_info: *const DebugUtilsLabelEXT) + -> c_void, + cmd_end_debug_utils_label_ext: extern "system" fn(command_buffer: CommandBuffer) -> c_void, + cmd_insert_debug_utils_label_ext: + extern "system" fn(command_buffer: CommandBuffer, p_label_info: *const DebugUtilsLabelEXT) + -> c_void, + create_debug_utils_messenger_ext: + extern "system" fn( instance: Instance, p_create_info: *const DebugUtilsMessengerCreateInfoEXT, p_allocator: *const AllocationCallbacks, p_messenger: *mut DebugUtilsMessengerEXT, - ) -> Result { - (self.create_debug_utils_messenger_ext)( - instance, - p_create_info, - p_allocator, - p_messenger, - ) - } - pub unsafe fn destroy_debug_utils_messenger_ext( - &self, - instance: Instance, - messenger: DebugUtilsMessengerEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_debug_utils_messenger_ext)(instance, messenger, p_allocator) - } - pub unsafe fn submit_debug_utils_message_ext( - &self, + ) -> Result, + destroy_debug_utils_messenger_ext: extern "system" fn( + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + submit_debug_utils_message_ext: + extern "system" fn( instance: Instance, message_severity: DebugUtilsMessageSeverityFlagsEXT, message_types: DebugUtilsMessageTypeFlagsEXT, p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, - ) -> c_void { - (self.submit_debug_utils_message_ext)( - instance, - message_severity, - message_types, - p_callback_data, - ) + ) -> c_void, +} +unsafe impl Send for ExtDebugUtilsFn {} +unsafe impl Sync for ExtDebugUtilsFn {} +impl ::std::clone::Clone for ExtDebugUtilsFn { + fn clone(&self) -> Self { + ExtDebugUtilsFn { + set_debug_utils_object_name_ext: self.set_debug_utils_object_name_ext, + set_debug_utils_object_tag_ext: self.set_debug_utils_object_tag_ext, + queue_begin_debug_utils_label_ext: self.queue_begin_debug_utils_label_ext, + queue_end_debug_utils_label_ext: self.queue_end_debug_utils_label_ext, + queue_insert_debug_utils_label_ext: self.queue_insert_debug_utils_label_ext, + cmd_begin_debug_utils_label_ext: self.cmd_begin_debug_utils_label_ext, + cmd_end_debug_utils_label_ext: self.cmd_end_debug_utils_label_ext, + cmd_insert_debug_utils_label_ext: self.cmd_insert_debug_utils_label_ext, + create_debug_utils_messenger_ext: self.create_debug_utils_messenger_ext, + destroy_debug_utils_messenger_ext: self.destroy_debug_utils_messenger_ext, + submit_debug_utils_message_ext: self.submit_debug_utils_message_ext, } } - #[doc = "Generated from \'VK_EXT_debug_utils\'"] - impl StructureType { - pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = StructureType(1000128000); - } - #[doc = "Generated from \'VK_EXT_debug_utils\'"] - impl StructureType { - pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = StructureType(1000128001); - } - #[doc = "Generated from \'VK_EXT_debug_utils\'"] - impl StructureType { - pub const DEBUG_UTILS_LABEL_EXT: Self = StructureType(1000128002); - } - #[doc = "Generated from \'VK_EXT_debug_utils\'"] - impl StructureType { - pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = StructureType(1000128003); - } - #[doc = "Generated from \'VK_EXT_debug_utils\'"] - impl StructureType { - pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = StructureType(1000128004); - } - #[doc = "Generated from \'VK_EXT_debug_utils\'"] - impl ObjectType { - pub const DEBUG_UTILS_MESSENGER_EXT: Self = ObjectType(1000128000); - } - pub struct AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: - extern "system" fn( - device: Device, - buffer: *const AHardwareBuffer, - p_properties: *mut AndroidHardwareBufferPropertiesANDROID, - ) -> Result, - get_memory_android_hardware_buffer_android: - extern "system" fn( - device: Device, - p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, - p_buffer: *mut *mut AHardwareBuffer, - ) -> Result, - } - unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {} - unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {} - impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { - fn clone(&self) -> Self { - AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: - self.get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: - self.get_memory_android_hardware_buffer_android, - } +} +impl ExtDebugUtilsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDebugUtilsFn { + set_debug_utils_object_name_ext: unsafe { + let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + set_debug_utils_object_tag_ext: unsafe { + let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_begin_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_end_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + queue_insert_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_begin_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_end_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_insert_debug_utils_label_ext: unsafe { + let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + create_debug_utils_messenger_ext: unsafe { + let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_debug_utils_messenger_ext: unsafe { + let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + submit_debug_utils_message_ext: unsafe { + let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl AndroidExternalMemoryAndroidHardwareBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: unsafe { - let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_memory_android_hardware_buffer_android: unsafe { - let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_android_hardware_buffer_properties_android( - &self, + pub unsafe fn set_debug_utils_object_name_ext( + &self, + device: Device, + p_name_info: *const DebugUtilsObjectNameInfoEXT, + ) -> Result { + (self.set_debug_utils_object_name_ext)(device, p_name_info) + } + pub unsafe fn set_debug_utils_object_tag_ext( + &self, + device: Device, + p_tag_info: *const DebugUtilsObjectTagInfoEXT, + ) -> Result { + (self.set_debug_utils_object_tag_ext)(device, p_tag_info) + } + pub unsafe fn queue_begin_debug_utils_label_ext( + &self, + queue: Queue, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.queue_begin_debug_utils_label_ext)(queue, p_label_info) + } + pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: Queue) -> c_void { + (self.queue_end_debug_utils_label_ext)(queue) + } + pub unsafe fn queue_insert_debug_utils_label_ext( + &self, + queue: Queue, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.queue_insert_debug_utils_label_ext)(queue, p_label_info) + } + pub unsafe fn cmd_begin_debug_utils_label_ext( + &self, + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.cmd_begin_debug_utils_label_ext)(command_buffer, p_label_info) + } + pub unsafe fn cmd_end_debug_utils_label_ext(&self, command_buffer: CommandBuffer) -> c_void { + (self.cmd_end_debug_utils_label_ext)(command_buffer) + } + pub unsafe fn cmd_insert_debug_utils_label_ext( + &self, + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + (self.cmd_insert_debug_utils_label_ext)(command_buffer, p_label_info) + } + pub unsafe fn create_debug_utils_messenger_ext( + &self, + instance: Instance, + p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_messenger: *mut DebugUtilsMessengerEXT, + ) -> Result { + (self.create_debug_utils_messenger_ext)(instance, p_create_info, p_allocator, p_messenger) + } + pub unsafe fn destroy_debug_utils_messenger_ext( + &self, + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_debug_utils_messenger_ext)(instance, messenger, p_allocator) + } + pub unsafe fn submit_debug_utils_message_ext( + &self, + instance: Instance, + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) -> c_void { + (self.submit_debug_utils_message_ext)( + instance, + message_severity, + message_types, + p_callback_data, + ) + } +} +#[doc = "Generated from \'VK_EXT_debug_utils\'"] +impl StructureType { + pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = StructureType(1000128000); +} +#[doc = "Generated from \'VK_EXT_debug_utils\'"] +impl StructureType { + pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = StructureType(1000128001); +} +#[doc = "Generated from \'VK_EXT_debug_utils\'"] +impl StructureType { + pub const DEBUG_UTILS_LABEL_EXT: Self = StructureType(1000128002); +} +#[doc = "Generated from \'VK_EXT_debug_utils\'"] +impl StructureType { + pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = StructureType(1000128003); +} +#[doc = "Generated from \'VK_EXT_debug_utils\'"] +impl StructureType { + pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = StructureType(1000128004); +} +#[doc = "Generated from \'VK_EXT_debug_utils\'"] +impl ObjectType { + pub const DEBUG_UTILS_MESSENGER_EXT: Self = ObjectType(1000128000); +} +pub struct AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: + extern "system" fn( device: Device, buffer: *const AHardwareBuffer, p_properties: *mut AndroidHardwareBufferPropertiesANDROID, - ) -> Result { - (self.get_android_hardware_buffer_properties_android)(device, buffer, p_properties) - } - pub unsafe fn get_memory_android_hardware_buffer_android( - &self, + ) -> Result, + get_memory_android_hardware_buffer_android: + extern "system" fn( device: Device, p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, p_buffer: *mut *mut AHardwareBuffer, - ) -> Result { - (self.get_memory_android_hardware_buffer_android)(device, p_info, p_buffer) + ) -> Result, +} +unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {} +unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {} +impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { + fn clone(&self) -> Self { + AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: + self.get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: self + .get_memory_android_hardware_buffer_android, } } - #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] - impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID: Self = - ExternalMemoryHandleTypeFlags(0b10000000000); - } - #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] - impl StructureType { - pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = StructureType(1000129000); - } - #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] - impl StructureType { - pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = StructureType(1000129001); - } - #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] - impl StructureType { - pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = - StructureType(1000129002); - } - #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] - impl StructureType { - pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = StructureType(1000129003); - } - #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] - impl StructureType { - pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = StructureType(1000129004); - } - #[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] - impl StructureType { - pub const EXTERNAL_FORMAT_ANDROID: Self = StructureType(1000129005); - } - pub struct ExtSamplerFilterMinmaxFn {} - unsafe impl Send for ExtSamplerFilterMinmaxFn {} - unsafe impl Sync for ExtSamplerFilterMinmaxFn {} - impl ::std::clone::Clone for ExtSamplerFilterMinmaxFn { - fn clone(&self) -> Self { - ExtSamplerFilterMinmaxFn {} +} +impl AndroidExternalMemoryAndroidHardwareBufferFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AndroidExternalMemoryAndroidHardwareBufferFn { + get_android_hardware_buffer_properties_android: unsafe { + let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_memory_android_hardware_buffer_android: unsafe { + let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtSamplerFilterMinmaxFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtSamplerFilterMinmaxFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + pub unsafe fn get_android_hardware_buffer_properties_android( + &self, + device: Device, + buffer: *const AHardwareBuffer, + p_properties: *mut AndroidHardwareBufferPropertiesANDROID, + ) -> Result { + (self.get_android_hardware_buffer_properties_android)(device, buffer, p_properties) + } + pub unsafe fn get_memory_android_hardware_buffer_android( + &self, + device: Device, + p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + p_buffer: *mut *mut AHardwareBuffer, + ) -> Result { + (self.get_memory_android_hardware_buffer_android)(device, p_info, p_buffer) + } +} +#[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] +impl ExternalMemoryHandleTypeFlags { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID: Self = + ExternalMemoryHandleTypeFlags(0b10000000000); +} +#[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] +impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = StructureType(1000129000); +} +#[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] +impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = StructureType(1000129001); +} +#[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] +impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = StructureType(1000129002); +} +#[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] +impl StructureType { + pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = StructureType(1000129003); +} +#[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] +impl StructureType { + pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = StructureType(1000129004); +} +#[doc = "Generated from \'VK_ANDROID_external_memory_android_hardware_buffer\'"] +impl StructureType { + pub const EXTERNAL_FORMAT_ANDROID: Self = StructureType(1000129005); +} +pub struct ExtSamplerFilterMinmaxFn {} +unsafe impl Send for ExtSamplerFilterMinmaxFn {} +unsafe impl Sync for ExtSamplerFilterMinmaxFn {} +impl ::std::clone::Clone for ExtSamplerFilterMinmaxFn { + fn clone(&self) -> Self { + ExtSamplerFilterMinmaxFn {} + } +} +impl ExtSamplerFilterMinmaxFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtSamplerFilterMinmaxFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self = - StructureType(1000130000); +} +#[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self = + StructureType(1000130000); +} +#[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] +impl StructureType { + pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self = StructureType(1000130001); +} +#[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = FormatFeatureFlags(0b10000000000000000); +} +pub struct KhrStorageBufferStorageClassFn {} +unsafe impl Send for KhrStorageBufferStorageClassFn {} +unsafe impl Sync for KhrStorageBufferStorageClassFn {} +impl ::std::clone::Clone for KhrStorageBufferStorageClassFn { + fn clone(&self) -> Self { + KhrStorageBufferStorageClassFn {} } - #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] - impl StructureType { - pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self = StructureType(1000130001); - } - #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] - impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = FormatFeatureFlags(0b10000000000000000); - } - pub struct KhrStorageBufferStorageClassFn {} - unsafe impl Send for KhrStorageBufferStorageClassFn {} - unsafe impl Sync for KhrStorageBufferStorageClassFn {} - impl ::std::clone::Clone for KhrStorageBufferStorageClassFn { - fn clone(&self) -> Self { - KhrStorageBufferStorageClassFn {} +} +impl KhrStorageBufferStorageClassFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrStorageBufferStorageClassFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrStorageBufferStorageClassFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrStorageBufferStorageClassFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct AmdGpuShaderInt16Fn {} +unsafe impl Send for AmdGpuShaderInt16Fn {} +unsafe impl Sync for AmdGpuShaderInt16Fn {} +impl ::std::clone::Clone for AmdGpuShaderInt16Fn { + fn clone(&self) -> Self { + AmdGpuShaderInt16Fn {} + } +} +impl AmdGpuShaderInt16Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdGpuShaderInt16Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct AmdGpuShaderInt16Fn {} - unsafe impl Send for AmdGpuShaderInt16Fn {} - unsafe impl Sync for AmdGpuShaderInt16Fn {} - impl ::std::clone::Clone for AmdGpuShaderInt16Fn { - fn clone(&self) -> Self { - AmdGpuShaderInt16Fn {} +} +pub struct AmdExtension134Fn {} +unsafe impl Send for AmdExtension134Fn {} +unsafe impl Sync for AmdExtension134Fn {} +impl ::std::clone::Clone for AmdExtension134Fn { + fn clone(&self) -> Self { + AmdExtension134Fn {} + } +} +impl AmdExtension134Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension134Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl AmdGpuShaderInt16Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdGpuShaderInt16Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct AmdExtension135Fn {} +unsafe impl Send for AmdExtension135Fn {} +unsafe impl Sync for AmdExtension135Fn {} +impl ::std::clone::Clone for AmdExtension135Fn { + fn clone(&self) -> Self { + AmdExtension135Fn {} + } +} +impl AmdExtension135Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension135Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct AmdExtension134Fn {} - unsafe impl Send for AmdExtension134Fn {} - unsafe impl Sync for AmdExtension134Fn {} - impl ::std::clone::Clone for AmdExtension134Fn { - fn clone(&self) -> Self { - AmdExtension134Fn {} +} +pub struct AmdExtension136Fn {} +unsafe impl Send for AmdExtension136Fn {} +unsafe impl Sync for AmdExtension136Fn {} +impl ::std::clone::Clone for AmdExtension136Fn { + fn clone(&self) -> Self { + AmdExtension136Fn {} + } +} +impl AmdExtension136Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension136Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl AmdExtension134Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension134Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct AmdMixedAttachmentSamplesFn {} +unsafe impl Send for AmdMixedAttachmentSamplesFn {} +unsafe impl Sync for AmdMixedAttachmentSamplesFn {} +impl ::std::clone::Clone for AmdMixedAttachmentSamplesFn { + fn clone(&self) -> Self { + AmdMixedAttachmentSamplesFn {} + } +} +impl AmdMixedAttachmentSamplesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdMixedAttachmentSamplesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct AmdExtension135Fn {} - unsafe impl Send for AmdExtension135Fn {} - unsafe impl Sync for AmdExtension135Fn {} - impl ::std::clone::Clone for AmdExtension135Fn { - fn clone(&self) -> Self { - AmdExtension135Fn {} +} +pub struct AmdShaderFragmentMaskFn {} +unsafe impl Send for AmdShaderFragmentMaskFn {} +unsafe impl Sync for AmdShaderFragmentMaskFn {} +impl ::std::clone::Clone for AmdShaderFragmentMaskFn { + fn clone(&self) -> Self { + AmdShaderFragmentMaskFn {} + } +} +impl AmdShaderFragmentMaskFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderFragmentMaskFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl AmdExtension135Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension135Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct AmdExtension139Fn {} +unsafe impl Send for AmdExtension139Fn {} +unsafe impl Sync for AmdExtension139Fn {} +impl ::std::clone::Clone for AmdExtension139Fn { + fn clone(&self) -> Self { + AmdExtension139Fn {} + } +} +impl AmdExtension139Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension139Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct AmdExtension136Fn {} - unsafe impl Send for AmdExtension136Fn {} - unsafe impl Sync for AmdExtension136Fn {} - impl ::std::clone::Clone for AmdExtension136Fn { - fn clone(&self) -> Self { - AmdExtension136Fn {} +} +pub struct AmdExtension140Fn {} +unsafe impl Send for AmdExtension140Fn {} +unsafe impl Sync for AmdExtension140Fn {} +impl ::std::clone::Clone for AmdExtension140Fn { + fn clone(&self) -> Self { + AmdExtension140Fn {} + } +} +impl AmdExtension140Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension140Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl AmdExtension136Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension136Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct ExtShaderStencilExportFn {} +unsafe impl Send for ExtShaderStencilExportFn {} +unsafe impl Sync for ExtShaderStencilExportFn {} +impl ::std::clone::Clone for ExtShaderStencilExportFn { + fn clone(&self) -> Self { + ExtShaderStencilExportFn {} + } +} +impl ExtShaderStencilExportFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderStencilExportFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct AmdMixedAttachmentSamplesFn {} - unsafe impl Send for AmdMixedAttachmentSamplesFn {} - unsafe impl Sync for AmdMixedAttachmentSamplesFn {} - impl ::std::clone::Clone for AmdMixedAttachmentSamplesFn { - fn clone(&self) -> Self { - AmdMixedAttachmentSamplesFn {} +} +pub struct AmdExtension142Fn {} +unsafe impl Send for AmdExtension142Fn {} +unsafe impl Sync for AmdExtension142Fn {} +impl ::std::clone::Clone for AmdExtension142Fn { + fn clone(&self) -> Self { + AmdExtension142Fn {} + } +} +impl AmdExtension142Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension142Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl AmdMixedAttachmentSamplesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdMixedAttachmentSamplesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct AmdExtension143Fn {} +unsafe impl Send for AmdExtension143Fn {} +unsafe impl Sync for AmdExtension143Fn {} +impl ::std::clone::Clone for AmdExtension143Fn { + fn clone(&self) -> Self { + AmdExtension143Fn {} + } +} +impl AmdExtension143Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension143Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct AmdShaderFragmentMaskFn {} - unsafe impl Send for AmdShaderFragmentMaskFn {} - unsafe impl Sync for AmdShaderFragmentMaskFn {} - impl ::std::clone::Clone for AmdShaderFragmentMaskFn { - fn clone(&self) -> Self { - AmdShaderFragmentMaskFn {} - } - } - impl AmdShaderFragmentMaskFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderFragmentMaskFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension139Fn {} - unsafe impl Send for AmdExtension139Fn {} - unsafe impl Sync for AmdExtension139Fn {} - impl ::std::clone::Clone for AmdExtension139Fn { - fn clone(&self) -> Self { - AmdExtension139Fn {} - } - } - impl AmdExtension139Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension139Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension140Fn {} - unsafe impl Send for AmdExtension140Fn {} - unsafe impl Sync for AmdExtension140Fn {} - impl ::std::clone::Clone for AmdExtension140Fn { - fn clone(&self) -> Self { - AmdExtension140Fn {} - } - } - impl AmdExtension140Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension140Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtShaderStencilExportFn {} - unsafe impl Send for ExtShaderStencilExportFn {} - unsafe impl Sync for ExtShaderStencilExportFn {} - impl ::std::clone::Clone for ExtShaderStencilExportFn { - fn clone(&self) -> Self { - ExtShaderStencilExportFn {} - } - } - impl ExtShaderStencilExportFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtShaderStencilExportFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension142Fn {} - unsafe impl Send for AmdExtension142Fn {} - unsafe impl Sync for AmdExtension142Fn {} - impl ::std::clone::Clone for AmdExtension142Fn { - fn clone(&self) -> Self { - AmdExtension142Fn {} - } - } - impl AmdExtension142Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension142Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension143Fn {} - unsafe impl Send for AmdExtension143Fn {} - unsafe impl Sync for AmdExtension143Fn {} - impl ::std::clone::Clone for AmdExtension143Fn { - fn clone(&self) -> Self { - AmdExtension143Fn {} - } - } - impl AmdExtension143Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension143Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtSampleLocationsFn { - cmd_set_sample_locations_ext: - extern "system" fn( - command_buffer: CommandBuffer, - p_sample_locations_info: *const SampleLocationsInfoEXT, - ) -> c_void, - get_physical_device_multisample_properties_ext: - extern "system" fn( - physical_device: PhysicalDevice, - samples: SampleCountFlags, - p_multisample_properties: *mut MultisamplePropertiesEXT, - ) -> c_void, - } - unsafe impl Send for ExtSampleLocationsFn {} - unsafe impl Sync for ExtSampleLocationsFn {} - impl ::std::clone::Clone for ExtSampleLocationsFn { - fn clone(&self) -> Self { - ExtSampleLocationsFn { - cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: - self.get_physical_device_multisample_properties_ext, - } - } - } - impl ExtSampleLocationsFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtSampleLocationsFn { - cmd_set_sample_locations_ext: unsafe { - let raw_name = stringify!(vkCmdSetSampleLocationsEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_physical_device_multisample_properties_ext: unsafe { - let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_set_sample_locations_ext( - &self, +} +pub struct ExtSampleLocationsFn { + cmd_set_sample_locations_ext: + extern "system" fn( command_buffer: CommandBuffer, p_sample_locations_info: *const SampleLocationsInfoEXT, - ) -> c_void { - (self.cmd_set_sample_locations_ext)(command_buffer, p_sample_locations_info) - } - pub unsafe fn get_physical_device_multisample_properties_ext( - &self, + ) -> c_void, + get_physical_device_multisample_properties_ext: + extern "system" fn( physical_device: PhysicalDevice, samples: SampleCountFlags, p_multisample_properties: *mut MultisamplePropertiesEXT, - ) -> c_void { - (self.get_physical_device_multisample_properties_ext)( - physical_device, - samples, - p_multisample_properties, - ) - } - } - #[doc = "Generated from \'VK_EXT_sample_locations\'"] - impl ImageCreateFlags { - pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT: Self = ImageCreateFlags(0b1000000000000); - } - #[doc = "Generated from \'VK_EXT_sample_locations\'"] - impl StructureType { - pub const SAMPLE_LOCATIONS_INFO_EXT: Self = StructureType(1000143000); - } - #[doc = "Generated from \'VK_EXT_sample_locations\'"] - impl StructureType { - pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = StructureType(1000143001); - } - #[doc = "Generated from \'VK_EXT_sample_locations\'"] - impl StructureType { - pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = StructureType(1000143002); - } - #[doc = "Generated from \'VK_EXT_sample_locations\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = StructureType(1000143003); - } - #[doc = "Generated from \'VK_EXT_sample_locations\'"] - impl StructureType { - pub const MULTISAMPLE_PROPERTIES_EXT: Self = StructureType(1000143004); - } - #[doc = "Generated from \'VK_EXT_sample_locations\'"] - impl DynamicState { - pub const SAMPLE_LOCATIONS_EXT: Self = DynamicState(1000143000); - } - pub struct KhrRelaxedBlockLayoutFn {} - unsafe impl Send for KhrRelaxedBlockLayoutFn {} - unsafe impl Sync for KhrRelaxedBlockLayoutFn {} - impl ::std::clone::Clone for KhrRelaxedBlockLayoutFn { - fn clone(&self) -> Self { - KhrRelaxedBlockLayoutFn {} - } - } - impl KhrRelaxedBlockLayoutFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrRelaxedBlockLayoutFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrGetMemoryRequirements2Fn {} - unsafe impl Send for KhrGetMemoryRequirements2Fn {} - unsafe impl Sync for KhrGetMemoryRequirements2Fn {} - impl ::std::clone::Clone for KhrGetMemoryRequirements2Fn { - fn clone(&self) -> Self { - KhrGetMemoryRequirements2Fn {} - } - } - impl KhrGetMemoryRequirements2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrGetMemoryRequirements2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrImageFormatListFn {} - unsafe impl Send for KhrImageFormatListFn {} - unsafe impl Sync for KhrImageFormatListFn {} - impl ::std::clone::Clone for KhrImageFormatListFn { - fn clone(&self) -> Self { - KhrImageFormatListFn {} - } - } - impl KhrImageFormatListFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrImageFormatListFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_KHR_image_format_list\'"] - impl StructureType { - pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = StructureType(1000147000); - } - pub struct ExtBlendOperationAdvancedFn {} - unsafe impl Send for ExtBlendOperationAdvancedFn {} - unsafe impl Sync for ExtBlendOperationAdvancedFn {} - impl ::std::clone::Clone for ExtBlendOperationAdvancedFn { - fn clone(&self) -> Self { - ExtBlendOperationAdvancedFn {} - } - } - impl ExtBlendOperationAdvancedFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtBlendOperationAdvancedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = - StructureType(1000148000); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = - StructureType(1000148001); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl StructureType { - pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = - StructureType(1000148002); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const ZERO_EXT: Self = BlendOp(1000148000); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const SRC_EXT: Self = BlendOp(1000148001); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const DST_EXT: Self = BlendOp(1000148002); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const SRC_OVER_EXT: Self = BlendOp(1000148003); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const DST_OVER_EXT: Self = BlendOp(1000148004); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const SRC_IN_EXT: Self = BlendOp(1000148005); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const DST_IN_EXT: Self = BlendOp(1000148006); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const SRC_OUT_EXT: Self = BlendOp(1000148007); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const DST_OUT_EXT: Self = BlendOp(1000148008); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const SRC_ATOP_EXT: Self = BlendOp(1000148009); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const DST_ATOP_EXT: Self = BlendOp(1000148010); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const XOR_EXT: Self = BlendOp(1000148011); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const MULTIPLY_EXT: Self = BlendOp(1000148012); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const SCREEN_EXT: Self = BlendOp(1000148013); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const OVERLAY_EXT: Self = BlendOp(1000148014); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const DARKEN_EXT: Self = BlendOp(1000148015); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const LIGHTEN_EXT: Self = BlendOp(1000148016); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const COLORDODGE_EXT: Self = BlendOp(1000148017); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const COLORBURN_EXT: Self = BlendOp(1000148018); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const HARDLIGHT_EXT: Self = BlendOp(1000148019); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const SOFTLIGHT_EXT: Self = BlendOp(1000148020); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const DIFFERENCE_EXT: Self = BlendOp(1000148021); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const EXCLUSION_EXT: Self = BlendOp(1000148022); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const INVERT_EXT: Self = BlendOp(1000148023); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const INVERT_RGB_EXT: Self = BlendOp(1000148024); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const LINEARDODGE_EXT: Self = BlendOp(1000148025); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const LINEARBURN_EXT: Self = BlendOp(1000148026); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const VIVIDLIGHT_EXT: Self = BlendOp(1000148027); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const LINEARLIGHT_EXT: Self = BlendOp(1000148028); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const PINLIGHT_EXT: Self = BlendOp(1000148029); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const HARDMIX_EXT: Self = BlendOp(1000148030); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const HSL_HUE_EXT: Self = BlendOp(1000148031); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const HSL_SATURATION_EXT: Self = BlendOp(1000148032); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const HSL_COLOR_EXT: Self = BlendOp(1000148033); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const HSL_LUMINOSITY_EXT: Self = BlendOp(1000148034); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const PLUS_EXT: Self = BlendOp(1000148035); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const PLUS_CLAMPED_EXT: Self = BlendOp(1000148036); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const PLUS_CLAMPED_ALPHA_EXT: Self = BlendOp(1000148037); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const PLUS_DARKER_EXT: Self = BlendOp(1000148038); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const MINUS_EXT: Self = BlendOp(1000148039); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const MINUS_CLAMPED_EXT: Self = BlendOp(1000148040); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const CONTRAST_EXT: Self = BlendOp(1000148041); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const INVERT_OVG_EXT: Self = BlendOp(1000148042); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const RED_EXT: Self = BlendOp(1000148043); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const GREEN_EXT: Self = BlendOp(1000148044); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl BlendOp { - pub const BLUE_EXT: Self = BlendOp(1000148045); - } - #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] - impl AccessFlags { - pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = AccessFlags(0b10000000000000000000); - } - pub struct NvFragmentCoverageToColorFn {} - unsafe impl Send for NvFragmentCoverageToColorFn {} - unsafe impl Sync for NvFragmentCoverageToColorFn {} - impl ::std::clone::Clone for NvFragmentCoverageToColorFn { - fn clone(&self) -> Self { - NvFragmentCoverageToColorFn {} - } - } - impl NvFragmentCoverageToColorFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvFragmentCoverageToColorFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_fragment_coverage_to_color\'"] - impl StructureType { - pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = StructureType(1000149000); - } - pub struct NvExtension151Fn {} - unsafe impl Send for NvExtension151Fn {} - unsafe impl Sync for NvExtension151Fn {} - impl ::std::clone::Clone for NvExtension151Fn { - fn clone(&self) -> Self { - NvExtension151Fn {} - } - } - impl NvExtension151Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension151Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension152Fn {} - unsafe impl Send for NvExtension152Fn {} - unsafe impl Sync for NvExtension152Fn {} - impl ::std::clone::Clone for NvExtension152Fn { - fn clone(&self) -> Self { - NvExtension152Fn {} - } - } - impl NvExtension152Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension152Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvFramebufferMixedSamplesFn {} - unsafe impl Send for NvFramebufferMixedSamplesFn {} - unsafe impl Sync for NvFramebufferMixedSamplesFn {} - impl ::std::clone::Clone for NvFramebufferMixedSamplesFn { - fn clone(&self) -> Self { - NvFramebufferMixedSamplesFn {} - } - } - impl NvFramebufferMixedSamplesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvFramebufferMixedSamplesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_framebuffer_mixed_samples\'"] - impl StructureType { - pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = - StructureType(1000152000); - } - pub struct NvFillRectangleFn {} - unsafe impl Send for NvFillRectangleFn {} - unsafe impl Sync for NvFillRectangleFn {} - impl ::std::clone::Clone for NvFillRectangleFn { - fn clone(&self) -> Self { - NvFillRectangleFn {} - } - } - impl NvFillRectangleFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvFillRectangleFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_fill_rectangle\'"] - impl PolygonMode { - pub const FILL_RECTANGLE_NV: Self = PolygonMode(1000153000); - } - pub struct NvExtension155Fn {} - unsafe impl Send for NvExtension155Fn {} - unsafe impl Sync for NvExtension155Fn {} - impl ::std::clone::Clone for NvExtension155Fn { - fn clone(&self) -> Self { - NvExtension155Fn {} - } - } - impl NvExtension155Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension155Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtPostDepthCoverageFn {} - unsafe impl Send for ExtPostDepthCoverageFn {} - unsafe impl Sync for ExtPostDepthCoverageFn {} - impl ::std::clone::Clone for ExtPostDepthCoverageFn { - fn clone(&self) -> Self { - ExtPostDepthCoverageFn {} - } - } - impl ExtPostDepthCoverageFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtPostDepthCoverageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrSamplerYcbcrConversionFn {} - unsafe impl Send for KhrSamplerYcbcrConversionFn {} - unsafe impl Sync for KhrSamplerYcbcrConversionFn {} - impl ::std::clone::Clone for KhrSamplerYcbcrConversionFn { - fn clone(&self) -> Self { - KhrSamplerYcbcrConversionFn {} - } - } - impl KhrSamplerYcbcrConversionFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrSamplerYcbcrConversionFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrBindMemory2Fn {} - unsafe impl Send for KhrBindMemory2Fn {} - unsafe impl Sync for KhrBindMemory2Fn {} - impl ::std::clone::Clone for KhrBindMemory2Fn { - fn clone(&self) -> Self { - KhrBindMemory2Fn {} - } - } - impl KhrBindMemory2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrBindMemory2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtExtension159Fn {} - unsafe impl Send for ExtExtension159Fn {} - unsafe impl Sync for ExtExtension159Fn {} - impl ::std::clone::Clone for ExtExtension159Fn { - fn clone(&self) -> Self { - ExtExtension159Fn {} - } - } - impl ExtExtension159Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension159Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtExtension160Fn {} - unsafe impl Send for ExtExtension160Fn {} - unsafe impl Sync for ExtExtension160Fn {} - impl ::std::clone::Clone for ExtExtension160Fn { - fn clone(&self) -> Self { - ExtExtension160Fn {} - } - } - impl ExtExtension160Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension160Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtValidationCacheFn { - create_validation_cache_ext: - extern "system" fn( - device: Device, - p_create_info: *const ValidationCacheCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_validation_cache: *mut ValidationCacheEXT, - ) -> Result, - destroy_validation_cache_ext: extern "system" fn( - device: Device, - validation_cache: ValidationCacheEXT, - p_allocator: *const AllocationCallbacks, ) -> c_void, - merge_validation_caches_ext: extern "system" fn( - device: Device, - dst_cache: ValidationCacheEXT, - src_cache_count: u32, - p_src_caches: *const ValidationCacheEXT, - ) -> Result, - get_validation_cache_data_ext: extern "system" fn( - device: Device, - validation_cache: ValidationCacheEXT, - p_data_size: *mut usize, - p_data: *mut c_void, - ) -> Result, - } - unsafe impl Send for ExtValidationCacheFn {} - unsafe impl Sync for ExtValidationCacheFn {} - impl ::std::clone::Clone for ExtValidationCacheFn { - fn clone(&self) -> Self { - ExtValidationCacheFn { - create_validation_cache_ext: self.create_validation_cache_ext, - destroy_validation_cache_ext: self.destroy_validation_cache_ext, - merge_validation_caches_ext: self.merge_validation_caches_ext, - get_validation_cache_data_ext: self.get_validation_cache_data_ext, - } +} +unsafe impl Send for ExtSampleLocationsFn {} +unsafe impl Sync for ExtSampleLocationsFn {} +impl ::std::clone::Clone for ExtSampleLocationsFn { + fn clone(&self) -> Self { + ExtSampleLocationsFn { + cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, + get_physical_device_multisample_properties_ext: + self.get_physical_device_multisample_properties_ext, } } - impl ExtValidationCacheFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtValidationCacheFn { - create_validation_cache_ext: unsafe { - let raw_name = stringify!(vkCreateValidationCacheEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - destroy_validation_cache_ext: unsafe { - let raw_name = stringify!(vkDestroyValidationCacheEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - merge_validation_caches_ext: unsafe { - let raw_name = stringify!(vkMergeValidationCachesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - get_validation_cache_data_ext: unsafe { - let raw_name = stringify!(vkGetValidationCacheDataEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +impl ExtSampleLocationsFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtSampleLocationsFn { + cmd_set_sample_locations_ext: unsafe { + let raw_name = stringify!(vkCmdSetSampleLocationsEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_physical_device_multisample_properties_ext: unsafe { + let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } - pub unsafe fn create_validation_cache_ext( - &self, + } + pub unsafe fn cmd_set_sample_locations_ext( + &self, + command_buffer: CommandBuffer, + p_sample_locations_info: *const SampleLocationsInfoEXT, + ) -> c_void { + (self.cmd_set_sample_locations_ext)(command_buffer, p_sample_locations_info) + } + pub unsafe fn get_physical_device_multisample_properties_ext( + &self, + physical_device: PhysicalDevice, + samples: SampleCountFlags, + p_multisample_properties: *mut MultisamplePropertiesEXT, + ) -> c_void { + (self.get_physical_device_multisample_properties_ext)( + physical_device, + samples, + p_multisample_properties, + ) + } +} +#[doc = "Generated from \'VK_EXT_sample_locations\'"] +impl ImageCreateFlags { + pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT: Self = ImageCreateFlags(0b1000000000000); +} +#[doc = "Generated from \'VK_EXT_sample_locations\'"] +impl StructureType { + pub const SAMPLE_LOCATIONS_INFO_EXT: Self = StructureType(1000143000); +} +#[doc = "Generated from \'VK_EXT_sample_locations\'"] +impl StructureType { + pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = StructureType(1000143001); +} +#[doc = "Generated from \'VK_EXT_sample_locations\'"] +impl StructureType { + pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = StructureType(1000143002); +} +#[doc = "Generated from \'VK_EXT_sample_locations\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = StructureType(1000143003); +} +#[doc = "Generated from \'VK_EXT_sample_locations\'"] +impl StructureType { + pub const MULTISAMPLE_PROPERTIES_EXT: Self = StructureType(1000143004); +} +#[doc = "Generated from \'VK_EXT_sample_locations\'"] +impl DynamicState { + pub const SAMPLE_LOCATIONS_EXT: Self = DynamicState(1000143000); +} +pub struct KhrRelaxedBlockLayoutFn {} +unsafe impl Send for KhrRelaxedBlockLayoutFn {} +unsafe impl Sync for KhrRelaxedBlockLayoutFn {} +impl ::std::clone::Clone for KhrRelaxedBlockLayoutFn { + fn clone(&self) -> Self { + KhrRelaxedBlockLayoutFn {} + } +} +impl KhrRelaxedBlockLayoutFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrRelaxedBlockLayoutFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrGetMemoryRequirements2Fn {} +unsafe impl Send for KhrGetMemoryRequirements2Fn {} +unsafe impl Sync for KhrGetMemoryRequirements2Fn {} +impl ::std::clone::Clone for KhrGetMemoryRequirements2Fn { + fn clone(&self) -> Self { + KhrGetMemoryRequirements2Fn {} + } +} +impl KhrGetMemoryRequirements2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrGetMemoryRequirements2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrImageFormatListFn {} +unsafe impl Send for KhrImageFormatListFn {} +unsafe impl Sync for KhrImageFormatListFn {} +impl ::std::clone::Clone for KhrImageFormatListFn { + fn clone(&self) -> Self { + KhrImageFormatListFn {} + } +} +impl KhrImageFormatListFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrImageFormatListFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_KHR_image_format_list\'"] +impl StructureType { + pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = StructureType(1000147000); +} +pub struct ExtBlendOperationAdvancedFn {} +unsafe impl Send for ExtBlendOperationAdvancedFn {} +unsafe impl Sync for ExtBlendOperationAdvancedFn {} +impl ::std::clone::Clone for ExtBlendOperationAdvancedFn { + fn clone(&self) -> Self { + ExtBlendOperationAdvancedFn {} + } +} +impl ExtBlendOperationAdvancedFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtBlendOperationAdvancedFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = + StructureType(1000148000); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = + StructureType(1000148001); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl StructureType { + pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = StructureType(1000148002); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const ZERO_EXT: Self = BlendOp(1000148000); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const SRC_EXT: Self = BlendOp(1000148001); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const DST_EXT: Self = BlendOp(1000148002); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const SRC_OVER_EXT: Self = BlendOp(1000148003); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const DST_OVER_EXT: Self = BlendOp(1000148004); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const SRC_IN_EXT: Self = BlendOp(1000148005); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const DST_IN_EXT: Self = BlendOp(1000148006); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const SRC_OUT_EXT: Self = BlendOp(1000148007); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const DST_OUT_EXT: Self = BlendOp(1000148008); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const SRC_ATOP_EXT: Self = BlendOp(1000148009); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const DST_ATOP_EXT: Self = BlendOp(1000148010); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const XOR_EXT: Self = BlendOp(1000148011); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const MULTIPLY_EXT: Self = BlendOp(1000148012); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const SCREEN_EXT: Self = BlendOp(1000148013); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const OVERLAY_EXT: Self = BlendOp(1000148014); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const DARKEN_EXT: Self = BlendOp(1000148015); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const LIGHTEN_EXT: Self = BlendOp(1000148016); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const COLORDODGE_EXT: Self = BlendOp(1000148017); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const COLORBURN_EXT: Self = BlendOp(1000148018); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const HARDLIGHT_EXT: Self = BlendOp(1000148019); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const SOFTLIGHT_EXT: Self = BlendOp(1000148020); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const DIFFERENCE_EXT: Self = BlendOp(1000148021); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const EXCLUSION_EXT: Self = BlendOp(1000148022); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const INVERT_EXT: Self = BlendOp(1000148023); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const INVERT_RGB_EXT: Self = BlendOp(1000148024); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const LINEARDODGE_EXT: Self = BlendOp(1000148025); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const LINEARBURN_EXT: Self = BlendOp(1000148026); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const VIVIDLIGHT_EXT: Self = BlendOp(1000148027); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const LINEARLIGHT_EXT: Self = BlendOp(1000148028); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const PINLIGHT_EXT: Self = BlendOp(1000148029); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const HARDMIX_EXT: Self = BlendOp(1000148030); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const HSL_HUE_EXT: Self = BlendOp(1000148031); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const HSL_SATURATION_EXT: Self = BlendOp(1000148032); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const HSL_COLOR_EXT: Self = BlendOp(1000148033); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const HSL_LUMINOSITY_EXT: Self = BlendOp(1000148034); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const PLUS_EXT: Self = BlendOp(1000148035); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const PLUS_CLAMPED_EXT: Self = BlendOp(1000148036); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const PLUS_CLAMPED_ALPHA_EXT: Self = BlendOp(1000148037); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const PLUS_DARKER_EXT: Self = BlendOp(1000148038); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const MINUS_EXT: Self = BlendOp(1000148039); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const MINUS_CLAMPED_EXT: Self = BlendOp(1000148040); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const CONTRAST_EXT: Self = BlendOp(1000148041); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const INVERT_OVG_EXT: Self = BlendOp(1000148042); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const RED_EXT: Self = BlendOp(1000148043); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const GREEN_EXT: Self = BlendOp(1000148044); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl BlendOp { + pub const BLUE_EXT: Self = BlendOp(1000148045); +} +#[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] +impl AccessFlags { + pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = AccessFlags(0b10000000000000000000); +} +pub struct NvFragmentCoverageToColorFn {} +unsafe impl Send for NvFragmentCoverageToColorFn {} +unsafe impl Sync for NvFragmentCoverageToColorFn {} +impl ::std::clone::Clone for NvFragmentCoverageToColorFn { + fn clone(&self) -> Self { + NvFragmentCoverageToColorFn {} + } +} +impl NvFragmentCoverageToColorFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvFragmentCoverageToColorFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_fragment_coverage_to_color\'"] +impl StructureType { + pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = StructureType(1000149000); +} +pub struct NvExtension151Fn {} +unsafe impl Send for NvExtension151Fn {} +unsafe impl Sync for NvExtension151Fn {} +impl ::std::clone::Clone for NvExtension151Fn { + fn clone(&self) -> Self { + NvExtension151Fn {} + } +} +impl NvExtension151Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension151Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension152Fn {} +unsafe impl Send for NvExtension152Fn {} +unsafe impl Sync for NvExtension152Fn {} +impl ::std::clone::Clone for NvExtension152Fn { + fn clone(&self) -> Self { + NvExtension152Fn {} + } +} +impl NvExtension152Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension152Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvFramebufferMixedSamplesFn {} +unsafe impl Send for NvFramebufferMixedSamplesFn {} +unsafe impl Sync for NvFramebufferMixedSamplesFn {} +impl ::std::clone::Clone for NvFramebufferMixedSamplesFn { + fn clone(&self) -> Self { + NvFramebufferMixedSamplesFn {} + } +} +impl NvFramebufferMixedSamplesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvFramebufferMixedSamplesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_framebuffer_mixed_samples\'"] +impl StructureType { + pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = StructureType(1000152000); +} +pub struct NvFillRectangleFn {} +unsafe impl Send for NvFillRectangleFn {} +unsafe impl Sync for NvFillRectangleFn {} +impl ::std::clone::Clone for NvFillRectangleFn { + fn clone(&self) -> Self { + NvFillRectangleFn {} + } +} +impl NvFillRectangleFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvFillRectangleFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_fill_rectangle\'"] +impl PolygonMode { + pub const FILL_RECTANGLE_NV: Self = PolygonMode(1000153000); +} +pub struct NvExtension155Fn {} +unsafe impl Send for NvExtension155Fn {} +unsafe impl Sync for NvExtension155Fn {} +impl ::std::clone::Clone for NvExtension155Fn { + fn clone(&self) -> Self { + NvExtension155Fn {} + } +} +impl NvExtension155Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension155Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtPostDepthCoverageFn {} +unsafe impl Send for ExtPostDepthCoverageFn {} +unsafe impl Sync for ExtPostDepthCoverageFn {} +impl ::std::clone::Clone for ExtPostDepthCoverageFn { + fn clone(&self) -> Self { + ExtPostDepthCoverageFn {} + } +} +impl ExtPostDepthCoverageFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtPostDepthCoverageFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrSamplerYcbcrConversionFn {} +unsafe impl Send for KhrSamplerYcbcrConversionFn {} +unsafe impl Sync for KhrSamplerYcbcrConversionFn {} +impl ::std::clone::Clone for KhrSamplerYcbcrConversionFn { + fn clone(&self) -> Self { + KhrSamplerYcbcrConversionFn {} + } +} +impl KhrSamplerYcbcrConversionFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrSamplerYcbcrConversionFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrBindMemory2Fn {} +unsafe impl Send for KhrBindMemory2Fn {} +unsafe impl Sync for KhrBindMemory2Fn {} +impl ::std::clone::Clone for KhrBindMemory2Fn { + fn clone(&self) -> Self { + KhrBindMemory2Fn {} + } +} +impl KhrBindMemory2Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrBindMemory2Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtExtension159Fn {} +unsafe impl Send for ExtExtension159Fn {} +unsafe impl Sync for ExtExtension159Fn {} +impl ::std::clone::Clone for ExtExtension159Fn { + fn clone(&self) -> Self { + ExtExtension159Fn {} + } +} +impl ExtExtension159Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension159Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtExtension160Fn {} +unsafe impl Send for ExtExtension160Fn {} +unsafe impl Sync for ExtExtension160Fn {} +impl ::std::clone::Clone for ExtExtension160Fn { + fn clone(&self) -> Self { + ExtExtension160Fn {} + } +} +impl ExtExtension160Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension160Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtValidationCacheFn { + create_validation_cache_ext: + extern "system" fn( device: Device, p_create_info: *const ValidationCacheCreateInfoEXT, p_allocator: *const AllocationCallbacks, p_validation_cache: *mut ValidationCacheEXT, - ) -> Result { - (self.create_validation_cache_ext)( - device, - p_create_info, - p_allocator, - p_validation_cache, - ) - } - pub unsafe fn destroy_validation_cache_ext( - &self, - device: Device, - validation_cache: ValidationCacheEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator) - } - pub unsafe fn merge_validation_caches_ext( - &self, - device: Device, - dst_cache: ValidationCacheEXT, - src_cache_count: u32, - p_src_caches: *const ValidationCacheEXT, - ) -> Result { - (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) - } - pub unsafe fn get_validation_cache_data_ext( - &self, - device: Device, - validation_cache: ValidationCacheEXT, - p_data_size: *mut usize, - p_data: *mut c_void, - ) -> Result { - (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) + ) -> Result, + destroy_validation_cache_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + merge_validation_caches_ext: extern "system" fn( + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: u32, + p_src_caches: *const ValidationCacheEXT, + ) -> Result, + get_validation_cache_data_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *mut usize, + p_data: *mut c_void, + ) -> Result, +} +unsafe impl Send for ExtValidationCacheFn {} +unsafe impl Sync for ExtValidationCacheFn {} +impl ::std::clone::Clone for ExtValidationCacheFn { + fn clone(&self) -> Self { + ExtValidationCacheFn { + create_validation_cache_ext: self.create_validation_cache_ext, + destroy_validation_cache_ext: self.destroy_validation_cache_ext, + merge_validation_caches_ext: self.merge_validation_caches_ext, + get_validation_cache_data_ext: self.get_validation_cache_data_ext, } } - #[doc = "Generated from \'VK_EXT_validation_cache\'"] - impl StructureType { - pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = StructureType(1000160000); - } - #[doc = "Generated from \'VK_EXT_validation_cache\'"] - impl StructureType { - pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = StructureType(1000160001); - } - #[doc = "Generated from \'VK_EXT_validation_cache\'"] - impl ObjectType { - pub const VALIDATION_CACHE_EXT: Self = ObjectType(1000160000); - } - pub struct ExtDescriptorIndexingFn {} - unsafe impl Send for ExtDescriptorIndexingFn {} - unsafe impl Sync for ExtDescriptorIndexingFn {} - impl ::std::clone::Clone for ExtDescriptorIndexingFn { - fn clone(&self) -> Self { - ExtDescriptorIndexingFn {} +} +impl ExtValidationCacheFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtValidationCacheFn { + create_validation_cache_ext: unsafe { + let raw_name = stringify!(vkCreateValidationCacheEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + destroy_validation_cache_ext: unsafe { + let raw_name = stringify!(vkDestroyValidationCacheEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + merge_validation_caches_ext: unsafe { + let raw_name = stringify!(vkMergeValidationCachesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + get_validation_cache_data_ext: unsafe { + let raw_name = stringify!(vkGetValidationCacheDataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtDescriptorIndexingFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtDescriptorIndexingFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + pub unsafe fn create_validation_cache_ext( + &self, + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *mut ValidationCacheEXT, + ) -> Result { + (self.create_validation_cache_ext)(device, p_create_info, p_allocator, p_validation_cache) + } + pub unsafe fn destroy_validation_cache_ext( + &self, + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator) + } + pub unsafe fn merge_validation_caches_ext( + &self, + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: u32, + p_src_caches: *const ValidationCacheEXT, + ) -> Result { + (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) + } + pub unsafe fn get_validation_cache_data_ext( + &self, + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *mut usize, + p_data: *mut c_void, + ) -> Result { + (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) + } +} +#[doc = "Generated from \'VK_EXT_validation_cache\'"] +impl StructureType { + pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = StructureType(1000160000); +} +#[doc = "Generated from \'VK_EXT_validation_cache\'"] +impl StructureType { + pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = StructureType(1000160001); +} +#[doc = "Generated from \'VK_EXT_validation_cache\'"] +impl ObjectType { + pub const VALIDATION_CACHE_EXT: Self = ObjectType(1000160000); +} +pub struct ExtDescriptorIndexingFn {} +unsafe impl Send for ExtDescriptorIndexingFn {} +unsafe impl Sync for ExtDescriptorIndexingFn {} +impl ::std::clone::Clone for ExtDescriptorIndexingFn { + fn clone(&self) -> Self { + ExtDescriptorIndexingFn {} + } +} +impl ExtDescriptorIndexingFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtDescriptorIndexingFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl StructureType { - pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = - StructureType(1000161000); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = StructureType(1000161000); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = StructureType(1000161001); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = StructureType(1000161002); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = + StructureType(1000161003); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = + StructureType(1000161004); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorPoolCreateFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorPoolCreateFlags(0b10); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorSetLayoutCreateFlags { + pub const UPDATE_AFTER_BIND_POOL_EXT: Self = DescriptorSetLayoutCreateFlags(0b10); +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl Result { + pub const ERROR_FRAGMENTATION_EXT: Self = Result(-1000161000); +} +pub struct ExtShaderViewportIndexLayerFn {} +unsafe impl Send for ExtShaderViewportIndexLayerFn {} +unsafe impl Sync for ExtShaderViewportIndexLayerFn {} +impl ::std::clone::Clone for ExtShaderViewportIndexLayerFn { + fn clone(&self) -> Self { + ExtShaderViewportIndexLayerFn {} } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = - StructureType(1000161001); - } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = - StructureType(1000161002); - } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl StructureType { - pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = - StructureType(1000161003); - } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl StructureType { - pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = - StructureType(1000161004); - } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl DescriptorPoolCreateFlags { - pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorPoolCreateFlags(0b10); - } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl DescriptorSetLayoutCreateFlags { - pub const UPDATE_AFTER_BIND_POOL_EXT: Self = DescriptorSetLayoutCreateFlags(0b10); - } - #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] - impl Result { - pub const ERROR_FRAGMENTATION_EXT: Self = Result(-1000161000); - } - pub struct ExtShaderViewportIndexLayerFn {} - unsafe impl Send for ExtShaderViewportIndexLayerFn {} - unsafe impl Sync for ExtShaderViewportIndexLayerFn {} - impl ::std::clone::Clone for ExtShaderViewportIndexLayerFn { - fn clone(&self) -> Self { - ExtShaderViewportIndexLayerFn {} +} +impl ExtShaderViewportIndexLayerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtShaderViewportIndexLayerFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl ExtShaderViewportIndexLayerFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtShaderViewportIndexLayerFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct NvExtension164Fn {} +unsafe impl Send for NvExtension164Fn {} +unsafe impl Sync for NvExtension164Fn {} +impl ::std::clone::Clone for NvExtension164Fn { + fn clone(&self) -> Self { + NvExtension164Fn {} + } +} +impl NvExtension164Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension164Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvExtension164Fn {} - unsafe impl Send for NvExtension164Fn {} - unsafe impl Sync for NvExtension164Fn {} - impl ::std::clone::Clone for NvExtension164Fn { - fn clone(&self) -> Self { - NvExtension164Fn {} +} +pub struct NvExtension165Fn {} +unsafe impl Send for NvExtension165Fn {} +unsafe impl Sync for NvExtension165Fn {} +impl ::std::clone::Clone for NvExtension165Fn { + fn clone(&self) -> Self { + NvExtension165Fn {} + } +} +impl NvExtension165Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension165Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension164Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension164Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct NvExtension166Fn {} +unsafe impl Send for NvExtension166Fn {} +unsafe impl Sync for NvExtension166Fn {} +impl ::std::clone::Clone for NvExtension166Fn { + fn clone(&self) -> Self { + NvExtension166Fn {} + } +} +impl NvExtension166Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension166Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvExtension165Fn {} - unsafe impl Send for NvExtension165Fn {} - unsafe impl Sync for NvExtension165Fn {} - impl ::std::clone::Clone for NvExtension165Fn { - fn clone(&self) -> Self { - NvExtension165Fn {} +} +pub struct NvExtension167Fn {} +unsafe impl Send for NvExtension167Fn {} +unsafe impl Sync for NvExtension167Fn {} +impl ::std::clone::Clone for NvExtension167Fn { + fn clone(&self) -> Self { + NvExtension167Fn {} + } +} +impl NvExtension167Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension167Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension165Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension165Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct NvExtension168Fn {} +unsafe impl Send for NvExtension168Fn {} +unsafe impl Sync for NvExtension168Fn {} +impl ::std::clone::Clone for NvExtension168Fn { + fn clone(&self) -> Self { + NvExtension168Fn {} + } +} +impl NvExtension168Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension168Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvExtension166Fn {} - unsafe impl Send for NvExtension166Fn {} - unsafe impl Sync for NvExtension166Fn {} - impl ::std::clone::Clone for NvExtension166Fn { - fn clone(&self) -> Self { - NvExtension166Fn {} +} +pub struct KhrMaintenance3Fn {} +unsafe impl Send for KhrMaintenance3Fn {} +unsafe impl Sync for KhrMaintenance3Fn {} +impl ::std::clone::Clone for KhrMaintenance3Fn { + fn clone(&self) -> Self { + KhrMaintenance3Fn {} + } +} +impl KhrMaintenance3Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrMaintenance3Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension166Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension166Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void, + cmd_draw_indexed_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void, +} +unsafe impl Send for KhrDrawIndirectCountFn {} +unsafe impl Sync for KhrDrawIndirectCountFn {} +impl ::std::clone::Clone for KhrDrawIndirectCountFn { + fn clone(&self) -> Self { + KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: self.cmd_draw_indirect_count_khr, + cmd_draw_indexed_indirect_count_khr: self.cmd_draw_indexed_indirect_count_khr, } } - pub struct NvExtension167Fn {} - unsafe impl Send for NvExtension167Fn {} - unsafe impl Sync for NvExtension167Fn {} - impl ::std::clone::Clone for NvExtension167Fn { - fn clone(&self) -> Self { - NvExtension167Fn {} +} +impl KhrDrawIndirectCountFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: unsafe { + let raw_name = stringify!(vkCmdDrawIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + cmd_draw_indexed_indirect_count_khr: unsafe { + let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension167Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension167Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + pub unsafe fn cmd_draw_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + pub unsafe fn cmd_draw_indexed_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_indexed_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } +} +pub struct QcomExtension171Fn {} +unsafe impl Send for QcomExtension171Fn {} +unsafe impl Sync for QcomExtension171Fn {} +impl ::std::clone::Clone for QcomExtension171Fn { + fn clone(&self) -> Self { + QcomExtension171Fn {} + } +} +impl QcomExtension171Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension171Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct NvExtension168Fn {} - unsafe impl Send for NvExtension168Fn {} - unsafe impl Sync for NvExtension168Fn {} - impl ::std::clone::Clone for NvExtension168Fn { - fn clone(&self) -> Self { - NvExtension168Fn {} +} +pub struct QcomExtension172Fn {} +unsafe impl Send for QcomExtension172Fn {} +unsafe impl Sync for QcomExtension172Fn {} +impl ::std::clone::Clone for QcomExtension172Fn { + fn clone(&self) -> Self { + QcomExtension172Fn {} + } +} +impl QcomExtension172Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension172Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl NvExtension168Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension168Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct QcomExtension173Fn {} +unsafe impl Send for QcomExtension173Fn {} +unsafe impl Sync for QcomExtension173Fn {} +impl ::std::clone::Clone for QcomExtension173Fn { + fn clone(&self) -> Self { + QcomExtension173Fn {} + } +} +impl QcomExtension173Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension173Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct KhrMaintenance3Fn {} - unsafe impl Send for KhrMaintenance3Fn {} - unsafe impl Sync for KhrMaintenance3Fn {} - impl ::std::clone::Clone for KhrMaintenance3Fn { - fn clone(&self) -> Self { - KhrMaintenance3Fn {} +} +pub struct QcomExtension174Fn {} +unsafe impl Send for QcomExtension174Fn {} +unsafe impl Sync for QcomExtension174Fn {} +impl ::std::clone::Clone for QcomExtension174Fn { + fn clone(&self) -> Self { + QcomExtension174Fn {} + } +} +impl QcomExtension174Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = QcomExtension174Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrMaintenance3Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrMaintenance3Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } +} +pub struct ExtGlobalPriorityFn {} +unsafe impl Send for ExtGlobalPriorityFn {} +unsafe impl Sync for ExtGlobalPriorityFn {} +impl ::std::clone::Clone for ExtGlobalPriorityFn { + fn clone(&self) -> Self { + ExtGlobalPriorityFn {} + } +} +impl ExtGlobalPriorityFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtGlobalPriorityFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void, - cmd_draw_indexed_indirect_count_khr: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void, +} +#[doc = "Generated from \'VK_EXT_global_priority\'"] +impl StructureType { + pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = StructureType(1000174000); +} +#[doc = "Generated from \'VK_EXT_global_priority\'"] +impl Result { + pub const ERROR_NOT_PERMITTED_EXT: Self = Result(-1000174001); +} +pub struct ExtExtension176Fn {} +unsafe impl Send for ExtExtension176Fn {} +unsafe impl Sync for ExtExtension176Fn {} +impl ::std::clone::Clone for ExtExtension176Fn { + fn clone(&self) -> Self { + ExtExtension176Fn {} } - unsafe impl Send for KhrDrawIndirectCountFn {} - unsafe impl Sync for KhrDrawIndirectCountFn {} - impl ::std::clone::Clone for KhrDrawIndirectCountFn { - fn clone(&self) -> Self { - KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: self.cmd_draw_indirect_count_khr, - cmd_draw_indexed_indirect_count_khr: self.cmd_draw_indexed_indirect_count_khr, - } +} +impl ExtExtension176Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension176Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl KhrDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: unsafe { - let raw_name = stringify!(vkCmdDrawIndirectCountKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - cmd_draw_indexed_indirect_count_khr: unsafe { - let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_draw_indirect_count_khr( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void { - (self.cmd_draw_indirect_count_khr)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) - } - pub unsafe fn cmd_draw_indexed_indirect_count_khr( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void { - (self.cmd_draw_indexed_indirect_count_khr)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) +} +pub struct ExtExtension177Fn {} +unsafe impl Send for ExtExtension177Fn {} +unsafe impl Sync for ExtExtension177Fn {} +impl ::std::clone::Clone for ExtExtension177Fn { + fn clone(&self) -> Self { + ExtExtension177Fn {} + } +} +impl ExtExtension177Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension177Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - pub struct QcomExtension171Fn {} - unsafe impl Send for QcomExtension171Fn {} - unsafe impl Sync for QcomExtension171Fn {} - impl ::std::clone::Clone for QcomExtension171Fn { - fn clone(&self) -> Self { - QcomExtension171Fn {} +} +pub struct ExtExtension178Fn {} +unsafe impl Send for ExtExtension178Fn {} +unsafe impl Sync for ExtExtension178Fn {} +impl ::std::clone::Clone for ExtExtension178Fn { + fn clone(&self) -> Self { + ExtExtension178Fn {} + } +} +impl ExtExtension178Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension178Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) } } - impl QcomExtension171Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = QcomExtension171Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct QcomExtension172Fn {} - unsafe impl Send for QcomExtension172Fn {} - unsafe impl Sync for QcomExtension172Fn {} - impl ::std::clone::Clone for QcomExtension172Fn { - fn clone(&self) -> Self { - QcomExtension172Fn {} - } - } - impl QcomExtension172Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = QcomExtension172Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct QcomExtension173Fn {} - unsafe impl Send for QcomExtension173Fn {} - unsafe impl Sync for QcomExtension173Fn {} - impl ::std::clone::Clone for QcomExtension173Fn { - fn clone(&self) -> Self { - QcomExtension173Fn {} - } - } - impl QcomExtension173Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = QcomExtension173Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct QcomExtension174Fn {} - unsafe impl Send for QcomExtension174Fn {} - unsafe impl Sync for QcomExtension174Fn {} - impl ::std::clone::Clone for QcomExtension174Fn { - fn clone(&self) -> Self { - QcomExtension174Fn {} - } - } - impl QcomExtension174Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = QcomExtension174Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtGlobalPriorityFn {} - unsafe impl Send for ExtGlobalPriorityFn {} - unsafe impl Sync for ExtGlobalPriorityFn {} - impl ::std::clone::Clone for ExtGlobalPriorityFn { - fn clone(&self) -> Self { - ExtGlobalPriorityFn {} - } - } - impl ExtGlobalPriorityFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtGlobalPriorityFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_EXT_global_priority\'"] - impl StructureType { - pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = StructureType(1000174000); - } - #[doc = "Generated from \'VK_EXT_global_priority\'"] - impl Result { - pub const ERROR_NOT_PERMITTED_EXT: Self = Result(-1000174001); - } - pub struct ExtExtension176Fn {} - unsafe impl Send for ExtExtension176Fn {} - unsafe impl Sync for ExtExtension176Fn {} - impl ::std::clone::Clone for ExtExtension176Fn { - fn clone(&self) -> Self { - ExtExtension176Fn {} - } - } - impl ExtExtension176Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension176Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtExtension177Fn {} - unsafe impl Send for ExtExtension177Fn {} - unsafe impl Sync for ExtExtension177Fn {} - impl ::std::clone::Clone for ExtExtension177Fn { - fn clone(&self) -> Self { - ExtExtension177Fn {} - } - } - impl ExtExtension177Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension177Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtExtension178Fn {} - unsafe impl Send for ExtExtension178Fn {} - unsafe impl Sync for ExtExtension178Fn {} - impl ::std::clone::Clone for ExtExtension178Fn { - fn clone(&self) -> Self { - ExtExtension178Fn {} - } - } - impl ExtExtension178Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension178Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , p_host_pointer : *const c_void , p_memory_host_pointer_properties : *mut MemoryHostPointerPropertiesEXT , ) -> Result , } - unsafe impl Send for ExtExternalMemoryHostFn {} - unsafe impl Sync for ExtExternalMemoryHostFn {} - impl ::std::clone::Clone for ExtExternalMemoryHostFn { - fn clone(&self) -> Self { - ExtExternalMemoryHostFn { - get_memory_host_pointer_properties_ext: self.get_memory_host_pointer_properties_ext, - } - } - } - impl ExtExternalMemoryHostFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExternalMemoryHostFn { - get_memory_host_pointer_properties_ext: unsafe { - let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn get_memory_host_pointer_properties_ext( - &self, +} +pub struct ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: + extern "system" fn( device: Device, handle_type: ExternalMemoryHandleTypeFlags, p_host_pointer: *const c_void, p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, - ) -> Result { - (self.get_memory_host_pointer_properties_ext)( - device, - handle_type, - p_host_pointer, - p_memory_host_pointer_properties, - ) - } - } - #[doc = "Generated from \'VK_EXT_external_memory_host\'"] - impl StructureType { - pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = StructureType(1000178000); - } - #[doc = "Generated from \'VK_EXT_external_memory_host\'"] - impl StructureType { - pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = StructureType(1000178001); - } - #[doc = "Generated from \'VK_EXT_external_memory_host\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = - StructureType(1000178002); - } - #[doc = "Generated from \'VK_EXT_external_memory_host\'"] - impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION: Self = - ExternalMemoryHandleTypeFlags(0b10000000); - } - #[doc = "Generated from \'VK_EXT_external_memory_host\'"] - impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY: Self = - ExternalMemoryHandleTypeFlags(0b100000000); - } - pub struct AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: extern "system" fn( - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - dst_buffer: Buffer, - dst_offset: DeviceSize, - marker: u32, - ) -> c_void, - } - unsafe impl Send for AmdBufferMarkerFn {} - unsafe impl Sync for AmdBufferMarkerFn {} - impl ::std::clone::Clone for AmdBufferMarkerFn { - fn clone(&self) -> Self { - AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: self.cmd_write_buffer_marker_amd, - } - } - } - impl AmdBufferMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: unsafe { - let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - _err_str.push(raw_name); - } - ::std::mem::transmute(val) - }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - pub unsafe fn cmd_write_buffer_marker_amd( - &self, - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - dst_buffer: Buffer, - dst_offset: DeviceSize, - marker: u32, - ) -> c_void { - (self.cmd_write_buffer_marker_amd)( - command_buffer, - pipeline_stage, - dst_buffer, - dst_offset, - marker, - ) - } - } - pub struct AmdExtension181Fn {} - unsafe impl Send for AmdExtension181Fn {} - unsafe impl Sync for AmdExtension181Fn {} - impl ::std::clone::Clone for AmdExtension181Fn { - fn clone(&self) -> Self { - AmdExtension181Fn {} - } - } - impl AmdExtension181Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension181Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension182Fn {} - unsafe impl Send for AmdExtension182Fn {} - unsafe impl Sync for AmdExtension182Fn {} - impl ::std::clone::Clone for AmdExtension182Fn { - fn clone(&self) -> Self { - AmdExtension182Fn {} - } - } - impl AmdExtension182Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension182Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension183Fn {} - unsafe impl Send for AmdExtension183Fn {} - unsafe impl Sync for AmdExtension183Fn {} - impl ::std::clone::Clone for AmdExtension183Fn { - fn clone(&self) -> Self { - AmdExtension183Fn {} - } - } - impl AmdExtension183Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension183Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension184Fn {} - unsafe impl Send for AmdExtension184Fn {} - unsafe impl Sync for AmdExtension184Fn {} - impl ::std::clone::Clone for AmdExtension184Fn { - fn clone(&self) -> Self { - AmdExtension184Fn {} - } - } - impl AmdExtension184Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension184Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension185Fn {} - unsafe impl Send for AmdExtension185Fn {} - unsafe impl Sync for AmdExtension185Fn {} - impl ::std::clone::Clone for AmdExtension185Fn { - fn clone(&self) -> Self { - AmdExtension185Fn {} - } - } - impl AmdExtension185Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension185Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdShaderCorePropertiesFn {} - unsafe impl Send for AmdShaderCorePropertiesFn {} - unsafe impl Sync for AmdShaderCorePropertiesFn {} - impl ::std::clone::Clone for AmdShaderCorePropertiesFn { - fn clone(&self) -> Self { - AmdShaderCorePropertiesFn {} - } - } - impl AmdShaderCorePropertiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdShaderCorePropertiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_AMD_shader_core_properties\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = StructureType(1000185000); - } - pub struct AmdExtension187Fn {} - unsafe impl Send for AmdExtension187Fn {} - unsafe impl Sync for AmdExtension187Fn {} - impl ::std::clone::Clone for AmdExtension187Fn { - fn clone(&self) -> Self { - AmdExtension187Fn {} - } - } - impl AmdExtension187Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension187Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension188Fn {} - unsafe impl Send for AmdExtension188Fn {} - unsafe impl Sync for AmdExtension188Fn {} - impl ::std::clone::Clone for AmdExtension188Fn { - fn clone(&self) -> Self { - AmdExtension188Fn {} - } - } - impl AmdExtension188Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension188Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension189Fn {} - unsafe impl Send for AmdExtension189Fn {} - unsafe impl Sync for AmdExtension189Fn {} - impl ::std::clone::Clone for AmdExtension189Fn { - fn clone(&self) -> Self { - AmdExtension189Fn {} - } - } - impl AmdExtension189Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension189Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct AmdExtension190Fn {} - unsafe impl Send for AmdExtension190Fn {} - unsafe impl Sync for AmdExtension190Fn {} - impl ::std::clone::Clone for AmdExtension190Fn { - fn clone(&self) -> Self { - AmdExtension190Fn {} - } - } - impl AmdExtension190Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = AmdExtension190Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtVertexAttributeDivisorFn {} - unsafe impl Send for ExtVertexAttributeDivisorFn {} - unsafe impl Sync for ExtVertexAttributeDivisorFn {} - impl ::std::clone::Clone for ExtVertexAttributeDivisorFn { - fn clone(&self) -> Self { - ExtVertexAttributeDivisorFn {} - } - } - impl ExtVertexAttributeDivisorFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtVertexAttributeDivisorFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = - StructureType(1000190000); - } - #[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] - impl StructureType { - pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = - StructureType(1000190001); - } - pub struct GoogleExtension192Fn {} - unsafe impl Send for GoogleExtension192Fn {} - unsafe impl Sync for GoogleExtension192Fn {} - impl ::std::clone::Clone for GoogleExtension192Fn { - fn clone(&self) -> Self { - GoogleExtension192Fn {} - } - } - impl GoogleExtension192Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleExtension192Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct GoogleExtension193Fn {} - unsafe impl Send for GoogleExtension193Fn {} - unsafe impl Sync for GoogleExtension193Fn {} - impl ::std::clone::Clone for GoogleExtension193Fn { - fn clone(&self) -> Self { - GoogleExtension193Fn {} - } - } - impl GoogleExtension193Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleExtension193Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct GoogleExtension194Fn {} - unsafe impl Send for GoogleExtension194Fn {} - unsafe impl Sync for GoogleExtension194Fn {} - impl ::std::clone::Clone for GoogleExtension194Fn { - fn clone(&self) -> Self { - GoogleExtension194Fn {} - } - } - impl GoogleExtension194Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleExtension194Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct GoogleExtension195Fn {} - unsafe impl Send for GoogleExtension195Fn {} - unsafe impl Sync for GoogleExtension195Fn {} - impl ::std::clone::Clone for GoogleExtension195Fn { - fn clone(&self) -> Self { - GoogleExtension195Fn {} - } - } - impl GoogleExtension195Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleExtension195Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct GoogleExtension196Fn {} - unsafe impl Send for GoogleExtension196Fn {} - unsafe impl Sync for GoogleExtension196Fn {} - impl ::std::clone::Clone for GoogleExtension196Fn { - fn clone(&self) -> Self { - GoogleExtension196Fn {} - } - } - impl GoogleExtension196Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = GoogleExtension196Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ExtExtension197Fn {} - unsafe impl Send for ExtExtension197Fn {} - unsafe impl Sync for ExtExtension197Fn {} - impl ::std::clone::Clone for ExtExtension197Fn { - fn clone(&self) -> Self { - ExtExtension197Fn {} - } - } - impl ExtExtension197Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ExtExtension197Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct ArmExtension198Fn {} - unsafe impl Send for ArmExtension198Fn {} - unsafe impl Sync for ArmExtension198Fn {} - impl ::std::clone::Clone for ArmExtension198Fn { - fn clone(&self) -> Self { - ArmExtension198Fn {} - } - } - impl ArmExtension198Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = ArmExtension198Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvShaderSubgroupPartitionedFn {} - unsafe impl Send for NvShaderSubgroupPartitionedFn {} - unsafe impl Sync for NvShaderSubgroupPartitionedFn {} - impl ::std::clone::Clone for NvShaderSubgroupPartitionedFn { - fn clone(&self) -> Self { - NvShaderSubgroupPartitionedFn {} - } - } - impl NvShaderSubgroupPartitionedFn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvShaderSubgroupPartitionedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_NV_shader_subgroup_partitioned\'"] - impl SubgroupFeatureFlags { - pub const PARTITIONED_NV: Self = SubgroupFeatureFlags(0b100000000); - } - pub struct KhrExtension200Fn {} - unsafe impl Send for KhrExtension200Fn {} - unsafe impl Sync for KhrExtension200Fn {} - impl ::std::clone::Clone for KhrExtension200Fn { - fn clone(&self) -> Self { - KhrExtension200Fn {} - } - } - impl KhrExtension200Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension200Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExtension201Fn {} - unsafe impl Send for KhrExtension201Fn {} - unsafe impl Sync for KhrExtension201Fn {} - impl ::std::clone::Clone for KhrExtension201Fn { - fn clone(&self) -> Self { - KhrExtension201Fn {} - } - } - impl KhrExtension201Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension201Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension202Fn {} - unsafe impl Send for NvExtension202Fn {} - unsafe impl Sync for NvExtension202Fn {} - impl ::std::clone::Clone for NvExtension202Fn { - fn clone(&self) -> Self { - NvExtension202Fn {} - } - } - impl NvExtension202Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension202Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension203Fn {} - unsafe impl Send for NvExtension203Fn {} - unsafe impl Sync for NvExtension203Fn {} - impl ::std::clone::Clone for NvExtension203Fn { - fn clone(&self) -> Self { - NvExtension203Fn {} - } - } - impl NvExtension203Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension203Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension204Fn {} - unsafe impl Send for NvExtension204Fn {} - unsafe impl Sync for NvExtension204Fn {} - impl ::std::clone::Clone for NvExtension204Fn { - fn clone(&self) -> Self { - NvExtension204Fn {} - } - } - impl NvExtension204Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension204Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension205Fn {} - unsafe impl Send for NvExtension205Fn {} - unsafe impl Sync for NvExtension205Fn {} - impl ::std::clone::Clone for NvExtension205Fn { - fn clone(&self) -> Self { - NvExtension205Fn {} - } - } - impl NvExtension205Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension205Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension206Fn {} - unsafe impl Send for NvExtension206Fn {} - unsafe impl Sync for NvExtension206Fn {} - impl ::std::clone::Clone for NvExtension206Fn { - fn clone(&self) -> Self { - NvExtension206Fn {} - } - } - impl NvExtension206Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension206Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct NvExtension207Fn {} - unsafe impl Send for NvExtension207Fn {} - unsafe impl Sync for NvExtension207Fn {} - impl ::std::clone::Clone for NvExtension207Fn { - fn clone(&self) -> Self { - NvExtension207Fn {} - } - } - impl NvExtension207Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = NvExtension207Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExtension208Fn {} - unsafe impl Send for KhrExtension208Fn {} - unsafe impl Sync for KhrExtension208Fn {} - impl ::std::clone::Clone for KhrExtension208Fn { - fn clone(&self) -> Self { - KhrExtension208Fn {} - } - } - impl KhrExtension208Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension208Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExtension209Fn {} - unsafe impl Send for KhrExtension209Fn {} - unsafe impl Sync for KhrExtension209Fn {} - impl ::std::clone::Clone for KhrExtension209Fn { - fn clone(&self) -> Self { - KhrExtension209Fn {} - } - } - impl KhrExtension209Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension209Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct IntelExtension210Fn {} - unsafe impl Send for IntelExtension210Fn {} - unsafe impl Sync for IntelExtension210Fn {} - impl ::std::clone::Clone for IntelExtension210Fn { - fn clone(&self) -> Self { - IntelExtension210Fn {} - } - } - impl IntelExtension210Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = IntelExtension210Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct IntelExtension211Fn {} - unsafe impl Send for IntelExtension211Fn {} - unsafe impl Sync for IntelExtension211Fn {} - impl ::std::clone::Clone for IntelExtension211Fn { - fn clone(&self) -> Self { - IntelExtension211Fn {} - } - } - impl IntelExtension211Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = IntelExtension211Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - pub struct KhrExtension212Fn {} - unsafe impl Send for KhrExtension212Fn {} - unsafe impl Sync for KhrExtension212Fn {} - impl ::std::clone::Clone for KhrExtension212Fn { - fn clone(&self) -> Self { - KhrExtension212Fn {} - } - } - impl KhrExtension212Fn { - pub fn load(mut _f: F) -> ::std::result::Result> - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - let mut _err_str = Vec::new(); - let s = KhrExtension212Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } - } - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = StructureType(1000094000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const BIND_BUFFER_MEMORY_INFO: Self = StructureType(1000157000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const BIND_IMAGE_MEMORY_INFO: Self = StructureType(1000157001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageCreateFlags { - pub const ALIAS: Self = ImageCreateFlags(0b10000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = StructureType(1000083000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const MEMORY_DEDICATED_REQUIREMENTS: Self = StructureType(1000127000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = StructureType(1000127001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = StructureType(1000060000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = StructureType(1000060003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = StructureType(1000060004); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DEVICE_GROUP_SUBMIT_INFO: Self = StructureType(1000060005); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = StructureType(1000060006); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl PipelineCreateFlags { - pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = PipelineCreateFlags(0b1000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl PipelineCreateFlags { - pub const DISPATCH_BASE: Self = PipelineCreateFlags(0b10000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl DependencyFlags { - pub const DEVICE_GROUP: Self = DependencyFlags(0b100); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1000060013); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1000060014); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageCreateFlags { - pub const SPLIT_INSTANCE_BIND_REGIONS: Self = ImageCreateFlags(0b1000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = StructureType(1000070000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = StructureType(1000070001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl MemoryHeapFlags { - pub const MULTI_INSTANCE: Self = MemoryHeapFlags(0b10); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const MEMORY_REQUIREMENTS_2: Self = StructureType(1000146003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = StructureType(1000146004); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_FEATURES_2: Self = StructureType(1000059000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = StructureType(1000059001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const FORMAT_PROPERTIES_2: Self = StructureType(1000059002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1000059003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = StructureType(1000059004); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const QUEUE_FAMILY_PROPERTIES_2: Self = StructureType(1000059005); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = StructureType(1000059006); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1000059007); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = StructureType(1000059008); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Result { - pub const ERROR_OUT_OF_POOL_MEMORY: Self = Result(-1000069000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const TRANSFER_SRC: Self = FormatFeatureFlags(0b100000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const TRANSFER_DST: Self = FormatFeatureFlags(0b1000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageCreateFlags { - pub const TYPE_2D_ARRAY_COMPATIBLE: Self = ImageCreateFlags(0b100000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageCreateFlags { - pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = ImageCreateFlags(0b10000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageCreateFlags { - pub const EXTENDED_USAGE: Self = ImageCreateFlags(0b100000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = StructureType(1000117000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = StructureType(1000117001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = StructureType(1000117002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = - StructureType(1000117003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageLayout { - pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(1000117000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageLayout { - pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(1000117001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = StructureType(1000053000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = StructureType(1000053001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = StructureType(1000053002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl DependencyFlags { - pub const VIEW_LOCAL: Self = DependencyFlags(0b10); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = StructureType(1000120000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PROTECTED_SUBMIT_INFO: Self = StructureType(1000145000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = StructureType(1000145001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = StructureType(1000145002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DEVICE_QUEUE_INFO_2: Self = StructureType(1000145003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl QueueFlags { - pub const PROTECTED: Self = QueueFlags(0b10000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl DeviceQueueCreateFlags { - pub const PROTECTED: Self = DeviceQueueCreateFlags(0b1); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl MemoryPropertyFlags { - pub const PROTECTED: Self = MemoryPropertyFlags(0b100000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl BufferCreateFlags { - pub const PROTECTED: Self = BufferCreateFlags(0b1000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageCreateFlags { - pub const PROTECTED: Self = ImageCreateFlags(0b100000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl CommandPoolCreateFlags { - pub const PROTECTED: Self = CommandPoolCreateFlags(0b100); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = StructureType(1000156000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = StructureType(1000156001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = StructureType(1000156002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = StructureType(1000156003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = - StructureType(1000156004); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = - StructureType(1000156005); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ObjectType { - pub const SAMPLER_YCBCR_CONVERSION: Self = ObjectType(1000156000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G8B8G8R8_422_UNORM: Self = Format(1000156000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const B8G8R8G8_422_UNORM: Self = Format(1000156001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G8_B8_R8_3PLANE_420_UNORM: Self = Format(1000156002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G8_B8R8_2PLANE_420_UNORM: Self = Format(1000156003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G8_B8_R8_3PLANE_422_UNORM: Self = Format(1000156004); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G8_B8R8_2PLANE_422_UNORM: Self = Format(1000156005); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G8_B8_R8_3PLANE_444_UNORM: Self = Format(1000156006); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const R10X6_UNORM_PACK16: Self = Format(1000156007); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const R10X6G10X6_UNORM_2PACK16: Self = Format(1000156008); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Format(1000156009); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Format(1000156010); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Format(1000156011); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Format(1000156012); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Format(1000156013); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Format(1000156014); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Format(1000156015); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Format(1000156016); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const R12X4_UNORM_PACK16: Self = Format(1000156017); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const R12X4G12X4_UNORM_2PACK16: Self = Format(1000156018); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Format(1000156019); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Format(1000156020); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Format(1000156021); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Format(1000156022); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Format(1000156023); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Format(1000156024); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Format(1000156025); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Format(1000156026); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G16B16G16R16_422_UNORM: Self = Format(1000156027); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const B16G16R16G16_422_UNORM: Self = Format(1000156028); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G16_B16_R16_3PLANE_420_UNORM: Self = Format(1000156029); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G16_B16R16_2PLANE_420_UNORM: Self = Format(1000156030); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G16_B16_R16_3PLANE_422_UNORM: Self = Format(1000156031); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G16_B16R16_2PLANE_422_UNORM: Self = Format(1000156032); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Format { - pub const G16_B16_R16_3PLANE_444_UNORM: Self = Format(1000156033); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageAspectFlags { - pub const PLANE_0: Self = ImageAspectFlags(0b10000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageAspectFlags { - pub const PLANE_1: Self = ImageAspectFlags(0b100000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageAspectFlags { - pub const PLANE_2: Self = ImageAspectFlags(0b1000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ImageCreateFlags { - pub const DISJOINT: Self = ImageCreateFlags(0b1000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const MIDPOINT_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b100000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = - FormatFeatureFlags(0b1000000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = - FormatFeatureFlags(0b10000000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = - FormatFeatureFlags(0b100000000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = - FormatFeatureFlags(0b1000000000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const DISJOINT: Self = FormatFeatureFlags(0b10000000000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl FormatFeatureFlags { - pub const COSITED_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b100000000000000000000000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = StructureType(1000085000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl ObjectType { - pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = ObjectType(1000085000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = StructureType(1000071000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1000071001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = StructureType(1000071002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXTERNAL_BUFFER_PROPERTIES: Self = StructureType(1000071003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = StructureType(1000071004); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = StructureType(1000072000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = StructureType(1000072001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = StructureType(1000072002); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl Result { - pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Result(-1000072003); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = StructureType(1000112000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXTERNAL_FENCE_PROPERTIES: Self = StructureType(1000112001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXPORT_FENCE_CREATE_INFO: Self = StructureType(1000113000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = StructureType(1000077000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = StructureType(1000076000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = StructureType(1000076001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = StructureType(1000168000); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = StructureType(1000168001); - } - #[doc = "Generated from \'VK_VERSION_1_1\'"] - impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = StructureType(1000063000); - } + ) -> Result, +} +unsafe impl Send for ExtExternalMemoryHostFn {} +unsafe impl Sync for ExtExternalMemoryHostFn {} +impl ::std::clone::Clone for ExtExternalMemoryHostFn { + fn clone(&self) -> Self { + ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: self.get_memory_host_pointer_properties_ext, + } + } +} +impl ExtExternalMemoryHostFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: unsafe { + let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn get_memory_host_pointer_properties_ext( + &self, + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result { + (self.get_memory_host_pointer_properties_ext)( + device, + handle_type, + p_host_pointer, + p_memory_host_pointer_properties, + ) + } +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl StructureType { + pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = StructureType(1000178000); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl StructureType { + pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = StructureType(1000178001); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = StructureType(1000178002); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl ExternalMemoryHandleTypeFlags { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION: Self = + ExternalMemoryHandleTypeFlags(0b10000000); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl ExternalMemoryHandleTypeFlags { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY: Self = + ExternalMemoryHandleTypeFlags(0b100000000); +} +pub struct AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, + ) -> c_void, +} +unsafe impl Send for AmdBufferMarkerFn {} +unsafe impl Sync for AmdBufferMarkerFn {} +impl ::std::clone::Clone for AmdBufferMarkerFn { + fn clone(&self) -> Self { + AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: self.cmd_write_buffer_marker_amd, + } + } +} +impl AmdBufferMarkerFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: unsafe { + let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + _err_str.push(raw_name); + } + ::std::mem::transmute(val) + }, + }; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } + pub unsafe fn cmd_write_buffer_marker_amd( + &self, + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, + ) -> c_void { + (self.cmd_write_buffer_marker_amd)( + command_buffer, + pipeline_stage, + dst_buffer, + dst_offset, + marker, + ) + } +} +pub struct AmdExtension181Fn {} +unsafe impl Send for AmdExtension181Fn {} +unsafe impl Sync for AmdExtension181Fn {} +impl ::std::clone::Clone for AmdExtension181Fn { + fn clone(&self) -> Self { + AmdExtension181Fn {} + } +} +impl AmdExtension181Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension181Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension182Fn {} +unsafe impl Send for AmdExtension182Fn {} +unsafe impl Sync for AmdExtension182Fn {} +impl ::std::clone::Clone for AmdExtension182Fn { + fn clone(&self) -> Self { + AmdExtension182Fn {} + } +} +impl AmdExtension182Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension182Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension183Fn {} +unsafe impl Send for AmdExtension183Fn {} +unsafe impl Sync for AmdExtension183Fn {} +impl ::std::clone::Clone for AmdExtension183Fn { + fn clone(&self) -> Self { + AmdExtension183Fn {} + } +} +impl AmdExtension183Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension183Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension184Fn {} +unsafe impl Send for AmdExtension184Fn {} +unsafe impl Sync for AmdExtension184Fn {} +impl ::std::clone::Clone for AmdExtension184Fn { + fn clone(&self) -> Self { + AmdExtension184Fn {} + } +} +impl AmdExtension184Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension184Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension185Fn {} +unsafe impl Send for AmdExtension185Fn {} +unsafe impl Sync for AmdExtension185Fn {} +impl ::std::clone::Clone for AmdExtension185Fn { + fn clone(&self) -> Self { + AmdExtension185Fn {} + } +} +impl AmdExtension185Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension185Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdShaderCorePropertiesFn {} +unsafe impl Send for AmdShaderCorePropertiesFn {} +unsafe impl Sync for AmdShaderCorePropertiesFn {} +impl ::std::clone::Clone for AmdShaderCorePropertiesFn { + fn clone(&self) -> Self { + AmdShaderCorePropertiesFn {} + } +} +impl AmdShaderCorePropertiesFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdShaderCorePropertiesFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_AMD_shader_core_properties\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = StructureType(1000185000); +} +pub struct AmdExtension187Fn {} +unsafe impl Send for AmdExtension187Fn {} +unsafe impl Sync for AmdExtension187Fn {} +impl ::std::clone::Clone for AmdExtension187Fn { + fn clone(&self) -> Self { + AmdExtension187Fn {} + } +} +impl AmdExtension187Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension187Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension188Fn {} +unsafe impl Send for AmdExtension188Fn {} +unsafe impl Sync for AmdExtension188Fn {} +impl ::std::clone::Clone for AmdExtension188Fn { + fn clone(&self) -> Self { + AmdExtension188Fn {} + } +} +impl AmdExtension188Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension188Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension189Fn {} +unsafe impl Send for AmdExtension189Fn {} +unsafe impl Sync for AmdExtension189Fn {} +impl ::std::clone::Clone for AmdExtension189Fn { + fn clone(&self) -> Self { + AmdExtension189Fn {} + } +} +impl AmdExtension189Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension189Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct AmdExtension190Fn {} +unsafe impl Send for AmdExtension190Fn {} +unsafe impl Sync for AmdExtension190Fn {} +impl ::std::clone::Clone for AmdExtension190Fn { + fn clone(&self) -> Self { + AmdExtension190Fn {} + } +} +impl AmdExtension190Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = AmdExtension190Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtVertexAttributeDivisorFn {} +unsafe impl Send for ExtVertexAttributeDivisorFn {} +unsafe impl Sync for ExtVertexAttributeDivisorFn {} +impl ::std::clone::Clone for ExtVertexAttributeDivisorFn { + fn clone(&self) -> Self { + ExtVertexAttributeDivisorFn {} + } +} +impl ExtVertexAttributeDivisorFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtVertexAttributeDivisorFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = + StructureType(1000190000); +} +#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +impl StructureType { + pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = StructureType(1000190001); +} +pub struct GoogleExtension192Fn {} +unsafe impl Send for GoogleExtension192Fn {} +unsafe impl Sync for GoogleExtension192Fn {} +impl ::std::clone::Clone for GoogleExtension192Fn { + fn clone(&self) -> Self { + GoogleExtension192Fn {} + } +} +impl GoogleExtension192Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension192Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct GoogleExtension193Fn {} +unsafe impl Send for GoogleExtension193Fn {} +unsafe impl Sync for GoogleExtension193Fn {} +impl ::std::clone::Clone for GoogleExtension193Fn { + fn clone(&self) -> Self { + GoogleExtension193Fn {} + } +} +impl GoogleExtension193Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension193Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct GoogleExtension194Fn {} +unsafe impl Send for GoogleExtension194Fn {} +unsafe impl Sync for GoogleExtension194Fn {} +impl ::std::clone::Clone for GoogleExtension194Fn { + fn clone(&self) -> Self { + GoogleExtension194Fn {} + } +} +impl GoogleExtension194Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension194Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct GoogleExtension195Fn {} +unsafe impl Send for GoogleExtension195Fn {} +unsafe impl Sync for GoogleExtension195Fn {} +impl ::std::clone::Clone for GoogleExtension195Fn { + fn clone(&self) -> Self { + GoogleExtension195Fn {} + } +} +impl GoogleExtension195Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension195Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct GoogleExtension196Fn {} +unsafe impl Send for GoogleExtension196Fn {} +unsafe impl Sync for GoogleExtension196Fn {} +impl ::std::clone::Clone for GoogleExtension196Fn { + fn clone(&self) -> Self { + GoogleExtension196Fn {} + } +} +impl GoogleExtension196Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = GoogleExtension196Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ExtExtension197Fn {} +unsafe impl Send for ExtExtension197Fn {} +unsafe impl Sync for ExtExtension197Fn {} +impl ::std::clone::Clone for ExtExtension197Fn { + fn clone(&self) -> Self { + ExtExtension197Fn {} + } +} +impl ExtExtension197Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ExtExtension197Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct ArmExtension198Fn {} +unsafe impl Send for ArmExtension198Fn {} +unsafe impl Sync for ArmExtension198Fn {} +impl ::std::clone::Clone for ArmExtension198Fn { + fn clone(&self) -> Self { + ArmExtension198Fn {} + } +} +impl ArmExtension198Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = ArmExtension198Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvShaderSubgroupPartitionedFn {} +unsafe impl Send for NvShaderSubgroupPartitionedFn {} +unsafe impl Sync for NvShaderSubgroupPartitionedFn {} +impl ::std::clone::Clone for NvShaderSubgroupPartitionedFn { + fn clone(&self) -> Self { + NvShaderSubgroupPartitionedFn {} + } +} +impl NvShaderSubgroupPartitionedFn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvShaderSubgroupPartitionedFn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_NV_shader_subgroup_partitioned\'"] +impl SubgroupFeatureFlags { + pub const PARTITIONED_NV: Self = SubgroupFeatureFlags(0b100000000); +} +pub struct KhrExtension200Fn {} +unsafe impl Send for KhrExtension200Fn {} +unsafe impl Sync for KhrExtension200Fn {} +impl ::std::clone::Clone for KhrExtension200Fn { + fn clone(&self) -> Self { + KhrExtension200Fn {} + } +} +impl KhrExtension200Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension200Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExtension201Fn {} +unsafe impl Send for KhrExtension201Fn {} +unsafe impl Sync for KhrExtension201Fn {} +impl ::std::clone::Clone for KhrExtension201Fn { + fn clone(&self) -> Self { + KhrExtension201Fn {} + } +} +impl KhrExtension201Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension201Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension202Fn {} +unsafe impl Send for NvExtension202Fn {} +unsafe impl Sync for NvExtension202Fn {} +impl ::std::clone::Clone for NvExtension202Fn { + fn clone(&self) -> Self { + NvExtension202Fn {} + } +} +impl NvExtension202Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension202Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension203Fn {} +unsafe impl Send for NvExtension203Fn {} +unsafe impl Sync for NvExtension203Fn {} +impl ::std::clone::Clone for NvExtension203Fn { + fn clone(&self) -> Self { + NvExtension203Fn {} + } +} +impl NvExtension203Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension203Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension204Fn {} +unsafe impl Send for NvExtension204Fn {} +unsafe impl Sync for NvExtension204Fn {} +impl ::std::clone::Clone for NvExtension204Fn { + fn clone(&self) -> Self { + NvExtension204Fn {} + } +} +impl NvExtension204Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension204Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension205Fn {} +unsafe impl Send for NvExtension205Fn {} +unsafe impl Sync for NvExtension205Fn {} +impl ::std::clone::Clone for NvExtension205Fn { + fn clone(&self) -> Self { + NvExtension205Fn {} + } +} +impl NvExtension205Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension205Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension206Fn {} +unsafe impl Send for NvExtension206Fn {} +unsafe impl Sync for NvExtension206Fn {} +impl ::std::clone::Clone for NvExtension206Fn { + fn clone(&self) -> Self { + NvExtension206Fn {} + } +} +impl NvExtension206Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension206Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct NvExtension207Fn {} +unsafe impl Send for NvExtension207Fn {} +unsafe impl Sync for NvExtension207Fn {} +impl ::std::clone::Clone for NvExtension207Fn { + fn clone(&self) -> Self { + NvExtension207Fn {} + } +} +impl NvExtension207Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = NvExtension207Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExtension208Fn {} +unsafe impl Send for KhrExtension208Fn {} +unsafe impl Sync for KhrExtension208Fn {} +impl ::std::clone::Clone for KhrExtension208Fn { + fn clone(&self) -> Self { + KhrExtension208Fn {} + } +} +impl KhrExtension208Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension208Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExtension209Fn {} +unsafe impl Send for KhrExtension209Fn {} +unsafe impl Sync for KhrExtension209Fn {} +impl ::std::clone::Clone for KhrExtension209Fn { + fn clone(&self) -> Self { + KhrExtension209Fn {} + } +} +impl KhrExtension209Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension209Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct IntelExtension210Fn {} +unsafe impl Send for IntelExtension210Fn {} +unsafe impl Sync for IntelExtension210Fn {} +impl ::std::clone::Clone for IntelExtension210Fn { + fn clone(&self) -> Self { + IntelExtension210Fn {} + } +} +impl IntelExtension210Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = IntelExtension210Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct IntelExtension211Fn {} +unsafe impl Send for IntelExtension211Fn {} +unsafe impl Sync for IntelExtension211Fn {} +impl ::std::clone::Clone for IntelExtension211Fn { + fn clone(&self) -> Self { + IntelExtension211Fn {} + } +} +impl IntelExtension211Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = IntelExtension211Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +pub struct KhrExtension212Fn {} +unsafe impl Send for KhrExtension212Fn {} +unsafe impl Sync for KhrExtension212Fn {} +impl ::std::clone::Clone for KhrExtension212Fn { + fn clone(&self) -> Self { + KhrExtension212Fn {} + } +} +impl KhrExtension212Fn { + pub fn load(mut _f: F) -> ::std::result::Result> + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + let mut _err_str = Vec::new(); + let s = KhrExtension212Fn {}; + if _err_str.is_empty() { + Ok(s) + } else { + Err(_err_str) + } + } +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = StructureType(1000094000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const BIND_BUFFER_MEMORY_INFO: Self = StructureType(1000157000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const BIND_IMAGE_MEMORY_INFO: Self = StructureType(1000157001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageCreateFlags { + pub const ALIAS: Self = ImageCreateFlags(0b10000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = StructureType(1000083000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const MEMORY_DEDICATED_REQUIREMENTS: Self = StructureType(1000127000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = StructureType(1000127001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = StructureType(1000060000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = StructureType(1000060003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = StructureType(1000060004); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DEVICE_GROUP_SUBMIT_INFO: Self = StructureType(1000060005); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = StructureType(1000060006); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl PipelineCreateFlags { + pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = PipelineCreateFlags(0b1000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl PipelineCreateFlags { + pub const DISPATCH_BASE: Self = PipelineCreateFlags(0b10000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl DependencyFlags { + pub const DEVICE_GROUP: Self = DependencyFlags(0b100); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1000060013); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1000060014); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageCreateFlags { + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = ImageCreateFlags(0b1000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = StructureType(1000070000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = StructureType(1000070001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl MemoryHeapFlags { + pub const MULTI_INSTANCE: Self = MemoryHeapFlags(0b10); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1000146002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const MEMORY_REQUIREMENTS_2: Self = StructureType(1000146003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = StructureType(1000146004); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FEATURES_2: Self = StructureType(1000059000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = StructureType(1000059001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const FORMAT_PROPERTIES_2: Self = StructureType(1000059002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1000059003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = StructureType(1000059004); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const QUEUE_FAMILY_PROPERTIES_2: Self = StructureType(1000059005); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = StructureType(1000059006); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1000059007); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = StructureType(1000059008); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Result { + pub const ERROR_OUT_OF_POOL_MEMORY: Self = Result(-1000069000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const TRANSFER_SRC: Self = FormatFeatureFlags(0b100000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const TRANSFER_DST: Self = FormatFeatureFlags(0b1000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageCreateFlags { + pub const TYPE_2D_ARRAY_COMPATIBLE: Self = ImageCreateFlags(0b100000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageCreateFlags { + pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = ImageCreateFlags(0b10000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageCreateFlags { + pub const EXTENDED_USAGE: Self = ImageCreateFlags(0b100000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = StructureType(1000117000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = StructureType(1000117001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = StructureType(1000117002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = + StructureType(1000117003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageLayout { + pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(1000117000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageLayout { + pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(1000117001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = StructureType(1000053000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = StructureType(1000053001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = StructureType(1000053002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl DependencyFlags { + pub const VIEW_LOCAL: Self = DependencyFlags(0b10); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = StructureType(1000120000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PROTECTED_SUBMIT_INFO: Self = StructureType(1000145000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = StructureType(1000145001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = StructureType(1000145002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DEVICE_QUEUE_INFO_2: Self = StructureType(1000145003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl QueueFlags { + pub const PROTECTED: Self = QueueFlags(0b10000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl DeviceQueueCreateFlags { + pub const PROTECTED: Self = DeviceQueueCreateFlags(0b1); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl MemoryPropertyFlags { + pub const PROTECTED: Self = MemoryPropertyFlags(0b100000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl BufferCreateFlags { + pub const PROTECTED: Self = BufferCreateFlags(0b1000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageCreateFlags { + pub const PROTECTED: Self = ImageCreateFlags(0b100000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl CommandPoolCreateFlags { + pub const PROTECTED: Self = CommandPoolCreateFlags(0b100); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = StructureType(1000156000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = StructureType(1000156001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = StructureType(1000156002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = StructureType(1000156003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = StructureType(1000156004); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1000156005); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ObjectType { + pub const SAMPLER_YCBCR_CONVERSION: Self = ObjectType(1000156000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G8B8G8R8_422_UNORM: Self = Format(1000156000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const B8G8R8G8_422_UNORM: Self = Format(1000156001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G8_B8_R8_3PLANE_420_UNORM: Self = Format(1000156002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G8_B8R8_2PLANE_420_UNORM: Self = Format(1000156003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G8_B8_R8_3PLANE_422_UNORM: Self = Format(1000156004); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G8_B8R8_2PLANE_422_UNORM: Self = Format(1000156005); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G8_B8_R8_3PLANE_444_UNORM: Self = Format(1000156006); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const R10X6_UNORM_PACK16: Self = Format(1000156007); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const R10X6G10X6_UNORM_2PACK16: Self = Format(1000156008); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Format(1000156009); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Format(1000156010); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Format(1000156011); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Format(1000156012); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Format(1000156013); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Format(1000156014); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Format(1000156015); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Format(1000156016); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const R12X4_UNORM_PACK16: Self = Format(1000156017); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const R12X4G12X4_UNORM_2PACK16: Self = Format(1000156018); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Format(1000156019); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Format(1000156020); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Format(1000156021); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Format(1000156022); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Format(1000156023); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Format(1000156024); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Format(1000156025); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Format(1000156026); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G16B16G16R16_422_UNORM: Self = Format(1000156027); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const B16G16R16G16_422_UNORM: Self = Format(1000156028); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G16_B16_R16_3PLANE_420_UNORM: Self = Format(1000156029); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G16_B16R16_2PLANE_420_UNORM: Self = Format(1000156030); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G16_B16_R16_3PLANE_422_UNORM: Self = Format(1000156031); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G16_B16R16_2PLANE_422_UNORM: Self = Format(1000156032); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Format { + pub const G16_B16_R16_3PLANE_444_UNORM: Self = Format(1000156033); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageAspectFlags { + pub const PLANE_0: Self = ImageAspectFlags(0b10000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageAspectFlags { + pub const PLANE_1: Self = ImageAspectFlags(0b100000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageAspectFlags { + pub const PLANE_2: Self = ImageAspectFlags(0b1000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ImageCreateFlags { + pub const DISJOINT: Self = ImageCreateFlags(0b1000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const MIDPOINT_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b100000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = + FormatFeatureFlags(0b1000000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = + FormatFeatureFlags(0b10000000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = + FormatFeatureFlags(0b100000000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = + FormatFeatureFlags(0b1000000000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const DISJOINT: Self = FormatFeatureFlags(0b10000000000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl FormatFeatureFlags { + pub const COSITED_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b100000000000000000000000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = StructureType(1000085000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl ObjectType { + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = ObjectType(1000085000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = StructureType(1000071000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1000071001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = StructureType(1000071002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXTERNAL_BUFFER_PROPERTIES: Self = StructureType(1000071003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = StructureType(1000071004); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = StructureType(1000072000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = StructureType(1000072001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = StructureType(1000072002); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl Result { + pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Result(-1000072003); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = StructureType(1000112000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXTERNAL_FENCE_PROPERTIES: Self = StructureType(1000112001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXPORT_FENCE_CREATE_INFO: Self = StructureType(1000113000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = StructureType(1000077000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = StructureType(1000076000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = StructureType(1000076001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = StructureType(1000168000); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = StructureType(1000168001); +} +#[doc = "Generated from \'VK_VERSION_1_1\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = StructureType(1000063000); } fn display_flags( f: &mut fmt::Formatter, @@ -23324,32 +23271,15 @@ fn display_flags( } Ok(()) } -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { +impl fmt::Display for PresentModeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), _ => None, }; if let Some(x) = name { @@ -23359,193 +23289,11 @@ impl fmt::Display for SamplerYcbcrRange { } } } -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { +impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), + Self::VERTEX => Some("VERTEX"), Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), _ => None, }; if let Some(x) = name { @@ -23584,6 +23332,44 @@ impl fmt::Display for ImageLayout { } } } +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ExternalFenceHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -23607,195 +23393,27 @@ impl fmt::Display for ExternalFenceHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { +impl fmt::Display for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), ]; display_flags(f, KNOWN, self.0) } @@ -23813,54 +23431,6 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -23888,263 +23458,12 @@ impl fmt::Display for ExternalSemaphoreHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::NEAREST => Some("NEAREST"), Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -24154,20 +23473,17 @@ impl fmt::Display for SamplerMipmapMode { } } } -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for CompareOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), _ => None, }; if let Some(x) = name { @@ -24177,17 +23493,12 @@ impl fmt::Display for PhysicalDeviceType { } } } -impl fmt::Display for IndirectCommandsTokenTypeNVX { +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -24197,225 +23508,11 @@ impl fmt::Display for IndirectCommandsTokenTypeNVX { } } } -impl fmt::Display for BlendFactor { +impl fmt::Display for SamplerYcbcrRange { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -24488,26 +23585,11 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -24517,22 +23599,92 @@ impl fmt::Display for IndexType { } } } -impl fmt::Display for QueryResultFlags { +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SharingMode { +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -24542,80 +23694,10 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), _ => None, }; if let Some(x) = name { @@ -24625,15 +23707,70 @@ impl fmt::Display for DiscardRectangleModeEXT { } } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), ]; display_flags(f, KNOWN, self.0) } @@ -24661,42 +23798,6 @@ impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24746,6 +23847,612 @@ impl fmt::Display for ObjectType { } } } +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ColorSpaceKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24773,19 +24480,11 @@ impl fmt::Display for ColorSpaceKHR { } } } -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), _ => None, }; if let Some(x) = name { @@ -24795,6 +24494,699 @@ impl fmt::Display for QueueGlobalPriorityEXT { } } } +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25235,105 +25627,117 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for DeviceQueueCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryPipelineStatisticFlags { +impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25354,659 +25758,6 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for SampleCountFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -26021,10 +25772,14 @@ impl fmt::Display for SampleCountFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -26040,3 +25795,195 @@ impl fmt::Display for SparseMemoryBindFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index e0102ae..4d96815 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -619,7 +619,7 @@ fn name_to_tokens(type_name: &str) -> Ident { "int" => "c_int", "void" => "c_void", "char" => "c_char", - "float" => "c_float", + "float" => "f32", "long" => "c_ulong", _ => { if type_name.starts_with("Vk") { @@ -1700,10 +1700,6 @@ pub fn write_source_code(path: &Path) { let source_code = quote!{ use std::fmt; use std::os::raw::*; - #[doc(hidden)] - pub use self::extensions::*; - #[doc(hidden)] - pub use self::bitflags::*; pub trait Handle { const TYPE: ObjectType; @@ -1719,16 +1715,10 @@ pub fn write_source_code(path: &Path) { #(#feature_code)* #(#definition_code)* #(#enum_code)* - pub mod bitflags { - use super::*; - #(#bitflags_code)* - } + #(#bitflags_code)* #(#constants_code)* - pub mod extensions { - use super::*; - #(#extension_code)* - #feature_extensions_code - } + #(#extension_code)* + #feature_extensions_code #const_displays }; write!(&mut file, "{}", source_code).expect("Unable to write to file"); From 33dc8bff8f74c7362647a98f51a3911dba55e9b6 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 2 Oct 2018 15:23:38 +0200 Subject: [PATCH 095/122] Remove the mir sufrace extension because it has been deprecated --- ash/src/extensions/mir_surface.rs | 50 ------------------------------- ash/src/extensions/mod.rs | 2 -- 2 files changed, 52 deletions(-) delete mode 100644 ash/src/extensions/mir_surface.rs diff --git a/ash/src/extensions/mir_surface.rs b/ash/src/extensions/mir_surface.rs deleted file mode 100644 index 3f36a1e..0000000 --- a/ash/src/extensions/mir_surface.rs +++ /dev/null @@ -1,50 +0,0 @@ -#![allow(dead_code)] -use prelude::*; -use std::ffi::CStr; -use std::mem; -use version::{EntryV1_0, InstanceV1_0}; -use vk; -use RawPtr; - -#[derive(Clone)] -pub struct MirSurface { - handle: vk::Instance, - mir_surface_fn: vk::KhrMirSurfaceFn, -} - -impl MirSurface { - pub fn new( - entry: &E, - instance: &I, - ) -> Result> { - let surface_fn = vk::KhrMirSurfaceFn::load(|name| unsafe { - mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(MirSurface { - handle: instance.handle(), - mir_surface_fn: surface_fn, - }) - } - - pub fn name() -> &'static CStr { - CStr::from_bytes_with_nul(b"VK_KHR_mir_surface\0").expect("Wrong extension string") - } - - pub unsafe fn create_mir_surface_khr( - &self, - create_info: &vk::MirSurfaceCreateInfoKHR, - allocation_callbacks: Option<&vk::AllocationCallbacks>, - ) -> VkResult { - let mut surface = mem::uninitialized(); - let err_code = self.mir_surface_fn.create_mir_surface_khr( - self.handle, - create_info, - allocation_callbacks.as_raw_ptr(), - &mut surface, - ); - match err_code { - vk::Result::SUCCESS => Ok(surface), - _ => Err(err_code), - } - } -} diff --git a/ash/src/extensions/mod.rs b/ash/src/extensions/mod.rs index db61e32..dc41390 100644 --- a/ash/src/extensions/mod.rs +++ b/ash/src/extensions/mod.rs @@ -5,7 +5,6 @@ pub use self::debug_utils::DebugUtils; pub use self::display_swapchain::DisplaySwapchain; pub use self::ios_surface::IOSSurface; pub use self::macos_surface::MacOSSurface; -pub use self::mir_surface::MirSurface; pub use self::surface::Surface; pub use self::swapchain::Swapchain; pub use self::wayland_surface::WaylandSurface; @@ -20,7 +19,6 @@ mod debug_utils; mod display_swapchain; mod ios_surface; mod macos_surface; -mod mir_surface; mod surface; mod swapchain; mod wayland_surface; From d4789768a6ca8b22a314dda4034a2e1cee8978fa Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 7 Oct 2018 10:17:48 -0700 Subject: [PATCH 096/122] Fix nonsense Debug impl on non-char static arrays --- ash/src/vk.rs | 3523 +++++++++++++++++++----------------------- generator/src/lib.rs | 4 +- 2 files changed, 1579 insertions(+), 1948 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 2fc09be..0c2f600 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -5045,9 +5045,8 @@ impl fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }).field("pipeline_cache_uuid", &unsafe { - ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }).field("limits", &self.limits) + }).field("pipeline_cache_uuid", &self.pipeline_cache_uuid) + .field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -5267,25 +5266,13 @@ pub struct QueueFamilyProperties { pub min_image_transfer_granularity: Extent3D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMemoryProperties { pub memory_type_count: u32, pub memory_types: [MemoryType; MAX_MEMORY_TYPES], pub memory_heap_count: u32, pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], } -impl fmt::Debug for PhysicalDeviceMemoryProperties { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("PhysicalDeviceMemoryProperties") - .field("memory_type_count", &self.memory_type_count) - .field("memory_types", &unsafe { - ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }).field("memory_heap_count", &self.memory_heap_count) - .field("memory_heaps", &unsafe { - ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for PhysicalDeviceMemoryProperties { fn default() -> PhysicalDeviceMemoryProperties { PhysicalDeviceMemoryProperties { @@ -5800,25 +5787,13 @@ pub struct ImageCopy { pub extent: Extent3D, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ImageBlit { pub src_subresource: ImageSubresourceLayers, pub src_offsets: [Offset3D; 2], pub dst_subresource: ImageSubresourceLayers, pub dst_offsets: [Offset3D; 2], } -impl fmt::Debug for ImageBlit { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("ImageBlit") - .field("src_subresource", &self.src_subresource) - .field("src_offsets", &unsafe { - ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }).field("dst_subresource", &self.dst_subresource) - .field("dst_offsets", &unsafe { - ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for ImageBlit { fn default() -> ImageBlit { ImageBlit { @@ -6207,7 +6182,7 @@ pub struct PipelineColorBlendAttachmentState { pub color_write_mask: ColorComponentFlags, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PipelineColorBlendStateCreateInfo { pub s_type: StructureType, pub p_next: *const c_void, @@ -6218,21 +6193,6 @@ pub struct PipelineColorBlendStateCreateInfo { pub p_attachments: *const PipelineColorBlendAttachmentState, pub blend_constants: [c_float; 4], } -impl fmt::Debug for PipelineColorBlendStateCreateInfo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("PipelineColorBlendStateCreateInfo") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("flags", &self.flags) - .field("logic_op_enable", &self.logic_op_enable) - .field("logic_op", &self.logic_op) - .field("attachment_count", &self.attachment_count) - .field("p_attachments", &self.p_attachments) - .field("blend_constants", &unsafe { - ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for PipelineColorBlendStateCreateInfo { fn default() -> PipelineColorBlendStateCreateInfo { PipelineColorBlendStateCreateInfo { @@ -6810,7 +6770,7 @@ pub struct PhysicalDeviceSparseProperties { pub residency_non_resident_strict: Bool32, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceLimits { pub max_image_dimension1_d: u32, pub max_image_dimension2_d: u32, @@ -6919,238 +6879,6 @@ pub struct PhysicalDeviceLimits { pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, pub non_coherent_atom_size: DeviceSize, } -impl fmt::Debug for PhysicalDeviceLimits { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("PhysicalDeviceLimits") - .field("max_image_dimension1_d", &self.max_image_dimension1_d) - .field("max_image_dimension2_d", &self.max_image_dimension2_d) - .field("max_image_dimension3_d", &self.max_image_dimension3_d) - .field("max_image_dimension_cube", &self.max_image_dimension_cube) - .field("max_image_array_layers", &self.max_image_array_layers) - .field("max_texel_buffer_elements", &self.max_texel_buffer_elements) - .field("max_uniform_buffer_range", &self.max_uniform_buffer_range) - .field("max_storage_buffer_range", &self.max_storage_buffer_range) - .field("max_push_constants_size", &self.max_push_constants_size) - .field( - "max_memory_allocation_count", - &self.max_memory_allocation_count, - ).field( - "max_sampler_allocation_count", - &self.max_sampler_allocation_count, - ).field("buffer_image_granularity", &self.buffer_image_granularity) - .field("sparse_address_space_size", &self.sparse_address_space_size) - .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) - .field( - "max_per_stage_descriptor_samplers", - &self.max_per_stage_descriptor_samplers, - ).field( - "max_per_stage_descriptor_uniform_buffers", - &self.max_per_stage_descriptor_uniform_buffers, - ).field( - "max_per_stage_descriptor_storage_buffers", - &self.max_per_stage_descriptor_storage_buffers, - ).field( - "max_per_stage_descriptor_sampled_images", - &self.max_per_stage_descriptor_sampled_images, - ).field( - "max_per_stage_descriptor_storage_images", - &self.max_per_stage_descriptor_storage_images, - ).field( - "max_per_stage_descriptor_input_attachments", - &self.max_per_stage_descriptor_input_attachments, - ).field("max_per_stage_resources", &self.max_per_stage_resources) - .field( - "max_descriptor_set_samplers", - &self.max_descriptor_set_samplers, - ).field( - "max_descriptor_set_uniform_buffers", - &self.max_descriptor_set_uniform_buffers, - ).field( - "max_descriptor_set_uniform_buffers_dynamic", - &self.max_descriptor_set_uniform_buffers_dynamic, - ).field( - "max_descriptor_set_storage_buffers", - &self.max_descriptor_set_storage_buffers, - ).field( - "max_descriptor_set_storage_buffers_dynamic", - &self.max_descriptor_set_storage_buffers_dynamic, - ).field( - "max_descriptor_set_sampled_images", - &self.max_descriptor_set_sampled_images, - ).field( - "max_descriptor_set_storage_images", - &self.max_descriptor_set_storage_images, - ).field( - "max_descriptor_set_input_attachments", - &self.max_descriptor_set_input_attachments, - ).field( - "max_vertex_input_attributes", - &self.max_vertex_input_attributes, - ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) - .field( - "max_vertex_input_attribute_offset", - &self.max_vertex_input_attribute_offset, - ).field( - "max_vertex_input_binding_stride", - &self.max_vertex_input_binding_stride, - ).field( - "max_vertex_output_components", - &self.max_vertex_output_components, - ).field( - "max_tessellation_generation_level", - &self.max_tessellation_generation_level, - ).field( - "max_tessellation_patch_size", - &self.max_tessellation_patch_size, - ).field( - "max_tessellation_control_per_vertex_input_components", - &self.max_tessellation_control_per_vertex_input_components, - ).field( - "max_tessellation_control_per_vertex_output_components", - &self.max_tessellation_control_per_vertex_output_components, - ).field( - "max_tessellation_control_per_patch_output_components", - &self.max_tessellation_control_per_patch_output_components, - ).field( - "max_tessellation_control_total_output_components", - &self.max_tessellation_control_total_output_components, - ).field( - "max_tessellation_evaluation_input_components", - &self.max_tessellation_evaluation_input_components, - ).field( - "max_tessellation_evaluation_output_components", - &self.max_tessellation_evaluation_output_components, - ).field( - "max_geometry_shader_invocations", - &self.max_geometry_shader_invocations, - ).field( - "max_geometry_input_components", - &self.max_geometry_input_components, - ).field( - "max_geometry_output_components", - &self.max_geometry_output_components, - ).field( - "max_geometry_output_vertices", - &self.max_geometry_output_vertices, - ).field( - "max_geometry_total_output_components", - &self.max_geometry_total_output_components, - ).field( - "max_fragment_input_components", - &self.max_fragment_input_components, - ).field( - "max_fragment_output_attachments", - &self.max_fragment_output_attachments, - ).field( - "max_fragment_dual_src_attachments", - &self.max_fragment_dual_src_attachments, - ).field( - "max_fragment_combined_output_resources", - &self.max_fragment_combined_output_resources, - ).field( - "max_compute_shared_memory_size", - &self.max_compute_shared_memory_size, - ).field("max_compute_work_group_count", &unsafe { - ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }).field( - "max_compute_work_group_invocations", - &self.max_compute_work_group_invocations, - ).field("max_compute_work_group_size", &unsafe { - ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) - .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) - .field("mipmap_precision_bits", &self.mipmap_precision_bits) - .field( - "max_draw_indexed_index_value", - &self.max_draw_indexed_index_value, - ).field("max_draw_indirect_count", &self.max_draw_indirect_count) - .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) - .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) - .field("max_viewports", &self.max_viewports) - .field("max_viewport_dimensions", &unsafe { - ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }).field("viewport_bounds_range", &unsafe { - ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) - .field("min_memory_map_alignment", &self.min_memory_map_alignment) - .field( - "min_texel_buffer_offset_alignment", - &self.min_texel_buffer_offset_alignment, - ).field( - "min_uniform_buffer_offset_alignment", - &self.min_uniform_buffer_offset_alignment, - ).field( - "min_storage_buffer_offset_alignment", - &self.min_storage_buffer_offset_alignment, - ).field("min_texel_offset", &self.min_texel_offset) - .field("max_texel_offset", &self.max_texel_offset) - .field("min_texel_gather_offset", &self.min_texel_gather_offset) - .field("max_texel_gather_offset", &self.max_texel_gather_offset) - .field("min_interpolation_offset", &self.min_interpolation_offset) - .field("max_interpolation_offset", &self.max_interpolation_offset) - .field( - "sub_pixel_interpolation_offset_bits", - &self.sub_pixel_interpolation_offset_bits, - ).field("max_framebuffer_width", &self.max_framebuffer_width) - .field("max_framebuffer_height", &self.max_framebuffer_height) - .field("max_framebuffer_layers", &self.max_framebuffer_layers) - .field( - "framebuffer_color_sample_counts", - &self.framebuffer_color_sample_counts, - ).field( - "framebuffer_depth_sample_counts", - &self.framebuffer_depth_sample_counts, - ).field( - "framebuffer_stencil_sample_counts", - &self.framebuffer_stencil_sample_counts, - ).field( - "framebuffer_no_attachments_sample_counts", - &self.framebuffer_no_attachments_sample_counts, - ).field("max_color_attachments", &self.max_color_attachments) - .field( - "sampled_image_color_sample_counts", - &self.sampled_image_color_sample_counts, - ).field( - "sampled_image_integer_sample_counts", - &self.sampled_image_integer_sample_counts, - ).field( - "sampled_image_depth_sample_counts", - &self.sampled_image_depth_sample_counts, - ).field( - "sampled_image_stencil_sample_counts", - &self.sampled_image_stencil_sample_counts, - ).field( - "storage_image_sample_counts", - &self.storage_image_sample_counts, - ).field("max_sample_mask_words", &self.max_sample_mask_words) - .field( - "timestamp_compute_and_graphics", - &self.timestamp_compute_and_graphics, - ).field("timestamp_period", &self.timestamp_period) - .field("max_clip_distances", &self.max_clip_distances) - .field("max_cull_distances", &self.max_cull_distances) - .field( - "max_combined_clip_and_cull_distances", - &self.max_combined_clip_and_cull_distances, - ).field("discrete_queue_priorities", &self.discrete_queue_priorities) - .field("point_size_range", &unsafe { - ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }).field("line_width_range", &unsafe { - ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }).field("point_size_granularity", &self.point_size_granularity) - .field("line_width_granularity", &self.line_width_granularity) - .field("strict_lines", &self.strict_lines) - .field("standard_sample_locations", &self.standard_sample_locations) - .field( - "optimal_buffer_copy_offset_alignment", - &self.optimal_buffer_copy_offset_alignment, - ).field( - "optimal_buffer_copy_row_pitch_alignment", - &self.optimal_buffer_copy_row_pitch_alignment, - ).field("non_coherent_atom_size", &self.non_coherent_atom_size) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceLimits { fn default() -> PhysicalDeviceLimits { PhysicalDeviceLimits { @@ -7842,24 +7570,13 @@ impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { } } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DebugMarkerMarkerInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, pub p_marker_name: *const c_char, pub color: [c_float; 4], } -impl fmt::Debug for DebugMarkerMarkerInfoEXT { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("DebugMarkerMarkerInfoEXT") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("p_marker_name", &self.p_marker_name) - .field("color", &unsafe { - ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for DebugMarkerMarkerInfoEXT { fn default() -> DebugMarkerMarkerInfoEXT { DebugMarkerMarkerInfoEXT { @@ -8540,7 +8257,7 @@ impl ::std::default::Default for ExternalBufferProperties { } } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceIDProperties { pub s_type: StructureType, pub p_next: *mut c_void, @@ -8550,22 +8267,6 @@ pub struct PhysicalDeviceIDProperties { pub device_node_mask: u32, pub device_luid_valid: Bool32, } -impl fmt::Debug for PhysicalDeviceIDProperties { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("PhysicalDeviceIDProperties") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("device_uuid", &unsafe { - ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }).field("driver_uuid", &unsafe { - ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }).field("device_luid", &unsafe { - ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }).field("device_node_mask", &self.device_node_mask) - .field("device_luid_valid", &self.device_luid_valid) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceIDProperties { fn default() -> PhysicalDeviceIDProperties { PhysicalDeviceIDProperties { @@ -9276,7 +8977,7 @@ impl ::std::default::Default for SwapchainCounterCreateInfoEXT { } } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceGroupProperties { pub s_type: StructureType, pub p_next: *mut c_void, @@ -9284,18 +8985,6 @@ pub struct PhysicalDeviceGroupProperties { pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, } -impl fmt::Debug for PhysicalDeviceGroupProperties { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("PhysicalDeviceGroupProperties") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("physical_device_count", &self.physical_device_count) - .field("physical_devices", &unsafe { - ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }).field("subset_allocation", &self.subset_allocation) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceGroupProperties { fn default() -> PhysicalDeviceGroupProperties { PhysicalDeviceGroupProperties { @@ -9486,24 +9175,13 @@ impl ::std::default::Default for DeviceGroupBindSparseInfo { } } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DeviceGroupPresentCapabilitiesKHR { pub s_type: StructureType, pub p_next: *const c_void, pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE], pub modes: DeviceGroupPresentModeFlagsKHR, } -impl fmt::Debug for DeviceGroupPresentCapabilitiesKHR { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("DeviceGroupPresentCapabilitiesKHR") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("present_mask", &unsafe { - ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }).field("modes", &self.modes) - .finish() - } -} impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { fn default() -> DeviceGroupPresentCapabilitiesKHR { DeviceGroupPresentCapabilitiesKHR { @@ -10576,7 +10254,7 @@ impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { } } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, @@ -10586,28 +10264,6 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub sample_location_sub_pixel_bits: u32, pub variable_sample_locations: Bool32, } -impl fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("PhysicalDeviceSampleLocationsPropertiesEXT") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field( - "sample_location_sample_counts", - &self.sample_location_sample_counts, - ).field( - "max_sample_location_grid_size", - &self.max_sample_location_grid_size, - ).field("sample_location_coordinate_range", &unsafe { - ::std::ffi::CStr::from_ptr( - self.sample_location_coordinate_range.as_ptr() as *const i8 - ) - }).field( - "sample_location_sub_pixel_bits", - &self.sample_location_sub_pixel_bits, - ).field("variable_sample_locations", &self.variable_sample_locations) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { fn default() -> PhysicalDeviceSampleLocationsPropertiesEXT { PhysicalDeviceSampleLocationsPropertiesEXT { @@ -10875,7 +10531,7 @@ pub struct ShaderResourceUsageAMD { pub scratch_mem_usage_in_bytes: usize, } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct ShaderStatisticsInfoAMD { pub shader_stage_mask: ShaderStageFlags, pub resource_usage: ShaderResourceUsageAMD, @@ -10885,20 +10541,6 @@ pub struct ShaderStatisticsInfoAMD { pub num_available_sgprs: u32, pub compute_work_group_size: [u32; 3], } -impl fmt::Debug for ShaderStatisticsInfoAMD { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("ShaderStatisticsInfoAMD") - .field("shader_stage_mask", &self.shader_stage_mask) - .field("resource_usage", &self.resource_usage) - .field("num_physical_vgprs", &self.num_physical_vgprs) - .field("num_physical_sgprs", &self.num_physical_sgprs) - .field("num_available_vgprs", &self.num_available_vgprs) - .field("num_available_sgprs", &self.num_available_sgprs) - .field("compute_work_group_size", &unsafe { - ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for ShaderStatisticsInfoAMD { fn default() -> ShaderStatisticsInfoAMD { ShaderStatisticsInfoAMD { @@ -10973,24 +10615,13 @@ impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { } } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct DebugUtilsLabelEXT { pub s_type: StructureType, pub p_next: *const c_void, pub p_label_name: *const c_char, pub color: [c_float; 4], } -impl fmt::Debug for DebugUtilsLabelEXT { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("DebugUtilsLabelEXT") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("p_label_name", &self.p_label_name) - .field("color", &unsafe { - ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for DebugUtilsLabelEXT { fn default() -> DebugUtilsLabelEXT { DebugUtilsLabelEXT { @@ -23324,73 +22955,6 @@ fn display_flags( } Ok(()) } -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -23439,595 +23003,9 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for AttachmentLoadOp { +impl fmt::Display for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; display_flags(f, KNOWN, self.0) } } @@ -24054,40 +23032,11 @@ impl fmt::Display for PrimitiveTopology { } } } -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), _ => None, }; if let Some(x) = name { @@ -24097,54 +23046,10 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for ImageType { +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -24160,271 +23065,6 @@ impl fmt::Display for FenceCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24488,26 +23128,862 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for DebugReportFlagsEXT { +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndexType { +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -24528,94 +24004,12 @@ impl fmt::Display for QueryResultFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SharingMode { +impl fmt::Display for ConservativeRasterizationModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), _ => None, }; if let Some(x) = name { @@ -24638,33 +24032,156 @@ impl fmt::Display for MemoryPropertyFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { +impl fmt::Display for DescriptorBindingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageTiling { +impl fmt::Display for AttachmentLoadOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), Self::LINEAR => Some("LINEAR"), _ => None, }; @@ -24675,124 +24192,75 @@ impl fmt::Display for ImageTiling { } } } -impl fmt::Display for BufferUsageFlags { +impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", ), ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectType { +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueueGlobalPriorityEXT { +impl fmt::Display for ExternalMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for StructureType { @@ -25235,31 +24703,33 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for MemoryHeapFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FrontFace { +impl fmt::Display for ColorSpaceKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), _ => None, }; if let Some(x) = name { @@ -25269,11 +24739,15 @@ impl fmt::Display for FrontFace { } } } -impl fmt::Display for PipelineBindPoint { +impl fmt::Display for PresentModeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), _ => None, }; if let Some(x) = name { @@ -25283,68 +24757,37 @@ impl fmt::Display for PipelineBindPoint { } } } -impl fmt::Display for QueryPipelineStatisticFlags { +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", ), ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", ), ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", ), ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ViewportCoordinateSwizzleNV { +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -25354,28 +24797,122 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for CommandPoolCreateFlags { +impl fmt::Display for BufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), ]; display_flags(f, KNOWN, self.0) @@ -25648,6 +25185,81 @@ impl fmt::Display for Format { } } } +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for QueueFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -25660,17 +25272,78 @@ impl fmt::Display for QueueFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BufferCreateFlags { +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25685,6 +25358,43 @@ impl fmt::Display for RasterizationOrderAMD { } } } +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25699,83 +25409,21 @@ impl fmt::Display for SubpassContents { } } } -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", ), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25796,15 +25444,180 @@ impl fmt::Display for StencilOp { } } } -impl fmt::Display for FormatFeatureFlags { +impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryControlFlags { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } @@ -25819,224 +25632,42 @@ impl fmt::Display for CullModeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", ), ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", ), ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", ), ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectEntryUsageFlagsNVX { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index e0102ae..da80d18 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1248,7 +1248,7 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt .map(|n| n.contains("pfn")) .unwrap_or(false) }); - let contains_static_array = members.clone().any(is_static_array); + let contains_static_array = members.clone().any(|x| is_static_array(x) && x.basetype == "char"); let contains_union = members .clone() .any(|field| union_types.contains(field.basetype.as_str())); @@ -1258,7 +1258,7 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt let debug_fields = members.clone().map(|field| { let param_ident = field.param_ident(); let param_str = param_ident.as_ref(); - let debug_value = if is_static_array(field) { + let debug_value = if is_static_array(field) && field.basetype == "char" { quote!{ &unsafe { ::std::ffi::CStr::from_ptr(self.#param_ident.as_ptr() as *const i8) From 445c72fa263d9bf3ae941f3f9e4d3884c8de662a Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 7 Oct 2018 11:12:03 -0700 Subject: [PATCH 097/122] Add missing unsafe qualifiers --- ash/src/device.rs | 56 +++---- ash/src/extensions/surface.rs | 141 ++++++++-------- ash/src/extensions/swapchain.rs | 40 +++-- ash/src/instance.rs | 280 +++++++++++++++----------------- 4 files changed, 238 insertions(+), 279 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index b6a2991..b21fa7c 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -652,13 +652,11 @@ pub trait DeviceV1_0 { } } - fn device_wait_idle(&self) -> VkResult<()> { - unsafe { - let err_code = self.fp_v1_0().device_wait_idle(self.handle()); - match err_code { - vk::Result::SUCCESS => Ok(()), - _ => Err(err_code), - } + unsafe fn device_wait_idle(&self) -> VkResult<()> { + let err_code = self.fp_v1_0().device_wait_idle(self.handle()); + match err_code { + vk::Result::SUCCESS => Ok(()), + _ => Err(err_code), } } @@ -1604,39 +1602,33 @@ pub trait DeviceV1_0 { } } - fn get_image_subresource_layout( + unsafe fn get_image_subresource_layout( &self, image: vk::Image, subresource: vk::ImageSubresource, ) -> vk::SubresourceLayout { - unsafe { - let mut layout = mem::uninitialized(); - self.fp_v1_0().get_image_subresource_layout( - self.handle(), - image, - &subresource, - &mut layout, - ); - layout - } + let mut layout = mem::uninitialized(); + self.fp_v1_0().get_image_subresource_layout( + self.handle(), + image, + &subresource, + &mut layout, + ); + layout } - fn get_image_memory_requirements(&self, image: vk::Image) -> vk::MemoryRequirements { - unsafe { - let mut mem_req = mem::uninitialized(); - self.fp_v1_0() - .get_image_memory_requirements(self.handle(), image, &mut mem_req); - mem_req - } + unsafe fn get_image_memory_requirements(&self, image: vk::Image) -> vk::MemoryRequirements { + let mut mem_req = mem::uninitialized(); + self.fp_v1_0() + .get_image_memory_requirements(self.handle(), image, &mut mem_req); + mem_req } - fn get_buffer_memory_requirements(&self, buffer: vk::Buffer) -> vk::MemoryRequirements { - unsafe { - let mut mem_req = mem::uninitialized(); - self.fp_v1_0() - .get_buffer_memory_requirements(self.handle(), buffer, &mut mem_req); - mem_req - } + unsafe fn get_buffer_memory_requirements(&self, buffer: vk::Buffer) -> vk::MemoryRequirements { + let mut mem_req = mem::uninitialized(); + self.fp_v1_0() + .get_buffer_memory_requirements(self.handle(), buffer, &mut mem_req); + mem_req } unsafe fn allocate_memory( diff --git a/ash/src/extensions/surface.rs b/ash/src/extensions/surface.rs index ce8cfd2..d7f5765 100644 --- a/ash/src/extensions/surface.rs +++ b/ash/src/extensions/surface.rs @@ -31,100 +31,93 @@ impl Surface { CStr::from_bytes_with_nul(b"VK_KHR_surface\0").expect("Wrong extension string") } - pub fn get_physical_device_surface_support_khr( + pub unsafe fn get_physical_device_surface_support_khr( &self, physical_device: vk::PhysicalDevice, queue_index: u32, surface: vk::SurfaceKHR, ) -> bool { - unsafe { - let mut b = mem::uninitialized(); - self.surface_fn.get_physical_device_surface_support_khr( - physical_device, - queue_index, - surface, - &mut b, - ); - b > 0 - } + let mut b = mem::uninitialized(); + self.surface_fn.get_physical_device_surface_support_khr( + physical_device, + queue_index, + surface, + &mut b, + ); + b > 0 } - pub fn get_physical_device_surface_present_modes_khr( + + pub unsafe fn get_physical_device_surface_present_modes_khr( &self, physical_device: vk::PhysicalDevice, surface: vk::SurfaceKHR, ) -> VkResult> { - unsafe { - let mut count = 0; - self.surface_fn - .get_physical_device_surface_present_modes_khr( - physical_device, - surface, - &mut count, - ptr::null_mut(), - ); - let mut v = Vec::with_capacity(count as usize); - let err_code = self - .surface_fn - .get_physical_device_surface_present_modes_khr( - physical_device, - surface, - &mut count, - v.as_mut_ptr(), - ); - v.set_len(count as usize); - match err_code { - vk::Result::SUCCESS => Ok(v), - _ => Err(err_code), - } - } - } - - pub fn get_physical_device_surface_capabilities_khr( - &self, - physical_device: vk::PhysicalDevice, - surface: vk::SurfaceKHR, - ) -> VkResult { - unsafe { - let mut surface_capabilities = mem::uninitialized(); - let err_code = self - .surface_fn - .get_physical_device_surface_capabilities_khr( - physical_device, - surface, - &mut surface_capabilities, - ); - match err_code { - vk::Result::SUCCESS => Ok(surface_capabilities), - _ => Err(err_code), - } - } - } - - pub fn get_physical_device_surface_formats_khr( - &self, - physical_device: vk::PhysicalDevice, - surface: vk::SurfaceKHR, - ) -> VkResult> { - unsafe { - let mut count = 0; - self.surface_fn.get_physical_device_surface_formats_khr( + let mut count = 0; + self.surface_fn + .get_physical_device_surface_present_modes_khr( physical_device, surface, &mut count, ptr::null_mut(), ); - let mut v = Vec::with_capacity(count as usize); - let err_code = self.surface_fn.get_physical_device_surface_formats_khr( + let mut v = Vec::with_capacity(count as usize); + let err_code = self + .surface_fn + .get_physical_device_surface_present_modes_khr( physical_device, surface, &mut count, v.as_mut_ptr(), ); - v.set_len(count as usize); - match err_code { - vk::Result::SUCCESS => Ok(v), - _ => Err(err_code), - } + v.set_len(count as usize); + match err_code { + vk::Result::SUCCESS => Ok(v), + _ => Err(err_code), + } + } + + pub unsafe fn get_physical_device_surface_capabilities_khr( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut surface_capabilities = mem::uninitialized(); + let err_code = self + .surface_fn + .get_physical_device_surface_capabilities_khr( + physical_device, + surface, + &mut surface_capabilities, + ); + match err_code { + vk::Result::SUCCESS => Ok(surface_capabilities), + _ => Err(err_code), + } + } + + pub unsafe fn get_physical_device_surface_formats_khr( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + let mut count = 0; + self.surface_fn.get_physical_device_surface_formats_khr( + physical_device, + surface, + &mut count, + ptr::null_mut(), + ); + let mut v = Vec::with_capacity(count as usize); + let err_code = self.surface_fn.get_physical_device_surface_formats_khr( + physical_device, + surface, + &mut count, + v.as_mut_ptr(), + ); + v.set_len(count as usize); + match err_code { + vk::Result::SUCCESS => Ok(v), + _ => Err(err_code), } } diff --git a/ash/src/extensions/swapchain.rs b/ash/src/extensions/swapchain.rs index 0a99708..e76902b 100644 --- a/ash/src/extensions/swapchain.rs +++ b/ash/src/extensions/swapchain.rs @@ -95,31 +95,29 @@ impl Swapchain { } } - pub fn get_swapchain_images_khr( + pub unsafe fn get_swapchain_images_khr( &self, swapchain: vk::SwapchainKHR, ) -> VkResult> { - unsafe { - let mut count = 0; - self.swapchain_fn.get_swapchain_images_khr( - self.handle, - swapchain, - &mut count, - ptr::null_mut(), - ); + let mut count = 0; + self.swapchain_fn.get_swapchain_images_khr( + self.handle, + swapchain, + &mut count, + ptr::null_mut(), + ); - let mut v = Vec::with_capacity(count as usize); - let err_code = self.swapchain_fn.get_swapchain_images_khr( - self.handle, - swapchain, - &mut count, - v.as_mut_ptr(), - ); - v.set_len(count as usize); - match err_code { - vk::Result::SUCCESS => Ok(v), - _ => Err(err_code), - } + let mut v = Vec::with_capacity(count as usize); + let err_code = self.swapchain_fn.get_swapchain_images_khr( + self.handle, + swapchain, + &mut count, + v.as_mut_ptr(), + ); + v.set_len(count as usize); + match err_code { + vk::Result::SUCCESS => Ok(v), + _ => Err(err_code), } } } diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 4555ec9..a7cfdc9 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -87,25 +87,23 @@ impl Instance { pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; - fn enumerate_physical_device_groups(&self) -> VkResult> { - unsafe { - let mut group_count = mem::uninitialized(); - self.fp_v1_1().enumerate_physical_device_groups( - self.handle(), - &mut group_count, - ptr::null_mut(), - ); - let mut physical_device_groups = Vec::with_capacity(group_count as usize); - let err_code = self.fp_v1_1().enumerate_physical_device_groups( - self.handle(), - &mut group_count, - physical_device_groups.as_mut_ptr(), - ); - physical_device_groups.set_len(group_count as usize); - match err_code { - vk::Result::SUCCESS => Ok(physical_device_groups), - _ => Err(err_code), - } + unsafe fn enumerate_physical_device_groups(&self) -> VkResult> { + let mut group_count = mem::uninitialized(); + self.fp_v1_1().enumerate_physical_device_groups( + self.handle(), + &mut group_count, + ptr::null_mut(), + ); + let mut physical_device_groups = Vec::with_capacity(group_count as usize); + let err_code = self.fp_v1_1().enumerate_physical_device_groups( + self.handle(), + &mut group_count, + physical_device_groups.as_mut_ptr(), + ); + physical_device_groups.set_len(group_count as usize); + match err_code { + vk::Result::SUCCESS => Ok(physical_device_groups), + _ => Err(err_code), } } @@ -118,20 +116,18 @@ pub trait InstanceV1_1: InstanceV1_0 { .get_physical_device_properties2(physical_device, prop); } - fn get_physical_device_format_properties2( + unsafe fn get_physical_device_format_properties2( &self, physical_device: vk::PhysicalDevice, format: vk::Format, ) -> vk::FormatProperties2 { - unsafe { - let mut format_prop = mem::uninitialized(); - self.fp_v1_1().get_physical_device_format_properties2( - physical_device, - format, - &mut format_prop, - ); - format_prop - } + let mut format_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_format_properties2( + physical_device, + format, + &mut format_prop, + ); + format_prop } unsafe fn get_physical_device_image_format_properties2( @@ -152,19 +148,17 @@ pub trait InstanceV1_1: InstanceV1_0 { } } - fn get_physical_device_queue_family_properties2_len( + unsafe fn get_physical_device_queue_family_properties2_len( &self, physical_device: vk::PhysicalDevice, ) -> usize { - unsafe { - let mut queue_count = 0; - self.fp_v1_1().get_physical_device_queue_family_properties2( - physical_device, - &mut queue_count, - ptr::null_mut(), - ); - queue_count as usize - } + let mut queue_count = 0; + self.fp_v1_1().get_physical_device_queue_family_properties2( + physical_device, + &mut queue_count, + ptr::null_mut(), + ); + queue_count as usize } unsafe fn get_physical_device_queue_family_properties2( @@ -180,16 +174,14 @@ pub trait InstanceV1_1: InstanceV1_0 { ); } - fn get_physical_device_memory_properties2( + unsafe fn get_physical_device_memory_properties2( &self, physical_device: vk::PhysicalDevice, ) -> vk::PhysicalDeviceMemoryProperties2 { - unsafe { - let mut memory_prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_memory_properties2(physical_device, &mut memory_prop); - memory_prop - } + let mut memory_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_memory_properties2(physical_device, &mut memory_prop); + memory_prop } unsafe fn get_physical_device_sparse_image_format_properties2( @@ -291,12 +283,12 @@ pub trait InstanceV1_0 { Ok(Device::from_raw(device, device_fn)) } - fn get_device_proc_addr( + unsafe fn get_device_proc_addr( &self, device: vk::Device, p_name: *const c_char, ) -> vk::PFN_vkVoidFunction { - unsafe { self.fp_v1_0().get_device_proc_addr(device, p_name) } + self.fp_v1_0().get_device_proc_addr(device, p_name) } unsafe fn destroy_instance(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) { @@ -304,23 +296,21 @@ pub trait InstanceV1_0 { .destroy_instance(self.handle(), allocation_callbacks.as_raw_ptr()); } - fn get_physical_device_format_properties( + unsafe fn get_physical_device_format_properties( &self, physical_device: vk::PhysicalDevice, format: vk::Format, ) -> vk::FormatProperties { - unsafe { - let mut format_prop = mem::uninitialized(); - self.fp_v1_0().get_physical_device_format_properties( - physical_device, - format, - &mut format_prop, - ); - format_prop - } + let mut format_prop = mem::uninitialized(); + self.fp_v1_0().get_physical_device_format_properties( + physical_device, + format, + &mut format_prop, + ); + format_prop } - fn get_physical_device_image_format_properties( + unsafe fn get_physical_device_image_format_properties( &self, physical_device: vk::PhysicalDevice, format: vk::Format, @@ -329,126 +319,112 @@ pub trait InstanceV1_0 { usage: vk::ImageUsageFlags, flags: vk::ImageCreateFlags, ) -> VkResult { - unsafe { - let mut image_format_prop = mem::uninitialized(); - let err_code = self.fp_v1_0().get_physical_device_image_format_properties( - physical_device, - format, - typ, - tiling, - usage, - flags, - &mut image_format_prop, - ); - if err_code == vk::Result::SUCCESS { - Ok(image_format_prop) - } else { - Err(err_code) - } + let mut image_format_prop = mem::uninitialized(); + let err_code = self.fp_v1_0().get_physical_device_image_format_properties( + physical_device, + format, + typ, + tiling, + usage, + flags, + &mut image_format_prop, + ); + if err_code == vk::Result::SUCCESS { + Ok(image_format_prop) + } else { + Err(err_code) } } - fn get_physical_device_memory_properties( + unsafe fn get_physical_device_memory_properties( &self, physical_device: vk::PhysicalDevice, ) -> vk::PhysicalDeviceMemoryProperties { - unsafe { - let mut memory_prop = mem::uninitialized(); - self.fp_v1_0() - .get_physical_device_memory_properties(physical_device, &mut memory_prop); - memory_prop - } + let mut memory_prop = mem::uninitialized(); + self.fp_v1_0() + .get_physical_device_memory_properties(physical_device, &mut memory_prop); + memory_prop } - fn get_physical_device_properties( + unsafe fn get_physical_device_properties( &self, physical_device: vk::PhysicalDevice, ) -> vk::PhysicalDeviceProperties { - unsafe { - let mut prop = mem::uninitialized(); - self.fp_v1_0() - .get_physical_device_properties(physical_device, &mut prop); - prop - } + let mut prop = mem::uninitialized(); + self.fp_v1_0() + .get_physical_device_properties(physical_device, &mut prop); + prop } - fn get_physical_device_queue_family_properties( + unsafe fn get_physical_device_queue_family_properties( &self, physical_device: vk::PhysicalDevice, ) -> Vec { - unsafe { - let mut queue_count = 0; - self.fp_v1_0().get_physical_device_queue_family_properties( - physical_device, - &mut queue_count, - ptr::null_mut(), - ); - let mut queue_families_vec = Vec::with_capacity(queue_count as usize); - self.fp_v1_0().get_physical_device_queue_family_properties( - physical_device, - &mut queue_count, - queue_families_vec.as_mut_ptr(), - ); - queue_families_vec.set_len(queue_count as usize); - queue_families_vec - } + let mut queue_count = 0; + self.fp_v1_0().get_physical_device_queue_family_properties( + physical_device, + &mut queue_count, + ptr::null_mut(), + ); + let mut queue_families_vec = Vec::with_capacity(queue_count as usize); + self.fp_v1_0().get_physical_device_queue_family_properties( + physical_device, + &mut queue_count, + queue_families_vec.as_mut_ptr(), + ); + queue_families_vec.set_len(queue_count as usize); + queue_families_vec } - fn get_physical_device_features( + unsafe fn get_physical_device_features( &self, physical_device: vk::PhysicalDevice, ) -> vk::PhysicalDeviceFeatures { - unsafe { - let mut prop = mem::uninitialized(); - self.fp_v1_0() - .get_physical_device_features(physical_device, &mut prop); - prop + let mut prop = mem::uninitialized(); + self.fp_v1_0() + .get_physical_device_features(physical_device, &mut prop); + prop + } + + unsafe fn enumerate_physical_devices(&self) -> VkResult> { + let mut num = mem::uninitialized(); + self.fp_v1_0() + .enumerate_physical_devices(self.handle(), &mut num, ptr::null_mut()); + let mut physical_devices = Vec::::with_capacity(num as usize); + let err_code = self.fp_v1_0().enumerate_physical_devices( + self.handle(), + &mut num, + physical_devices.as_mut_ptr(), + ); + physical_devices.set_len(num as usize); + match err_code { + vk::Result::SUCCESS => Ok(physical_devices), + _ => Err(err_code), } } - fn enumerate_physical_devices(&self) -> VkResult> { - unsafe { - let mut num = mem::uninitialized(); - self.fp_v1_0() - .enumerate_physical_devices(self.handle(), &mut num, ptr::null_mut()); - let mut physical_devices = Vec::::with_capacity(num as usize); - let err_code = self.fp_v1_0().enumerate_physical_devices( - self.handle(), - &mut num, - physical_devices.as_mut_ptr(), - ); - physical_devices.set_len(num as usize); - match err_code { - vk::Result::SUCCESS => Ok(physical_devices), - _ => Err(err_code), - } - } - } - - fn enumerate_device_extension_properties( + unsafe fn enumerate_device_extension_properties( &self, device: vk::PhysicalDevice, ) -> Result, vk::Result> { - unsafe { - let mut num = 0; - self.fp_v1_0().enumerate_device_extension_properties( - device, - ptr::null(), - &mut num, - ptr::null_mut(), - ); - let mut data = Vec::with_capacity(num as usize); - let err_code = self.fp_v1_0().enumerate_device_extension_properties( - device, - ptr::null(), - &mut num, - data.as_mut_ptr(), - ); - data.set_len(num as usize); - match err_code { - vk::Result::SUCCESS => Ok(data), - _ => Err(err_code), - } + let mut num = 0; + self.fp_v1_0().enumerate_device_extension_properties( + device, + ptr::null(), + &mut num, + ptr::null_mut(), + ); + let mut data = Vec::with_capacity(num as usize); + let err_code = self.fp_v1_0().enumerate_device_extension_properties( + device, + ptr::null(), + &mut num, + data.as_mut_ptr(), + ); + data.set_len(num as usize); + match err_code { + vk::Result::SUCCESS => Ok(data), + _ => Err(err_code), } } } From ffa09c5fd99824096d054000a1ed9894a69ef195 Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 7 Oct 2018 11:25:37 -0700 Subject: [PATCH 098/122] Expose suboptimal results from swapchain operations --- ash/src/extensions/swapchain.rs | 12 ++++++++---- examples/src/bin/texture.rs | 2 +- examples/src/bin/triangle.rs | 2 +- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/ash/src/extensions/swapchain.rs b/ash/src/extensions/swapchain.rs index 0a99708..8d630ef 100644 --- a/ash/src/extensions/swapchain.rs +++ b/ash/src/extensions/swapchain.rs @@ -43,13 +43,14 @@ impl Swapchain { ); } + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. pub unsafe fn acquire_next_image_khr( &self, swapchain: vk::SwapchainKHR, timeout: u64, semaphore: vk::Semaphore, fence: vk::Fence, - ) -> VkResult { + ) -> VkResult<(u32, bool)> { let mut index = mem::uninitialized(); let err_code = self.swapchain_fn.acquire_next_image_khr( self.handle, @@ -60,7 +61,8 @@ impl Swapchain { &mut index, ); match err_code { - vk::Result::SUCCESS => Ok(index), + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), _ => Err(err_code), } } @@ -83,14 +85,16 @@ impl Swapchain { } } + /// On success, returns whether the swapchain is suboptimal for the surface. pub unsafe fn queue_present_khr( &self, queue: vk::Queue, create_info: &vk::PresentInfoKHR, - ) -> VkResult<()> { + ) -> VkResult { let err_code = self.swapchain_fn.queue_present_khr(queue, create_info); match err_code { - vk::Result::SUCCESS => Ok(()), + vk::Result::SUCCESS => Ok(false), + vk::Result::SUBOPTIMAL_KHR => Ok(true), _ => Err(err_code), } } diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index d87df89..1381e82 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -876,7 +876,7 @@ fn main() { let graphic_pipeline = graphics_pipelines[0]; base.render_loop(|| { - let present_index = base + let (present_index, _) = base .swapchain_loader .acquire_next_image_khr( base.swapchain, diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index 12a3b85..f2f467b 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -461,7 +461,7 @@ fn main() { let graphic_pipeline = graphics_pipelines[0]; base.render_loop(|| { - let present_index = base + let (present_index, _) = base .swapchain_loader .acquire_next_image_khr( base.swapchain, From dd6f4f678c185b176d4682a538aa802518aa5fcd Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 7 Oct 2018 20:28:41 -0700 Subject: [PATCH 099/122] Fix Vulkan 1.1 getters --- ash/src/device.rs | 41 +++++++++++---------- ash/src/instance.rs | 87 ++++++++++++++++++++++++--------------------- 2 files changed, 69 insertions(+), 59 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index b6a2991..ffc84e5 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -35,7 +35,7 @@ pub trait DeviceV1_1: DeviceV1_0 { } } - unsafe fn get_device_group_peer_memory_features( + unsafe fn get_device_group_peer_memory_features( &self, heap_index: u32, local_device_index: u32, @@ -85,33 +85,31 @@ pub trait DeviceV1_1: DeviceV1_0 { unsafe fn get_image_memory_requirements2( &self, info: &vk::ImageMemoryRequirementsInfo2, - ) -> vk::MemoryRequirements2 { - let mut image_memory_requirements = mem::uninitialized(); + out: &mut vk::MemoryRequirements2, + ) { self.fp_v1_1().get_image_memory_requirements2( self.handle(), info, - &mut image_memory_requirements, + out, ); - image_memory_requirements } unsafe fn get_buffer_memory_requirements2( &self, info: &vk::BufferMemoryRequirementsInfo2, - ) -> vk::MemoryRequirements2 { - let mut image_memory_requirements = mem::uninitialized(); + out: &mut vk::MemoryRequirements2, + ) { self.fp_v1_1().get_buffer_memory_requirements2( self.handle(), info, - &mut image_memory_requirements, + out, ); - image_memory_requirements } - unsafe fn get_image_sparse_memory_requirements2( + unsafe fn get_image_sparse_memory_requirements2_len( &self, info: &vk::ImageSparseMemoryRequirementsInfo2, - ) -> Vec { + ) -> usize { let mut count = mem::uninitialized(); self.fp_v1_1().get_image_sparse_memory_requirements2( self.handle(), @@ -119,15 +117,21 @@ pub trait DeviceV1_1: DeviceV1_0 { &mut count, ptr::null_mut(), ); - let mut requirements = Vec::with_capacity(count as usize); + count as usize + } + + unsafe fn get_image_sparse_memory_requirements2( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2, + out: &mut [vk::SparseImageMemoryRequirements2], + ) { + let mut count = out.len() as u32; self.fp_v1_1().get_image_sparse_memory_requirements2( self.handle(), info, &mut count, - requirements.as_mut_ptr(), + out.as_mut_ptr(), ); - requirements.set_len(count as usize); - requirements } unsafe fn trim_command_pool( @@ -216,14 +220,13 @@ pub trait DeviceV1_1: DeviceV1_0 { unsafe fn get_descriptor_set_layout_support( &self, create_info: &vk::DescriptorSetLayoutCreateInfo, - ) -> vk::DescriptorSetLayoutSupport { - let mut descriptor_set_layout_support = mem::uninitialized(); + out: &mut vk::DescriptorSetLayoutSupport, + ) { self.fp_v1_1().get_descriptor_set_layout_support( self.handle(), create_info, - &mut descriptor_set_layout_support, + out, ); - descriptor_set_layout_support } } diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 4555ec9..3a6d0e6 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -87,25 +87,30 @@ impl Instance { pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; - fn enumerate_physical_device_groups(&self) -> VkResult> { + unsafe fn enumerate_physical_device_groups_len(&self) -> usize { + let mut group_count = mem::uninitialized(); + self.fp_v1_1().enumerate_physical_device_groups( + self.handle(), + &mut group_count, + ptr::null_mut(), + ); + group_count as usize + } + + fn enumerate_physical_device_groups( + &self, + out: &mut [vk::PhysicalDeviceGroupProperties] + ) -> VkResult<()> { unsafe { - let mut group_count = mem::uninitialized(); - self.fp_v1_1().enumerate_physical_device_groups( - self.handle(), - &mut group_count, - ptr::null_mut(), - ); - let mut physical_device_groups = Vec::with_capacity(group_count as usize); + let mut group_count = out.len() as u32; let err_code = self.fp_v1_1().enumerate_physical_device_groups( self.handle(), &mut group_count, - physical_device_groups.as_mut_ptr(), + out.as_mut_ptr(), ); - physical_device_groups.set_len(group_count as usize); - match err_code { - vk::Result::SUCCESS => Ok(physical_device_groups), - _ => Err(err_code), - } + if err_code == vk::Result::SUCCESS { + Ok(()) + } else { Err(err_code) } } } @@ -122,15 +127,14 @@ pub trait InstanceV1_1: InstanceV1_0 { &self, physical_device: vk::PhysicalDevice, format: vk::Format, - ) -> vk::FormatProperties2 { + out: &mut vk::FormatProperties2, + ) { unsafe { - let mut format_prop = mem::uninitialized(); self.fp_v1_1().get_physical_device_format_properties2( physical_device, format, - &mut format_prop, + out, ); - format_prop } } @@ -183,20 +187,19 @@ pub trait InstanceV1_1: InstanceV1_0 { fn get_physical_device_memory_properties2( &self, physical_device: vk::PhysicalDevice, - ) -> vk::PhysicalDeviceMemoryProperties2 { + out: &mut vk::PhysicalDeviceMemoryProperties2, + ) { unsafe { - let mut memory_prop = mem::uninitialized(); self.fp_v1_1() - .get_physical_device_memory_properties2(physical_device, &mut memory_prop); - memory_prop + .get_physical_device_memory_properties2(physical_device, out); } } - unsafe fn get_physical_device_sparse_image_format_properties2( + unsafe fn get_physical_device_sparse_image_format_properties2_len( &self, physical_device: vk::PhysicalDevice, format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, - ) -> Vec { + ) -> usize { let mut format_count = 0; self.fp_v1_1() .get_physical_device_sparse_image_format_properties2( @@ -205,61 +208,65 @@ pub trait InstanceV1_1: InstanceV1_0 { &mut format_count, ptr::null_mut(), ); - let mut format_prop = Vec::with_capacity(format_count as usize); + format_count as usize + } + + unsafe fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, + out: &mut [vk::SparseImageFormatProperties2], + ) { + let mut format_count = out.len() as u32; self.fp_v1_1() .get_physical_device_sparse_image_format_properties2( physical_device, format_info, &mut format_count, - format_prop.as_mut_ptr(), + out.as_mut_ptr(), ); - format_prop.set_len(format_count as usize); - format_prop } unsafe fn get_physical_device_external_buffer_properties( &self, physical_device: vk::PhysicalDevice, external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo, - ) -> vk::ExternalBufferProperties { - let mut image_format_prop = mem::uninitialized(); + out: &mut vk::ExternalBufferProperties, + ) { self.fp_v1_1() .get_physical_device_external_buffer_properties( physical_device, external_buffer_info, - &mut image_format_prop, + out, ); - image_format_prop } unsafe fn get_physical_device_external_fence_properties( &self, physical_device: vk::PhysicalDevice, external_fence_info: &vk::PhysicalDeviceExternalFenceInfo, - ) -> vk::ExternalFenceProperties { - let mut fence_prop = mem::uninitialized(); + out: &mut vk::ExternalFenceProperties, + ) { self.fp_v1_1() .get_physical_device_external_fence_properties( physical_device, external_fence_info, - &mut fence_prop, + out, ); - fence_prop } unsafe fn get_physical_device_external_semaphore_properties( &self, physical_device: vk::PhysicalDevice, external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo, - ) -> vk::ExternalSemaphoreProperties { - let mut semaphore_prop = mem::uninitialized(); + out: &mut vk::ExternalSemaphoreProperties, + ) { self.fp_v1_1() .get_physical_device_external_semaphore_properties( physical_device, external_semaphore_info, - &mut semaphore_prop, + out, ); - semaphore_prop } } From cd394db60fe0dcbb0d46f6b04a51aa51275ebe04 Mon Sep 17 00:00:00 2001 From: Benjamin Saunders Date: Sun, 7 Oct 2018 10:09:29 -0700 Subject: [PATCH 100/122] Wrap function pointers in Option since they might be null --- ash/src/vk.rs | 3482 +++++++++++++++++++++--------------------- examples/src/lib.rs | 2 +- generator/src/lib.rs | 15 +- 3 files changed, 1752 insertions(+), 1747 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 0c2f600..01547bc 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -4880,45 +4880,49 @@ handle_nondispatchable!(SwapchainKHR, SWAPCHAIN_KHR); handle_nondispatchable!(DebugReportCallbackEXT, DEBUG_REPORT_CALLBACK_EXT); handle_nondispatchable!(DebugUtilsMessengerEXT, DEBUG_UTILS_MESSENGER_EXT); #[allow(non_camel_case_types)] -pub type PFN_vkInternalAllocationNotification = +pub type PFN_vkInternalAllocationNotification = Option< unsafe extern "system" fn( p_user_data: *mut c_void, size: usize, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationScope, - ) -> c_void; + ) -> c_void, +>; #[allow(non_camel_case_types)] -pub type PFN_vkInternalFreeNotification = +pub type PFN_vkInternalFreeNotification = Option< unsafe extern "system" fn( p_user_data: *mut c_void, size: usize, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationScope, - ) -> c_void; + ) -> c_void, +>; #[allow(non_camel_case_types)] -pub type PFN_vkReallocationFunction = +pub type PFN_vkReallocationFunction = Option< unsafe extern "system" fn( p_user_data: *mut c_void, p_original: *mut c_void, size: usize, alignment: usize, allocation_scope: SystemAllocationScope, - ) -> *mut c_void; + ) -> *mut c_void, +>; #[allow(non_camel_case_types)] -pub type PFN_vkAllocationFunction = +pub type PFN_vkAllocationFunction = Option< unsafe extern "system" fn( p_user_data: *mut c_void, size: usize, alignment: usize, allocation_scope: SystemAllocationScope, - ) -> *mut c_void; + ) -> *mut c_void, +>; #[allow(non_camel_case_types)] pub type PFN_vkFreeFunction = - unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void) -> c_void; + Option c_void>; #[allow(non_camel_case_types)] -pub type PFN_vkVoidFunction = unsafe extern "system" fn() -> c_void; +pub type PFN_vkVoidFunction = Option c_void>; #[allow(non_camel_case_types)] -pub type PFN_vkDebugReportCallbackEXT = +pub type PFN_vkDebugReportCallbackEXT = Option< unsafe extern "system" fn( flags: DebugReportFlagsEXT, object_type: DebugReportObjectTypeEXT, @@ -4928,15 +4932,17 @@ pub type PFN_vkDebugReportCallbackEXT = p_layer_prefix: *const c_char, p_message: *const c_char, p_user_data: *mut c_void, - ) -> Bool32; + ) -> Bool32, +>; #[allow(non_camel_case_types)] -pub type PFN_vkDebugUtilsMessengerCallbackEXT = +pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option< unsafe extern "system" fn( message_severity: DebugUtilsMessageSeverityFlagsEXT, message_type: DebugUtilsMessageTypeFlagsEXT, p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, p_user_data: *mut c_void, - ) -> Bool32; + ) -> Bool32, +>; #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BaseOutStructure { @@ -5157,25 +5163,31 @@ impl fmt::Debug for AllocationCallbacks { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AllocationCallbacks") .field("p_user_data", &self.p_user_data) - .field("pfn_allocation", &(self.pfn_allocation as *const ())) - .field("pfn_reallocation", &(self.pfn_reallocation as *const ())) - .field("pfn_free", &(self.pfn_free as *const ())) + .field( + "pfn_allocation", + &(self.pfn_allocation.map(|x| x as *const ())), + ).field( + "pfn_reallocation", + &(self.pfn_reallocation.map(|x| x as *const ())), + ).field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) .field( "pfn_internal_allocation", - &(self.pfn_internal_allocation as *const ()), - ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) - .finish() + &(self.pfn_internal_allocation.map(|x| x as *const ())), + ).field( + "pfn_internal_free", + &(self.pfn_internal_free.map(|x| x as *const ())), + ).finish() } } impl ::std::default::Default for AllocationCallbacks { fn default() -> AllocationCallbacks { AllocationCallbacks { p_user_data: ::std::ptr::null_mut(), - pfn_allocation: unsafe { ::std::mem::zeroed() }, - pfn_reallocation: unsafe { ::std::mem::zeroed() }, - pfn_free: unsafe { ::std::mem::zeroed() }, - pfn_internal_allocation: unsafe { ::std::mem::zeroed() }, - pfn_internal_free: unsafe { ::std::mem::zeroed() }, + pfn_allocation: PFN_vkAllocationFunction::default(), + pfn_reallocation: PFN_vkReallocationFunction::default(), + pfn_free: PFN_vkFreeFunction::default(), + pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(), + pfn_internal_free: PFN_vkInternalFreeNotification::default(), } } } @@ -7475,7 +7487,7 @@ impl fmt::Debug for DebugReportCallbackCreateInfoEXT { .field("s_type", &self.s_type) .field("p_next", &self.p_next) .field("flags", &self.flags) - .field("pfn_callback", &(self.pfn_callback as *const ())) + .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ()))) .field("p_user_data", &self.p_user_data) .finish() } @@ -7486,7 +7498,7 @@ impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, p_next: ::std::ptr::null(), flags: DebugReportFlagsEXT::default(), - pfn_callback: unsafe { ::std::mem::zeroed() }, + pfn_callback: PFN_vkDebugReportCallbackEXT::default(), p_user_data: ::std::ptr::null_mut(), } } @@ -10651,8 +10663,10 @@ impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { .field("flags", &self.flags) .field("message_severity", &self.message_severity) .field("message_type", &self.message_type) - .field("pfn_user_callback", &(self.pfn_user_callback as *const ())) - .field("p_user_data", &self.p_user_data) + .field( + "pfn_user_callback", + &(self.pfn_user_callback.map(|x| x as *const ())), + ).field("p_user_data", &self.p_user_data) .finish() } } @@ -10664,7 +10678,7 @@ impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { flags: DebugUtilsMessengerCreateFlagsEXT::default(), message_severity: DebugUtilsMessageSeverityFlagsEXT::default(), message_type: DebugUtilsMessageTypeFlagsEXT::default(), - pfn_user_callback: unsafe { ::std::mem::zeroed() }, + pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(), p_user_data: ::std::ptr::null_mut(), } } @@ -22955,45 +22969,10 @@ fn display_flags( } Ok(()) } -impl fmt::Display for DebugReportObjectTypeEXT { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), _ => None, }; if let Some(x) = name { @@ -23003,26 +22982,41 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for QueryControlFlags { +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PrimitiveTopology { +impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } _ => None, }; if let Some(x) = name { @@ -23046,10 +23040,11 @@ impl fmt::Display for ValidationCheckEXT { } } } -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), _ => None, }; if let Some(x) = name { @@ -23059,9 +23054,321 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for FenceCreateFlags { +impl fmt::Display for ImageAspectFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; display_flags(f, KNOWN, self.0) } } @@ -23128,12 +23435,68 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for Filter { +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -23143,41 +23506,14 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -23187,14 +23523,48 @@ impl fmt::Display for FrontFace { } } } -impl fmt::Display for PeerMemoryFeatureFlags { +impl fmt::Display for BlendOverlapEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } @@ -23217,53 +23587,12 @@ impl fmt::Display for CommandBufferUsageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { +impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -23273,77 +23602,21 @@ impl fmt::Display for QueryType { } } } -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ChromaLocation { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), _ => None, }; if let Some(x) = name { @@ -23353,13 +23626,119 @@ impl fmt::Display for ChromaLocation { } } } -impl fmt::Display for QueueGlobalPriorityEXT { +impl fmt::Display for BlendFactor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -23382,12 +23761,18 @@ impl fmt::Display for StencilFaceFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for VendorId { +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), _ => None, }; if let Some(x) = name { @@ -23397,10 +23782,190 @@ impl fmt::Display for VendorId { } } } -impl fmt::Display for DescriptorUpdateTemplateType { +impl fmt::Display for ConservativeRasterizationModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -23420,237 +23985,38 @@ impl fmt::Display for DependencyFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { +impl fmt::Display for MemoryPropertyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), _ => None, }; if let Some(x) = name { @@ -23674,11 +24040,12 @@ impl fmt::Display for DisplayPlaneAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SharingMode { +impl fmt::Display for SamplerReductionModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), _ => None, }; if let Some(x) = name { @@ -23688,6 +24055,518 @@ impl fmt::Display for SharingMode { } } } +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -23720,13 +24599,16 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { @@ -23736,28 +24618,11 @@ impl fmt::Display for SamplerAddressMode { } } } -impl fmt::Display for BlendFactor { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -23810,11 +24675,147 @@ impl fmt::Display for PipelineStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageTiling { +impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), _ => None, }; if let Some(x) = name { @@ -23844,425 +24845,29 @@ impl fmt::Display for IndirectCommandsTokenTypeNVX { } } } -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", ), ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", ), ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", ), ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24703,6 +25308,112 @@ impl fmt::Display for StructureType { } } } +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for MemoryHeapFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -24712,24 +25423,10 @@ impl fmt::Display for MemoryHeapFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorSpaceKHR { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -24739,47 +25436,6 @@ impl fmt::Display for ColorSpaceKHR { } } } -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24797,448 +25453,10 @@ impl fmt::Display for ObjectEntryTypeNVX { } } } -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { +impl fmt::Display for DescriptorUpdateTemplateType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -25248,43 +25466,18 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { +impl fmt::Display for SparseMemoryBindFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), _ => None, }; if let Some(x) = name { @@ -25294,47 +25487,11 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), _ => None, }; if let Some(x) = name { @@ -25358,48 +25515,68 @@ impl fmt::Display for RasterizationOrderAMD { } } } -impl fmt::Display for DeviceEventTypeEXT { +impl fmt::Display for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) } } -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for QueryPipelineStatisticFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassContents { +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), _ => None, }; if let Some(x) = name { @@ -25409,21 +25586,85 @@ impl fmt::Display for SubpassContents { } } } -impl fmt::Display for SubpassDescriptionFlags { +impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25444,230 +25685,3 @@ impl fmt::Display for StencilOp { } } } -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 0209cb2..44e2196 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -310,7 +310,7 @@ impl ExampleBase { flags: vk::DebugReportFlagsEXT::ERROR | vk::DebugReportFlagsEXT::WARNING | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING, - pfn_callback: vulkan_debug_callback, + pfn_callback: Some(vulkan_debug_callback), p_user_data: ptr::null_mut(), }; let debug_report_loader = diff --git a/generator/src/lib.rs b/generator/src/lib.rs index da80d18..f94c30b 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1142,14 +1142,6 @@ pub fn derive_default(_struct: &vkxml::Struct) -> Option { _ => None, }); let is_structure_type = |field: &vkxml::Field| field.basetype == "VkStructureType"; - let is_pfn = |field: &vkxml::Field| { - field - .name - .as_ref() - .map(|n| n.contains("pfn")) - .unwrap_or(false) - }; - let contains_pfn = members.clone().any(is_pfn); // This are also pointers, and therefor also don't implement Default. The spec // also doesn't mark them as pointers @@ -1157,7 +1149,7 @@ pub fn derive_default(_struct: &vkxml::Struct) -> Option { let contains_ptr = members.clone().any(|field| field.reference.is_some()); let contains_strucutre_type = members.clone().any(is_structure_type); let contains_static_array = members.clone().any(is_static_array); - if !(contains_ptr || contains_pfn || contains_strucutre_type || contains_static_array) { + if !(contains_ptr || contains_strucutre_type || contains_static_array) { return None; }; let default_fields = members.clone().map(|field| { @@ -1209,7 +1201,6 @@ pub fn derive_default(_struct: &vkxml::Struct) -> Option { } } } else if is_static_array(field) - || is_pfn(field) || handles.contains(&field.basetype.as_str()) { quote!{ @@ -1266,7 +1257,7 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt } } else if param_ident.as_ref().contains("pfn") { quote!{ - &(self.#param_ident as *const()) + &(self.#param_ident.map(|x| x as *const ())) } } else if union_types.contains(field.basetype.as_str()) { quote!(&"union") @@ -1375,7 +1366,7 @@ fn generate_funcptr(fnptr: &vkxml::FunctionPointer) -> Tokens { }); quote!{ #[allow(non_camel_case_types)] - pub type #name = unsafe extern "system" fn(#(#params),*) -> #ret_ty_tokens; + pub type #name = Option #ret_ty_tokens>; } } From 5e2f231cf27e74af81e71eb9916f4c4ab7c397ad Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 23 Oct 2018 15:45:27 +0200 Subject: [PATCH 101/122] wl_* types are not pointers --- ash/src/vk.rs | 2706 +++++++++++++++++++++--------------------- generator/src/lib.rs | 4 +- 2 files changed, 1355 insertions(+), 1355 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 01547bc..8b12c08 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -48,9 +48,9 @@ pub type MirSurface = *const c_void; pub type HINSTANCE = *const c_void; pub type HWND = *const c_void; #[allow(non_camel_case_types)] -pub type wl_display = *const c_void; +pub type wl_display = c_void; #[allow(non_camel_case_types)] -pub type wl_surface = *const c_void; +pub type wl_surface = c_void; pub type HANDLE = *mut c_void; pub type DWORD = c_ulong; pub type LPCWSTR = *const u16; @@ -22969,10 +22969,483 @@ fn display_flags( } Ok(()) } -impl fmt::Display for DisplayEventTypeEXT { +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), _ => None, }; if let Some(x) = name { @@ -22997,207 +23470,21 @@ impl fmt::Display for SubpassDescriptionFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DiscardRectangleModeEXT { +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), _ => None, }; if let Some(x) = name { @@ -23228,150 +23515,195 @@ impl fmt::Display for ShaderStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { +impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", ), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", ), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -23435,68 +23767,87 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for BufferUsageFlags { +impl fmt::Display for AttachmentDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectType { +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -23506,14 +23857,14 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -23523,12 +23874,11 @@ impl fmt::Display for PhysicalDeviceType { } } } -impl fmt::Display for BlendOverlapEXT { +impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), _ => None, }; if let Some(x) = name { @@ -23538,61 +23888,70 @@ impl fmt::Display for BlendOverlapEXT { } } } -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", ), ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPowerStateEXT { +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), _ => None, }; if let Some(x) = name { @@ -23626,236 +23985,54 @@ impl fmt::Display for DynamicState { } } } -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, + CommandPoolResetFlags::RELEASE_RESOURCES.0, "RELEASE_RESOURCES", )]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for BufferCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", ), ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", ), ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PrimitiveTopology { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -23922,21 +24099,25 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { +impl fmt::Display for SampleCountFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrRange { +impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), _ => None, }; if let Some(x) = name { @@ -23946,127 +24127,6 @@ impl fmt::Display for SamplerYcbcrRange { } } } -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ColorSpaceKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24094,95 +24154,23 @@ impl fmt::Display for ColorSpaceKHR { } } } -impl fmt::Display for BorderColor { +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -24459,13 +24447,38 @@ impl fmt::Display for Format { } } } -impl fmt::Display for PeerMemoryFeatureFlags { +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), ]; display_flags(f, KNOWN, self.0) } @@ -24486,11 +24499,10 @@ impl fmt::Display for SubgroupFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageTiling { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -24500,29 +24512,170 @@ impl fmt::Display for ImageTiling { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for CoverageModulationModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24539,62 +24692,18 @@ impl fmt::Display for CoverageModulationModeNV { } } } -impl fmt::Display for SurfaceTransformFlagsKHR { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } @@ -24618,83 +24727,25 @@ impl fmt::Display for ImageViewType { } } } -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { +impl fmt::Display for ExternalMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", ), ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", ), ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -24743,131 +24794,6 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25308,12 +25234,10 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for ShaderInfoTypeAMD { +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -25323,61 +25247,152 @@ impl fmt::Display for ShaderInfoTypeAMD { } } } -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", ), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), _ => None, }; if let Some(x) = name { @@ -25414,70 +25429,75 @@ impl fmt::Display for ExternalSemaphoreHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryHeapFlags { +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for ImageUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryType { +impl fmt::Display for BorderColor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), _ => None, }; if let Some(x) = name { @@ -25487,11 +25507,12 @@ impl fmt::Display for QueryType { } } } -impl fmt::Display for SharingMode { +impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -25501,11 +25522,34 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for RasterizationOrderAMD { +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), _ => None, }; if let Some(x) = name { @@ -25515,167 +25559,123 @@ impl fmt::Display for RasterizationOrderAMD { } } } +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryPipelineStatisticFlags { +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", ), ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), _ => None, }; if let Some(x) = name { diff --git a/generator/src/lib.rs b/generator/src/lib.rs index f94c30b..f1a359b 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -357,9 +357,9 @@ pub fn platform_specific_types() -> Tokens { pub type HINSTANCE = *const c_void; pub type HWND = *const c_void; #[allow(non_camel_case_types)] - pub type wl_display = *const c_void; + pub type wl_display = c_void; #[allow(non_camel_case_types)] - pub type wl_surface = *const c_void; + pub type wl_surface = c_void; pub type HANDLE = *mut c_void; pub type DWORD = c_ulong; pub type LPCWSTR = *const u16; From 0c70322d2256d5af6ee54ea063398394940af4a8 Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Fri, 19 Oct 2018 22:16:35 +0200 Subject: [PATCH 102/122] Implementation of setters --- ash/src/vk.rs | 19882 ++++++++++++++++++++++++++++++++++++----- generator/src/lib.rs | 149 + 2 files changed, 17901 insertions(+), 2130 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 8b12c08..40db6ef 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -463,18 +463,18 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: - self.get_physical_device_image_format_properties, + get_physical_device_image_format_properties: self + .get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: - self.get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: self + .get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: - self.get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: self + .get_physical_device_sparse_image_format_properties, } } } @@ -3956,19 +3956,19 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: - self.get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: - self.get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: self + .get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: self + .get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: - self.get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: - self.get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: - self.get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: - self.get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: self + .get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: self + .get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: self + .get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: self + .get_physical_device_external_semaphore_properties, } } } @@ -4957,6 +4957,29 @@ impl ::std::default::Default for BaseOutStructure { } } } +impl BaseOutStructure { + pub fn builder<'a>() -> BaseOutStructureBuilder<'a> { + BaseOutStructureBuilder { + inner: BaseOutStructure::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BaseOutStructureBuilder<'a> { + inner: BaseOutStructure, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BaseOutStructureBuilder<'a> { + type Target = BaseOutStructure; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BaseOutStructureBuilder<'a> { + pub fn build(self) -> BaseOutStructure { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BaseInStructure { @@ -4971,12 +4994,66 @@ impl ::std::default::Default for BaseInStructure { } } } +impl BaseInStructure { + pub fn builder<'a>() -> BaseInStructureBuilder<'a> { + BaseInStructureBuilder { + inner: BaseInStructure::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BaseInStructureBuilder<'a> { + inner: BaseInStructure, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BaseInStructureBuilder<'a> { + type Target = BaseInStructure; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BaseInStructureBuilder<'a> { + pub fn build(self) -> BaseInStructure { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Offset2D { pub x: i32, pub y: i32, } +impl Offset2D { + pub fn builder<'a>() -> Offset2DBuilder<'a> { + Offset2DBuilder { + inner: Offset2D::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Offset2DBuilder<'a> { + inner: Offset2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> { + type Target = Offset2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Offset2DBuilder<'a> { + pub fn x(mut self, x: i32) -> Offset2DBuilder<'a> { + self.inner.x = x; + self + } + pub fn y(mut self, y: i32) -> Offset2DBuilder<'a> { + self.inner.y = y; + self + } + pub fn build(self) -> Offset2D { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Offset3D { @@ -4984,12 +5061,78 @@ pub struct Offset3D { pub y: i32, pub z: i32, } +impl Offset3D { + pub fn builder<'a>() -> Offset3DBuilder<'a> { + Offset3DBuilder { + inner: Offset3D::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Offset3DBuilder<'a> { + inner: Offset3D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> { + type Target = Offset3D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Offset3DBuilder<'a> { + pub fn x(mut self, x: i32) -> Offset3DBuilder<'a> { + self.inner.x = x; + self + } + pub fn y(mut self, y: i32) -> Offset3DBuilder<'a> { + self.inner.y = y; + self + } + pub fn z(mut self, z: i32) -> Offset3DBuilder<'a> { + self.inner.z = z; + self + } + pub fn build(self) -> Offset3D { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Extent2D { pub width: u32, pub height: u32, } +impl Extent2D { + pub fn builder<'a>() -> Extent2DBuilder<'a> { + Extent2DBuilder { + inner: Extent2D::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Extent2DBuilder<'a> { + inner: Extent2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> { + type Target = Extent2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Extent2DBuilder<'a> { + pub fn width(mut self, width: u32) -> Extent2DBuilder<'a> { + self.inner.width = width; + self + } + pub fn height(mut self, height: u32) -> Extent2DBuilder<'a> { + self.inner.height = height; + self + } + pub fn build(self) -> Extent2D { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)] pub struct Extent3D { @@ -4997,6 +5140,41 @@ pub struct Extent3D { pub height: u32, pub depth: u32, } +impl Extent3D { + pub fn builder<'a>() -> Extent3DBuilder<'a> { + Extent3DBuilder { + inner: Extent3D::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Extent3DBuilder<'a> { + inner: Extent3D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> { + type Target = Extent3D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Extent3DBuilder<'a> { + pub fn width(mut self, width: u32) -> Extent3DBuilder<'a> { + self.inner.width = width; + self + } + pub fn height(mut self, height: u32) -> Extent3DBuilder<'a> { + self.inner.height = height; + self + } + pub fn depth(mut self, depth: u32) -> Extent3DBuilder<'a> { + self.inner.depth = depth; + self + } + pub fn build(self) -> Extent3D { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Viewport { @@ -5007,12 +5185,90 @@ pub struct Viewport { pub min_depth: c_float, pub max_depth: c_float, } +impl Viewport { + pub fn builder<'a>() -> ViewportBuilder<'a> { + ViewportBuilder { + inner: Viewport::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ViewportBuilder<'a> { + inner: Viewport, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportBuilder<'a> { + type Target = Viewport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ViewportBuilder<'a> { + pub fn x(mut self, x: c_float) -> ViewportBuilder<'a> { + self.inner.x = x; + self + } + pub fn y(mut self, y: c_float) -> ViewportBuilder<'a> { + self.inner.y = y; + self + } + pub fn width(mut self, width: c_float) -> ViewportBuilder<'a> { + self.inner.width = width; + self + } + pub fn height(mut self, height: c_float) -> ViewportBuilder<'a> { + self.inner.height = height; + self + } + pub fn min_depth(mut self, min_depth: c_float) -> ViewportBuilder<'a> { + self.inner.min_depth = min_depth; + self + } + pub fn max_depth(mut self, max_depth: c_float) -> ViewportBuilder<'a> { + self.inner.max_depth = max_depth; + self + } + pub fn build(self) -> Viewport { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct Rect2D { pub offset: Offset2D, pub extent: Extent2D, } +impl Rect2D { + pub fn builder<'a>() -> Rect2DBuilder<'a> { + Rect2DBuilder { + inner: Rect2D::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Rect2DBuilder<'a> { + inner: Rect2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> { + type Target = Rect2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Rect2DBuilder<'a> { + pub fn offset(mut self, offset: Offset2D) -> Rect2DBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn extent(mut self, extent: Extent2D) -> Rect2DBuilder<'a> { + self.inner.extent = extent; + self + } + pub fn build(self) -> Rect2D { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ClearRect { @@ -5020,6 +5276,41 @@ pub struct ClearRect { pub base_array_layer: u32, pub layer_count: u32, } +impl ClearRect { + pub fn builder<'a>() -> ClearRectBuilder<'a> { + ClearRectBuilder { + inner: ClearRect::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ClearRectBuilder<'a> { + inner: ClearRect, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> { + type Target = ClearRect; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ClearRectBuilder<'a> { + pub fn rect(mut self, rect: Rect2D) -> ClearRectBuilder<'a> { + self.inner.rect = rect; + self + } + pub fn base_array_layer(mut self, base_array_layer: u32) -> ClearRectBuilder<'a> { + self.inner.base_array_layer = base_array_layer; + self + } + pub fn layer_count(mut self, layer_count: u32) -> ClearRectBuilder<'a> { + self.inner.layer_count = layer_count; + self + } + pub fn build(self) -> ClearRect { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ComponentMapping { @@ -5028,6 +5319,45 @@ pub struct ComponentMapping { pub b: ComponentSwizzle, pub a: ComponentSwizzle, } +impl ComponentMapping { + pub fn builder<'a>() -> ComponentMappingBuilder<'a> { + ComponentMappingBuilder { + inner: ComponentMapping::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ComponentMappingBuilder<'a> { + inner: ComponentMapping, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> { + type Target = ComponentMapping; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ComponentMappingBuilder<'a> { + pub fn r(mut self, r: ComponentSwizzle) -> ComponentMappingBuilder<'a> { + self.inner.r = r; + self + } + pub fn g(mut self, g: ComponentSwizzle) -> ComponentMappingBuilder<'a> { + self.inner.g = g; + self + } + pub fn b(mut self, b: ComponentSwizzle) -> ComponentMappingBuilder<'a> { + self.inner.b = b; + self + } + pub fn a(mut self, a: ComponentSwizzle) -> ComponentMappingBuilder<'a> { + self.inner.a = a; + self + } + pub fn build(self) -> ComponentMapping { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct PhysicalDeviceProperties { @@ -5051,7 +5381,8 @@ impl fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }).field("pipeline_cache_uuid", &self.pipeline_cache_uuid) + }) + .field("pipeline_cache_uuid", &self.pipeline_cache_uuid) .field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() @@ -5072,6 +5403,77 @@ impl ::std::default::Default for PhysicalDeviceProperties { } } } +impl PhysicalDeviceProperties { + pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> { + PhysicalDevicePropertiesBuilder { + inner: PhysicalDeviceProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDevicePropertiesBuilder<'a> { + inner: PhysicalDeviceProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> { + type Target = PhysicalDeviceProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDevicePropertiesBuilder<'a> { + pub fn api_version(mut self, api_version: u32) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.api_version = api_version; + self + } + pub fn driver_version(mut self, driver_version: u32) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.driver_version = driver_version; + self + } + pub fn vendor_id(mut self, vendor_id: u32) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.vendor_id = vendor_id; + self + } + pub fn device_id(mut self, device_id: u32) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.device_id = device_id; + self + } + pub fn device_type( + mut self, + device_type: PhysicalDeviceType, + ) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.device_type = device_type; + self + } + pub fn device_name( + mut self, + device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE], + ) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.device_name = device_name; + self + } + pub fn pipeline_cache_uuid( + mut self, + pipeline_cache_uuid: [u8; UUID_SIZE], + ) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + pub fn limits(mut self, limits: PhysicalDeviceLimits) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.limits = limits; + self + } + pub fn sparse_properties( + mut self, + sparse_properties: PhysicalDeviceSparseProperties, + ) -> PhysicalDevicePropertiesBuilder<'a> { + self.inner.sparse_properties = sparse_properties; + self + } + pub fn build(self) -> PhysicalDeviceProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct ExtensionProperties { @@ -5083,7 +5485,8 @@ impl fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .finish() } } @@ -5095,6 +5498,40 @@ impl ::std::default::Default for ExtensionProperties { } } } +impl ExtensionProperties { + pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> { + ExtensionPropertiesBuilder { + inner: ExtensionProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExtensionPropertiesBuilder<'a> { + inner: ExtensionProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> { + type Target = ExtensionProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExtensionPropertiesBuilder<'a> { + pub fn extension_name( + mut self, + extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], + ) -> ExtensionPropertiesBuilder<'a> { + self.inner.extension_name = extension_name; + self + } + pub fn spec_version(mut self, spec_version: u32) -> ExtensionPropertiesBuilder<'a> { + self.inner.spec_version = spec_version; + self + } + pub fn build(self) -> ExtensionProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct LayerProperties { @@ -5108,11 +5545,13 @@ impl fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }).field("spec_version", &self.spec_version) + }) + .field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }).finish() + }) + .finish() } } impl ::std::default::Default for LayerProperties { @@ -5125,6 +5564,54 @@ impl ::std::default::Default for LayerProperties { } } } +impl LayerProperties { + pub fn builder<'a>() -> LayerPropertiesBuilder<'a> { + LayerPropertiesBuilder { + inner: LayerProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct LayerPropertiesBuilder<'a> { + inner: LayerProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> { + type Target = LayerProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> LayerPropertiesBuilder<'a> { + pub fn layer_name( + mut self, + layer_name: [c_char; MAX_EXTENSION_NAME_SIZE], + ) -> LayerPropertiesBuilder<'a> { + self.inner.layer_name = layer_name; + self + } + pub fn spec_version(mut self, spec_version: u32) -> LayerPropertiesBuilder<'a> { + self.inner.spec_version = spec_version; + self + } + pub fn implementation_version( + mut self, + implementation_version: u32, + ) -> LayerPropertiesBuilder<'a> { + self.inner.implementation_version = implementation_version; + self + } + pub fn description( + mut self, + description: [c_char; MAX_DESCRIPTION_SIZE], + ) -> LayerPropertiesBuilder<'a> { + self.inner.description = description; + self + } + pub fn build(self) -> LayerProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ApplicationInfo { @@ -5149,6 +5636,52 @@ impl ::std::default::Default for ApplicationInfo { } } } +impl ApplicationInfo { + pub fn builder<'a>() -> ApplicationInfoBuilder<'a> { + ApplicationInfoBuilder { + inner: ApplicationInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ApplicationInfoBuilder<'a> { + inner: ApplicationInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> { + type Target = ApplicationInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ApplicationInfoBuilder<'a> { + pub fn application_name( + mut self, + application_name: &'a ::std::ffi::CStr, + ) -> ApplicationInfoBuilder<'a> { + self.inner.p_application_name = application_name.as_ptr(); + self + } + pub fn application_version(mut self, application_version: u32) -> ApplicationInfoBuilder<'a> { + self.inner.application_version = application_version; + self + } + pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> ApplicationInfoBuilder<'a> { + self.inner.p_engine_name = engine_name.as_ptr(); + self + } + pub fn engine_version(mut self, engine_version: u32) -> ApplicationInfoBuilder<'a> { + self.inner.engine_version = engine_version; + self + } + pub fn api_version(mut self, api_version: u32) -> ApplicationInfoBuilder<'a> { + self.inner.api_version = api_version; + self + } + pub fn build(self) -> ApplicationInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct AllocationCallbacks { @@ -5166,17 +5699,21 @@ impl fmt::Debug for AllocationCallbacks { .field( "pfn_allocation", &(self.pfn_allocation.map(|x| x as *const ())), - ).field( + ) + .field( "pfn_reallocation", &(self.pfn_reallocation.map(|x| x as *const ())), - ).field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) + ) + .field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) .field( "pfn_internal_allocation", &(self.pfn_internal_allocation.map(|x| x as *const ())), - ).field( + ) + .field( "pfn_internal_free", &(self.pfn_internal_free.map(|x| x as *const ())), - ).finish() + ) + .finish() } } impl ::std::default::Default for AllocationCallbacks { @@ -5191,6 +5728,65 @@ impl ::std::default::Default for AllocationCallbacks { } } } +impl AllocationCallbacks { + pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> { + AllocationCallbacksBuilder { + inner: AllocationCallbacks::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AllocationCallbacksBuilder<'a> { + inner: AllocationCallbacks, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> { + type Target = AllocationCallbacks; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AllocationCallbacksBuilder<'a> { + pub fn user_data(mut self, user_data: *mut c_void) -> AllocationCallbacksBuilder<'a> { + self.inner.p_user_data = user_data; + self + } + pub fn pfn_allocation( + mut self, + pfn_allocation: PFN_vkAllocationFunction, + ) -> AllocationCallbacksBuilder<'a> { + self.inner.pfn_allocation = pfn_allocation; + self + } + pub fn pfn_reallocation( + mut self, + pfn_reallocation: PFN_vkReallocationFunction, + ) -> AllocationCallbacksBuilder<'a> { + self.inner.pfn_reallocation = pfn_reallocation; + self + } + pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> AllocationCallbacksBuilder<'a> { + self.inner.pfn_free = pfn_free; + self + } + pub fn pfn_internal_allocation( + mut self, + pfn_internal_allocation: PFN_vkInternalAllocationNotification, + ) -> AllocationCallbacksBuilder<'a> { + self.inner.pfn_internal_allocation = pfn_internal_allocation; + self + } + pub fn pfn_internal_free( + mut self, + pfn_internal_free: PFN_vkInternalFreeNotification, + ) -> AllocationCallbacksBuilder<'a> { + self.inner.pfn_internal_free = pfn_internal_free; + self + } + pub fn build(self) -> AllocationCallbacks { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceQueueCreateInfo { @@ -5213,6 +5809,52 @@ impl ::std::default::Default for DeviceQueueCreateInfo { } } } +impl DeviceQueueCreateInfo { + pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> { + DeviceQueueCreateInfoBuilder { + inner: DeviceQueueCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceQueueCreateInfoBuilder<'a> { + inner: DeviceQueueCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> { + type Target = DeviceQueueCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceQueueCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn queue_family_index( + mut self, + queue_family_index: u32, + ) -> DeviceQueueCreateInfoBuilder<'a> { + self.inner.queue_family_index = queue_family_index; + self + } + pub fn queue_count(mut self, queue_count: u32) -> DeviceQueueCreateInfoBuilder<'a> { + self.inner.queue_count = queue_count; + self + } + pub fn queue_priorities( + mut self, + queue_priorities: &'a [c_float], + ) -> DeviceQueueCreateInfoBuilder<'a> { + self.inner.queue_count = queue_priorities.len() as u32; + self.inner.p_queue_priorities = queue_priorities.as_ptr(); + self + } + pub fn build(self) -> DeviceQueueCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceCreateInfo { @@ -5243,6 +5885,82 @@ impl ::std::default::Default for DeviceCreateInfo { } } } +impl DeviceCreateInfo { + pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> { + DeviceCreateInfoBuilder { + inner: DeviceCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceCreateInfoBuilder<'a> { + inner: DeviceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> { + type Target = DeviceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: DeviceCreateFlags) -> DeviceCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn queue_create_info_count( + mut self, + queue_create_info_count: u32, + ) -> DeviceCreateInfoBuilder<'a> { + self.inner.queue_create_info_count = queue_create_info_count; + self + } + pub fn queue_create_infos( + mut self, + queue_create_infos: &'a [DeviceQueueCreateInfo], + ) -> DeviceCreateInfoBuilder<'a> { + self.inner.queue_create_info_count = queue_create_infos.len() as u32; + self.inner.p_queue_create_infos = queue_create_infos.as_ptr(); + self + } + pub fn enabled_layer_count(mut self, enabled_layer_count: u32) -> DeviceCreateInfoBuilder<'a> { + self.inner.enabled_layer_count = enabled_layer_count; + self + } + pub fn enabled_layer_names( + mut self, + enabled_layer_names: &'a [*const c_char], + ) -> DeviceCreateInfoBuilder<'a> { + self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self.inner.enabled_layer_count = enabled_layer_names.len() as u32; + self + } + pub fn enabled_extension_count( + mut self, + enabled_extension_count: u32, + ) -> DeviceCreateInfoBuilder<'a> { + self.inner.enabled_extension_count = enabled_extension_count; + self + } + pub fn enabled_extension_names( + mut self, + enabled_extension_names: &'a [*const c_char], + ) -> DeviceCreateInfoBuilder<'a> { + self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self.inner.enabled_extension_count = enabled_extension_names.len() as u32; + self + } + pub fn enabled_features( + mut self, + enabled_features: *const PhysicalDeviceFeatures, + ) -> DeviceCreateInfoBuilder<'a> { + self.inner.p_enabled_features = enabled_features; + self + } + pub fn build(self) -> DeviceCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct InstanceCreateInfo { @@ -5269,6 +5987,70 @@ impl ::std::default::Default for InstanceCreateInfo { } } } +impl InstanceCreateInfo { + pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> { + InstanceCreateInfoBuilder { + inner: InstanceCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct InstanceCreateInfoBuilder<'a> { + inner: InstanceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> { + type Target = InstanceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> InstanceCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: InstanceCreateFlags) -> InstanceCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn application_info( + mut self, + application_info: &'a ApplicationInfo, + ) -> InstanceCreateInfoBuilder<'a> { + self.inner.p_application_info = application_info; + self + } + pub fn enabled_layer_count( + mut self, + enabled_layer_count: u32, + ) -> InstanceCreateInfoBuilder<'a> { + self.inner.enabled_layer_count = enabled_layer_count; + self + } + pub fn enabled_layer_names( + mut self, + enabled_layer_names: &'a [*const c_char], + ) -> InstanceCreateInfoBuilder<'a> { + self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self.inner.enabled_layer_count = enabled_layer_names.len() as u32; + self + } + pub fn enabled_extension_count( + mut self, + enabled_extension_count: u32, + ) -> InstanceCreateInfoBuilder<'a> { + self.inner.enabled_extension_count = enabled_extension_count; + self + } + pub fn enabled_extension_names( + mut self, + enabled_extension_names: &'a [*const c_char], + ) -> InstanceCreateInfoBuilder<'a> { + self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self.inner.enabled_extension_count = enabled_extension_names.len() as u32; + self + } + pub fn build(self) -> InstanceCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct QueueFamilyProperties { @@ -5277,6 +6059,51 @@ pub struct QueueFamilyProperties { pub timestamp_valid_bits: u32, pub min_image_transfer_granularity: Extent3D, } +impl QueueFamilyProperties { + pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> { + QueueFamilyPropertiesBuilder { + inner: QueueFamilyProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct QueueFamilyPropertiesBuilder<'a> { + inner: QueueFamilyProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> { + type Target = QueueFamilyProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> QueueFamilyPropertiesBuilder<'a> { + pub fn queue_flags(mut self, queue_flags: QueueFlags) -> QueueFamilyPropertiesBuilder<'a> { + self.inner.queue_flags = queue_flags; + self + } + pub fn queue_count(mut self, queue_count: u32) -> QueueFamilyPropertiesBuilder<'a> { + self.inner.queue_count = queue_count; + self + } + pub fn timestamp_valid_bits( + mut self, + timestamp_valid_bits: u32, + ) -> QueueFamilyPropertiesBuilder<'a> { + self.inner.timestamp_valid_bits = timestamp_valid_bits; + self + } + pub fn min_image_transfer_granularity( + mut self, + min_image_transfer_granularity: Extent3D, + ) -> QueueFamilyPropertiesBuilder<'a> { + self.inner.min_image_transfer_granularity = min_image_transfer_granularity; + self + } + pub fn build(self) -> QueueFamilyProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMemoryProperties { @@ -5295,6 +6122,57 @@ impl ::std::default::Default for PhysicalDeviceMemoryProperties { } } } +impl PhysicalDeviceMemoryProperties { + pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> { + PhysicalDeviceMemoryPropertiesBuilder { + inner: PhysicalDeviceMemoryProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> { + inner: PhysicalDeviceMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> { + type Target = PhysicalDeviceMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> { + pub fn memory_type_count( + mut self, + memory_type_count: u32, + ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> { + self.inner.memory_type_count = memory_type_count; + self + } + pub fn memory_types( + mut self, + memory_types: [MemoryType; MAX_MEMORY_TYPES], + ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> { + self.inner.memory_types = memory_types; + self + } + pub fn memory_heap_count( + mut self, + memory_heap_count: u32, + ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> { + self.inner.memory_heap_count = memory_heap_count; + self + } + pub fn memory_heaps( + mut self, + memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], + ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> { + self.inner.memory_heaps = memory_heaps; + self + } + pub fn build(self) -> PhysicalDeviceMemoryProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryAllocateInfo { @@ -5313,6 +6191,37 @@ impl ::std::default::Default for MemoryAllocateInfo { } } } +impl MemoryAllocateInfo { + pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> { + MemoryAllocateInfoBuilder { + inner: MemoryAllocateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryAllocateInfoBuilder<'a> { + inner: MemoryAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> { + type Target = MemoryAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryAllocateInfoBuilder<'a> { + pub fn allocation_size(mut self, allocation_size: DeviceSize) -> MemoryAllocateInfoBuilder<'a> { + self.inner.allocation_size = allocation_size; + self + } + pub fn memory_type_index(mut self, memory_type_index: u32) -> MemoryAllocateInfoBuilder<'a> { + self.inner.memory_type_index = memory_type_index; + self + } + pub fn build(self) -> MemoryAllocateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct MemoryRequirements { @@ -5320,6 +6229,41 @@ pub struct MemoryRequirements { pub alignment: DeviceSize, pub memory_type_bits: u32, } +impl MemoryRequirements { + pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> { + MemoryRequirementsBuilder { + inner: MemoryRequirements::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryRequirementsBuilder<'a> { + inner: MemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> { + type Target = MemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryRequirementsBuilder<'a> { + pub fn size(mut self, size: DeviceSize) -> MemoryRequirementsBuilder<'a> { + self.inner.size = size; + self + } + pub fn alignment(mut self, alignment: DeviceSize) -> MemoryRequirementsBuilder<'a> { + self.inner.alignment = alignment; + self + } + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> MemoryRequirementsBuilder<'a> { + self.inner.memory_type_bits = memory_type_bits; + self + } + pub fn build(self) -> MemoryRequirements { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SparseImageFormatProperties { @@ -5327,6 +6271,50 @@ pub struct SparseImageFormatProperties { pub image_granularity: Extent3D, pub flags: SparseImageFormatFlags, } +impl SparseImageFormatProperties { + pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> { + SparseImageFormatPropertiesBuilder { + inner: SparseImageFormatProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseImageFormatPropertiesBuilder<'a> { + inner: SparseImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> { + type Target = SparseImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseImageFormatPropertiesBuilder<'a> { + pub fn aspect_mask( + mut self, + aspect_mask: ImageAspectFlags, + ) -> SparseImageFormatPropertiesBuilder<'a> { + self.inner.aspect_mask = aspect_mask; + self + } + pub fn image_granularity( + mut self, + image_granularity: Extent3D, + ) -> SparseImageFormatPropertiesBuilder<'a> { + self.inner.image_granularity = image_granularity; + self + } + pub fn flags( + mut self, + flags: SparseImageFormatFlags, + ) -> SparseImageFormatPropertiesBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> SparseImageFormatProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SparseImageMemoryRequirements { @@ -5336,18 +6324,138 @@ pub struct SparseImageMemoryRequirements { pub image_mip_tail_offset: DeviceSize, pub image_mip_tail_stride: DeviceSize, } +impl SparseImageMemoryRequirements { + pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> { + SparseImageMemoryRequirementsBuilder { + inner: SparseImageMemoryRequirements::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseImageMemoryRequirementsBuilder<'a> { + inner: SparseImageMemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> { + type Target = SparseImageMemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseImageMemoryRequirementsBuilder<'a> { + pub fn format_properties( + mut self, + format_properties: SparseImageFormatProperties, + ) -> SparseImageMemoryRequirementsBuilder<'a> { + self.inner.format_properties = format_properties; + self + } + pub fn image_mip_tail_first_lod( + mut self, + image_mip_tail_first_lod: u32, + ) -> SparseImageMemoryRequirementsBuilder<'a> { + self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod; + self + } + pub fn image_mip_tail_size( + mut self, + image_mip_tail_size: DeviceSize, + ) -> SparseImageMemoryRequirementsBuilder<'a> { + self.inner.image_mip_tail_size = image_mip_tail_size; + self + } + pub fn image_mip_tail_offset( + mut self, + image_mip_tail_offset: DeviceSize, + ) -> SparseImageMemoryRequirementsBuilder<'a> { + self.inner.image_mip_tail_offset = image_mip_tail_offset; + self + } + pub fn image_mip_tail_stride( + mut self, + image_mip_tail_stride: DeviceSize, + ) -> SparseImageMemoryRequirementsBuilder<'a> { + self.inner.image_mip_tail_stride = image_mip_tail_stride; + self + } + pub fn build(self) -> SparseImageMemoryRequirements { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct MemoryType { pub property_flags: MemoryPropertyFlags, pub heap_index: u32, } +impl MemoryType { + pub fn builder<'a>() -> MemoryTypeBuilder<'a> { + MemoryTypeBuilder { + inner: MemoryType::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryTypeBuilder<'a> { + inner: MemoryType, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> { + type Target = MemoryType; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryTypeBuilder<'a> { + pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> MemoryTypeBuilder<'a> { + self.inner.property_flags = property_flags; + self + } + pub fn heap_index(mut self, heap_index: u32) -> MemoryTypeBuilder<'a> { + self.inner.heap_index = heap_index; + self + } + pub fn build(self) -> MemoryType { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct MemoryHeap { pub size: DeviceSize, pub flags: MemoryHeapFlags, } +impl MemoryHeap { + pub fn builder<'a>() -> MemoryHeapBuilder<'a> { + MemoryHeapBuilder { + inner: MemoryHeap::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryHeapBuilder<'a> { + inner: MemoryHeap, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> { + type Target = MemoryHeap; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryHeapBuilder<'a> { + pub fn size(mut self, size: DeviceSize) -> MemoryHeapBuilder<'a> { + self.inner.size = size; + self + } + pub fn flags(mut self, flags: MemoryHeapFlags) -> MemoryHeapBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> MemoryHeap { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MappedMemoryRange { @@ -5368,6 +6476,41 @@ impl ::std::default::Default for MappedMemoryRange { } } } +impl MappedMemoryRange { + pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> { + MappedMemoryRangeBuilder { + inner: MappedMemoryRange::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MappedMemoryRangeBuilder<'a> { + inner: MappedMemoryRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> { + type Target = MappedMemoryRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MappedMemoryRangeBuilder<'a> { + pub fn memory(mut self, memory: DeviceMemory) -> MappedMemoryRangeBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn offset(mut self, offset: DeviceSize) -> MappedMemoryRangeBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn size(mut self, size: DeviceSize) -> MappedMemoryRangeBuilder<'a> { + self.inner.size = size; + self + } + pub fn build(self) -> MappedMemoryRange { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct FormatProperties { @@ -5375,6 +6518,50 @@ pub struct FormatProperties { pub optimal_tiling_features: FormatFeatureFlags, pub buffer_features: FormatFeatureFlags, } +impl FormatProperties { + pub fn builder<'a>() -> FormatPropertiesBuilder<'a> { + FormatPropertiesBuilder { + inner: FormatProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct FormatPropertiesBuilder<'a> { + inner: FormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> { + type Target = FormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> FormatPropertiesBuilder<'a> { + pub fn linear_tiling_features( + mut self, + linear_tiling_features: FormatFeatureFlags, + ) -> FormatPropertiesBuilder<'a> { + self.inner.linear_tiling_features = linear_tiling_features; + self + } + pub fn optimal_tiling_features( + mut self, + optimal_tiling_features: FormatFeatureFlags, + ) -> FormatPropertiesBuilder<'a> { + self.inner.optimal_tiling_features = optimal_tiling_features; + self + } + pub fn buffer_features( + mut self, + buffer_features: FormatFeatureFlags, + ) -> FormatPropertiesBuilder<'a> { + self.inner.buffer_features = buffer_features; + self + } + pub fn build(self) -> FormatProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageFormatProperties { @@ -5384,6 +6571,55 @@ pub struct ImageFormatProperties { pub sample_counts: SampleCountFlags, pub max_resource_size: DeviceSize, } +impl ImageFormatProperties { + pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> { + ImageFormatPropertiesBuilder { + inner: ImageFormatProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageFormatPropertiesBuilder<'a> { + inner: ImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> { + type Target = ImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageFormatPropertiesBuilder<'a> { + pub fn max_extent(mut self, max_extent: Extent3D) -> ImageFormatPropertiesBuilder<'a> { + self.inner.max_extent = max_extent; + self + } + pub fn max_mip_levels(mut self, max_mip_levels: u32) -> ImageFormatPropertiesBuilder<'a> { + self.inner.max_mip_levels = max_mip_levels; + self + } + pub fn max_array_layers(mut self, max_array_layers: u32) -> ImageFormatPropertiesBuilder<'a> { + self.inner.max_array_layers = max_array_layers; + self + } + pub fn sample_counts( + mut self, + sample_counts: SampleCountFlags, + ) -> ImageFormatPropertiesBuilder<'a> { + self.inner.sample_counts = sample_counts; + self + } + pub fn max_resource_size( + mut self, + max_resource_size: DeviceSize, + ) -> ImageFormatPropertiesBuilder<'a> { + self.inner.max_resource_size = max_resource_size; + self + } + pub fn build(self) -> ImageFormatProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DescriptorBufferInfo { @@ -5391,6 +6627,41 @@ pub struct DescriptorBufferInfo { pub offset: DeviceSize, pub range: DeviceSize, } +impl DescriptorBufferInfo { + pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> { + DescriptorBufferInfoBuilder { + inner: DescriptorBufferInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorBufferInfoBuilder<'a> { + inner: DescriptorBufferInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> { + type Target = DescriptorBufferInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorBufferInfoBuilder<'a> { + pub fn buffer(mut self, buffer: Buffer) -> DescriptorBufferInfoBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn offset(mut self, offset: DeviceSize) -> DescriptorBufferInfoBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn range(mut self, range: DeviceSize) -> DescriptorBufferInfoBuilder<'a> { + self.inner.range = range; + self + } + pub fn build(self) -> DescriptorBufferInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DescriptorImageInfo { @@ -5398,6 +6669,41 @@ pub struct DescriptorImageInfo { pub image_view: ImageView, pub image_layout: ImageLayout, } +impl DescriptorImageInfo { + pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> { + DescriptorImageInfoBuilder { + inner: DescriptorImageInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorImageInfoBuilder<'a> { + inner: DescriptorImageInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> { + type Target = DescriptorImageInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorImageInfoBuilder<'a> { + pub fn sampler(mut self, sampler: Sampler) -> DescriptorImageInfoBuilder<'a> { + self.inner.sampler = sampler; + self + } + pub fn image_view(mut self, image_view: ImageView) -> DescriptorImageInfoBuilder<'a> { + self.inner.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: ImageLayout) -> DescriptorImageInfoBuilder<'a> { + self.inner.image_layout = image_layout; + self + } + pub fn build(self) -> DescriptorImageInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct WriteDescriptorSet { @@ -5428,6 +6734,76 @@ impl ::std::default::Default for WriteDescriptorSet { } } } +impl WriteDescriptorSet { + pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> { + WriteDescriptorSetBuilder { + inner: WriteDescriptorSet::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct WriteDescriptorSetBuilder<'a> { + inner: WriteDescriptorSet, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> { + type Target = WriteDescriptorSet; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> WriteDescriptorSetBuilder<'a> { + pub fn dst_set(mut self, dst_set: DescriptorSet) -> WriteDescriptorSetBuilder<'a> { + self.inner.dst_set = dst_set; + self + } + pub fn dst_binding(mut self, dst_binding: u32) -> WriteDescriptorSetBuilder<'a> { + self.inner.dst_binding = dst_binding; + self + } + pub fn dst_array_element(mut self, dst_array_element: u32) -> WriteDescriptorSetBuilder<'a> { + self.inner.dst_array_element = dst_array_element; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> WriteDescriptorSetBuilder<'a> { + self.inner.descriptor_count = descriptor_count; + self + } + pub fn descriptor_type( + mut self, + descriptor_type: DescriptorType, + ) -> WriteDescriptorSetBuilder<'a> { + self.inner.descriptor_type = descriptor_type; + self + } + pub fn image_info( + mut self, + image_info: &'a [DescriptorImageInfo], + ) -> WriteDescriptorSetBuilder<'a> { + self.inner.descriptor_count = image_info.len() as u32; + self.inner.p_image_info = image_info.as_ptr(); + self + } + pub fn buffer_info( + mut self, + buffer_info: &'a [DescriptorBufferInfo], + ) -> WriteDescriptorSetBuilder<'a> { + self.inner.descriptor_count = buffer_info.len() as u32; + self.inner.p_buffer_info = buffer_info.as_ptr(); + self + } + pub fn texel_buffer_view( + mut self, + texel_buffer_view: &'a [BufferView], + ) -> WriteDescriptorSetBuilder<'a> { + self.inner.descriptor_count = texel_buffer_view.len() as u32; + self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr(); + self + } + pub fn build(self) -> WriteDescriptorSet { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CopyDescriptorSet { @@ -5456,6 +6832,57 @@ impl ::std::default::Default for CopyDescriptorSet { } } } +impl CopyDescriptorSet { + pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> { + CopyDescriptorSetBuilder { + inner: CopyDescriptorSet::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct CopyDescriptorSetBuilder<'a> { + inner: CopyDescriptorSet, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> { + type Target = CopyDescriptorSet; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> CopyDescriptorSetBuilder<'a> { + pub fn src_set(mut self, src_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a> { + self.inner.src_set = src_set; + self + } + pub fn src_binding(mut self, src_binding: u32) -> CopyDescriptorSetBuilder<'a> { + self.inner.src_binding = src_binding; + self + } + pub fn src_array_element(mut self, src_array_element: u32) -> CopyDescriptorSetBuilder<'a> { + self.inner.src_array_element = src_array_element; + self + } + pub fn dst_set(mut self, dst_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a> { + self.inner.dst_set = dst_set; + self + } + pub fn dst_binding(mut self, dst_binding: u32) -> CopyDescriptorSetBuilder<'a> { + self.inner.dst_binding = dst_binding; + self + } + pub fn dst_array_element(mut self, dst_array_element: u32) -> CopyDescriptorSetBuilder<'a> { + self.inner.dst_array_element = dst_array_element; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> CopyDescriptorSetBuilder<'a> { + self.inner.descriptor_count = descriptor_count; + self + } + pub fn build(self) -> CopyDescriptorSet { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferCreateInfo { @@ -5482,6 +6909,60 @@ impl ::std::default::Default for BufferCreateInfo { } } } +impl BufferCreateInfo { + pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> { + BufferCreateInfoBuilder { + inner: BufferCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferCreateInfoBuilder<'a> { + inner: BufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> { + type Target = BufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: BufferCreateFlags) -> BufferCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn size(mut self, size: DeviceSize) -> BufferCreateInfoBuilder<'a> { + self.inner.size = size; + self + } + pub fn usage(mut self, usage: BufferUsageFlags) -> BufferCreateInfoBuilder<'a> { + self.inner.usage = usage; + self + } + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> BufferCreateInfoBuilder<'a> { + self.inner.sharing_mode = sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> BufferCreateInfoBuilder<'a> { + self.inner.queue_family_index_count = queue_family_index_count; + self + } + pub fn queue_family_indices( + mut self, + queue_family_indices: &'a [u32], + ) -> BufferCreateInfoBuilder<'a> { + self.inner.queue_family_index_count = queue_family_indices.len() as u32; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + pub fn build(self) -> BufferCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferViewCreateInfo { @@ -5506,6 +6987,49 @@ impl ::std::default::Default for BufferViewCreateInfo { } } } +impl BufferViewCreateInfo { + pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> { + BufferViewCreateInfoBuilder { + inner: BufferViewCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferViewCreateInfoBuilder<'a> { + inner: BufferViewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { + type Target = BufferViewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferViewCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: BufferViewCreateFlags) -> BufferViewCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn buffer(mut self, buffer: Buffer) -> BufferViewCreateInfoBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn format(mut self, format: Format) -> BufferViewCreateInfoBuilder<'a> { + self.inner.format = format; + self + } + pub fn offset(mut self, offset: DeviceSize) -> BufferViewCreateInfoBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn range(mut self, range: DeviceSize) -> BufferViewCreateInfoBuilder<'a> { + self.inner.range = range; + self + } + pub fn build(self) -> BufferViewCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresource { @@ -5513,6 +7037,41 @@ pub struct ImageSubresource { pub mip_level: u32, pub array_layer: u32, } +impl ImageSubresource { + pub fn builder<'a>() -> ImageSubresourceBuilder<'a> { + ImageSubresourceBuilder { + inner: ImageSubresource::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageSubresourceBuilder<'a> { + inner: ImageSubresource, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> { + type Target = ImageSubresource; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageSubresourceBuilder<'a> { + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ImageSubresourceBuilder<'a> { + self.inner.aspect_mask = aspect_mask; + self + } + pub fn mip_level(mut self, mip_level: u32) -> ImageSubresourceBuilder<'a> { + self.inner.mip_level = mip_level; + self + } + pub fn array_layer(mut self, array_layer: u32) -> ImageSubresourceBuilder<'a> { + self.inner.array_layer = array_layer; + self + } + pub fn build(self) -> ImageSubresource { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresourceLayers { @@ -5521,6 +7080,48 @@ pub struct ImageSubresourceLayers { pub base_array_layer: u32, pub layer_count: u32, } +impl ImageSubresourceLayers { + pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> { + ImageSubresourceLayersBuilder { + inner: ImageSubresourceLayers::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageSubresourceLayersBuilder<'a> { + inner: ImageSubresourceLayers, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> { + type Target = ImageSubresourceLayers; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageSubresourceLayersBuilder<'a> { + pub fn aspect_mask( + mut self, + aspect_mask: ImageAspectFlags, + ) -> ImageSubresourceLayersBuilder<'a> { + self.inner.aspect_mask = aspect_mask; + self + } + pub fn mip_level(mut self, mip_level: u32) -> ImageSubresourceLayersBuilder<'a> { + self.inner.mip_level = mip_level; + self + } + pub fn base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceLayersBuilder<'a> { + self.inner.base_array_layer = base_array_layer; + self + } + pub fn layer_count(mut self, layer_count: u32) -> ImageSubresourceLayersBuilder<'a> { + self.inner.layer_count = layer_count; + self + } + pub fn build(self) -> ImageSubresourceLayers { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageSubresourceRange { @@ -5530,6 +7131,52 @@ pub struct ImageSubresourceRange { pub base_array_layer: u32, pub layer_count: u32, } +impl ImageSubresourceRange { + pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> { + ImageSubresourceRangeBuilder { + inner: ImageSubresourceRange::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageSubresourceRangeBuilder<'a> { + inner: ImageSubresourceRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> { + type Target = ImageSubresourceRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageSubresourceRangeBuilder<'a> { + pub fn aspect_mask( + mut self, + aspect_mask: ImageAspectFlags, + ) -> ImageSubresourceRangeBuilder<'a> { + self.inner.aspect_mask = aspect_mask; + self + } + pub fn base_mip_level(mut self, base_mip_level: u32) -> ImageSubresourceRangeBuilder<'a> { + self.inner.base_mip_level = base_mip_level; + self + } + pub fn level_count(mut self, level_count: u32) -> ImageSubresourceRangeBuilder<'a> { + self.inner.level_count = level_count; + self + } + pub fn base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceRangeBuilder<'a> { + self.inner.base_array_layer = base_array_layer; + self + } + pub fn layer_count(mut self, layer_count: u32) -> ImageSubresourceRangeBuilder<'a> { + self.inner.layer_count = layer_count; + self + } + pub fn build(self) -> ImageSubresourceRange { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryBarrier { @@ -5548,6 +7195,37 @@ impl ::std::default::Default for MemoryBarrier { } } } +impl MemoryBarrier { + pub fn builder<'a>() -> MemoryBarrierBuilder<'a> { + MemoryBarrierBuilder { + inner: MemoryBarrier::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryBarrierBuilder<'a> { + inner: MemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> { + type Target = MemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryBarrierBuilder<'a> { + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a> { + self.inner.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a> { + self.inner.dst_access_mask = dst_access_mask; + self + } + pub fn build(self) -> MemoryBarrier { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferMemoryBarrier { @@ -5576,6 +7254,69 @@ impl ::std::default::Default for BufferMemoryBarrier { } } } +impl BufferMemoryBarrier { + pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> { + BufferMemoryBarrierBuilder { + inner: BufferMemoryBarrier::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferMemoryBarrierBuilder<'a> { + inner: BufferMemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> { + type Target = BufferMemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferMemoryBarrierBuilder<'a> { + pub fn src_access_mask( + mut self, + src_access_mask: AccessFlags, + ) -> BufferMemoryBarrierBuilder<'a> { + self.inner.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: AccessFlags, + ) -> BufferMemoryBarrierBuilder<'a> { + self.inner.dst_access_mask = dst_access_mask; + self + } + pub fn src_queue_family_index( + mut self, + src_queue_family_index: u32, + ) -> BufferMemoryBarrierBuilder<'a> { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index( + mut self, + dst_queue_family_index: u32, + ) -> BufferMemoryBarrierBuilder<'a> { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn buffer(mut self, buffer: Buffer) -> BufferMemoryBarrierBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn offset(mut self, offset: DeviceSize) -> BufferMemoryBarrierBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn size(mut self, size: DeviceSize) -> BufferMemoryBarrierBuilder<'a> { + self.inner.size = size; + self + } + pub fn build(self) -> BufferMemoryBarrier { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageMemoryBarrier { @@ -5606,6 +7347,76 @@ impl ::std::default::Default for ImageMemoryBarrier { } } } +impl ImageMemoryBarrier { + pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> { + ImageMemoryBarrierBuilder { + inner: ImageMemoryBarrier::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageMemoryBarrierBuilder<'a> { + inner: ImageMemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> { + type Target = ImageMemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageMemoryBarrierBuilder<'a> { + pub fn src_access_mask( + mut self, + src_access_mask: AccessFlags, + ) -> ImageMemoryBarrierBuilder<'a> { + self.inner.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: AccessFlags, + ) -> ImageMemoryBarrierBuilder<'a> { + self.inner.dst_access_mask = dst_access_mask; + self + } + pub fn old_layout(mut self, old_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a> { + self.inner.old_layout = old_layout; + self + } + pub fn new_layout(mut self, new_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a> { + self.inner.new_layout = new_layout; + self + } + pub fn src_queue_family_index( + mut self, + src_queue_family_index: u32, + ) -> ImageMemoryBarrierBuilder<'a> { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index( + mut self, + dst_queue_family_index: u32, + ) -> ImageMemoryBarrierBuilder<'a> { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn image(mut self, image: Image) -> ImageMemoryBarrierBuilder<'a> { + self.inner.image = image; + self + } + pub fn subresource_range( + mut self, + subresource_range: ImageSubresourceRange, + ) -> ImageMemoryBarrierBuilder<'a> { + self.inner.subresource_range = subresource_range; + self + } + pub fn build(self) -> ImageMemoryBarrier { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageCreateInfo { @@ -5646,6 +7457,88 @@ impl ::std::default::Default for ImageCreateInfo { } } } +impl ImageCreateInfo { + pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> { + ImageCreateInfoBuilder { + inner: ImageCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageCreateInfoBuilder<'a> { + inner: ImageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> { + type Target = ImageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: ImageCreateFlags) -> ImageCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn image_type(mut self, image_type: ImageType) -> ImageCreateInfoBuilder<'a> { + self.inner.image_type = image_type; + self + } + pub fn format(mut self, format: Format) -> ImageCreateInfoBuilder<'a> { + self.inner.format = format; + self + } + pub fn extent(mut self, extent: Extent3D) -> ImageCreateInfoBuilder<'a> { + self.inner.extent = extent; + self + } + pub fn mip_levels(mut self, mip_levels: u32) -> ImageCreateInfoBuilder<'a> { + self.inner.mip_levels = mip_levels; + self + } + pub fn array_layers(mut self, array_layers: u32) -> ImageCreateInfoBuilder<'a> { + self.inner.array_layers = array_layers; + self + } + pub fn samples(mut self, samples: SampleCountFlags) -> ImageCreateInfoBuilder<'a> { + self.inner.samples = samples; + self + } + pub fn tiling(mut self, tiling: ImageTiling) -> ImageCreateInfoBuilder<'a> { + self.inner.tiling = tiling; + self + } + pub fn usage(mut self, usage: ImageUsageFlags) -> ImageCreateInfoBuilder<'a> { + self.inner.usage = usage; + self + } + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> ImageCreateInfoBuilder<'a> { + self.inner.sharing_mode = sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> ImageCreateInfoBuilder<'a> { + self.inner.queue_family_index_count = queue_family_index_count; + self + } + pub fn queue_family_indices( + mut self, + queue_family_indices: &'a [u32], + ) -> ImageCreateInfoBuilder<'a> { + self.inner.queue_family_index_count = queue_family_indices.len() as u32; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + pub fn initial_layout(mut self, initial_layout: ImageLayout) -> ImageCreateInfoBuilder<'a> { + self.inner.initial_layout = initial_layout; + self + } + pub fn build(self) -> ImageCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SubresourceLayout { @@ -5655,6 +7548,49 @@ pub struct SubresourceLayout { pub array_pitch: DeviceSize, pub depth_pitch: DeviceSize, } +impl SubresourceLayout { + pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> { + SubresourceLayoutBuilder { + inner: SubresourceLayout::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SubresourceLayoutBuilder<'a> { + inner: SubresourceLayout, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> { + type Target = SubresourceLayout; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SubresourceLayoutBuilder<'a> { + pub fn offset(mut self, offset: DeviceSize) -> SubresourceLayoutBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn size(mut self, size: DeviceSize) -> SubresourceLayoutBuilder<'a> { + self.inner.size = size; + self + } + pub fn row_pitch(mut self, row_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> { + self.inner.row_pitch = row_pitch; + self + } + pub fn array_pitch(mut self, array_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> { + self.inner.array_pitch = array_pitch; + self + } + pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> { + self.inner.depth_pitch = depth_pitch; + self + } + pub fn build(self) -> SubresourceLayout { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageViewCreateInfo { @@ -5681,6 +7617,56 @@ impl ::std::default::Default for ImageViewCreateInfo { } } } +impl ImageViewCreateInfo { + pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> { + ImageViewCreateInfoBuilder { + inner: ImageViewCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageViewCreateInfoBuilder<'a> { + inner: ImageViewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> { + type Target = ImageViewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageViewCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: ImageViewCreateFlags) -> ImageViewCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn image(mut self, image: Image) -> ImageViewCreateInfoBuilder<'a> { + self.inner.image = image; + self + } + pub fn view_type(mut self, view_type: ImageViewType) -> ImageViewCreateInfoBuilder<'a> { + self.inner.view_type = view_type; + self + } + pub fn format(mut self, format: Format) -> ImageViewCreateInfoBuilder<'a> { + self.inner.format = format; + self + } + pub fn components(mut self, components: ComponentMapping) -> ImageViewCreateInfoBuilder<'a> { + self.inner.components = components; + self + } + pub fn subresource_range( + mut self, + subresource_range: ImageSubresourceRange, + ) -> ImageViewCreateInfoBuilder<'a> { + self.inner.subresource_range = subresource_range; + self + } + pub fn build(self) -> ImageViewCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct BufferCopy { @@ -5688,6 +7674,41 @@ pub struct BufferCopy { pub dst_offset: DeviceSize, pub size: DeviceSize, } +impl BufferCopy { + pub fn builder<'a>() -> BufferCopyBuilder<'a> { + BufferCopyBuilder { + inner: BufferCopy::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferCopyBuilder<'a> { + inner: BufferCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> { + type Target = BufferCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferCopyBuilder<'a> { + pub fn src_offset(mut self, src_offset: DeviceSize) -> BufferCopyBuilder<'a> { + self.inner.src_offset = src_offset; + self + } + pub fn dst_offset(mut self, dst_offset: DeviceSize) -> BufferCopyBuilder<'a> { + self.inner.dst_offset = dst_offset; + self + } + pub fn size(mut self, size: DeviceSize) -> BufferCopyBuilder<'a> { + self.inner.size = size; + self + } + pub fn build(self) -> BufferCopy { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SparseMemoryBind { @@ -5697,6 +7718,49 @@ pub struct SparseMemoryBind { pub memory_offset: DeviceSize, pub flags: SparseMemoryBindFlags, } +impl SparseMemoryBind { + pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> { + SparseMemoryBindBuilder { + inner: SparseMemoryBind::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseMemoryBindBuilder<'a> { + inner: SparseMemoryBind, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> { + type Target = SparseMemoryBind; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseMemoryBindBuilder<'a> { + pub fn resource_offset(mut self, resource_offset: DeviceSize) -> SparseMemoryBindBuilder<'a> { + self.inner.resource_offset = resource_offset; + self + } + pub fn size(mut self, size: DeviceSize) -> SparseMemoryBindBuilder<'a> { + self.inner.size = size; + self + } + pub fn memory(mut self, memory: DeviceMemory) -> SparseMemoryBindBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> SparseMemoryBindBuilder<'a> { + self.inner.memory_offset = memory_offset; + self + } + pub fn flags(mut self, flags: SparseMemoryBindFlags) -> SparseMemoryBindBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> SparseMemoryBind { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SparseImageMemoryBind { @@ -5707,6 +7771,56 @@ pub struct SparseImageMemoryBind { pub memory_offset: DeviceSize, pub flags: SparseMemoryBindFlags, } +impl SparseImageMemoryBind { + pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> { + SparseImageMemoryBindBuilder { + inner: SparseImageMemoryBind::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseImageMemoryBindBuilder<'a> { + inner: SparseImageMemoryBind, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> { + type Target = SparseImageMemoryBind; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseImageMemoryBindBuilder<'a> { + pub fn subresource( + mut self, + subresource: ImageSubresource, + ) -> SparseImageMemoryBindBuilder<'a> { + self.inner.subresource = subresource; + self + } + pub fn offset(mut self, offset: Offset3D) -> SparseImageMemoryBindBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn extent(mut self, extent: Extent3D) -> SparseImageMemoryBindBuilder<'a> { + self.inner.extent = extent; + self + } + pub fn memory(mut self, memory: DeviceMemory) -> SparseImageMemoryBindBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> SparseImageMemoryBindBuilder<'a> { + self.inner.memory_offset = memory_offset; + self + } + pub fn flags(mut self, flags: SparseMemoryBindFlags) -> SparseImageMemoryBindBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> SparseImageMemoryBind { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseBufferMemoryBindInfo { @@ -5723,6 +7837,42 @@ impl ::std::default::Default for SparseBufferMemoryBindInfo { } } } +impl SparseBufferMemoryBindInfo { + pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> { + SparseBufferMemoryBindInfoBuilder { + inner: SparseBufferMemoryBindInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseBufferMemoryBindInfoBuilder<'a> { + inner: SparseBufferMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> { + type Target = SparseBufferMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseBufferMemoryBindInfoBuilder<'a> { + pub fn buffer(mut self, buffer: Buffer) -> SparseBufferMemoryBindInfoBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn bind_count(mut self, bind_count: u32) -> SparseBufferMemoryBindInfoBuilder<'a> { + self.inner.bind_count = bind_count; + self + } + pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> SparseBufferMemoryBindInfoBuilder<'a> { + self.inner.bind_count = binds.len() as u32; + self.inner.p_binds = binds.as_ptr(); + self + } + pub fn build(self) -> SparseBufferMemoryBindInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageOpaqueMemoryBindInfo { @@ -5739,6 +7889,45 @@ impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { } } } +impl SparseImageOpaqueMemoryBindInfo { + pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + SparseImageOpaqueMemoryBindInfoBuilder { + inner: SparseImageOpaqueMemoryBindInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> { + inner: SparseImageOpaqueMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> { + type Target = SparseImageOpaqueMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + pub fn image(mut self, image: Image) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + self.inner.image = image; + self + } + pub fn bind_count(mut self, bind_count: u32) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + self.inner.bind_count = bind_count; + self + } + pub fn binds( + mut self, + binds: &'a [SparseMemoryBind], + ) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + self.inner.bind_count = binds.len() as u32; + self.inner.p_binds = binds.as_ptr(); + self + } + pub fn build(self) -> SparseImageOpaqueMemoryBindInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryBindInfo { @@ -5755,6 +7944,45 @@ impl ::std::default::Default for SparseImageMemoryBindInfo { } } } +impl SparseImageMemoryBindInfo { + pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> { + SparseImageMemoryBindInfoBuilder { + inner: SparseImageMemoryBindInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseImageMemoryBindInfoBuilder<'a> { + inner: SparseImageMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> { + type Target = SparseImageMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseImageMemoryBindInfoBuilder<'a> { + pub fn image(mut self, image: Image) -> SparseImageMemoryBindInfoBuilder<'a> { + self.inner.image = image; + self + } + pub fn bind_count(mut self, bind_count: u32) -> SparseImageMemoryBindInfoBuilder<'a> { + self.inner.bind_count = bind_count; + self + } + pub fn binds( + mut self, + binds: &'a [SparseImageMemoryBind], + ) -> SparseImageMemoryBindInfoBuilder<'a> { + self.inner.bind_count = binds.len() as u32; + self.inner.p_binds = binds.as_ptr(); + self + } + pub fn build(self) -> SparseImageMemoryBindInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindSparseInfo { @@ -5789,6 +8017,95 @@ impl ::std::default::Default for BindSparseInfo { } } } +impl BindSparseInfo { + pub fn builder<'a>() -> BindSparseInfoBuilder<'a> { + BindSparseInfoBuilder { + inner: BindSparseInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BindSparseInfoBuilder<'a> { + inner: BindSparseInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> { + type Target = BindSparseInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BindSparseInfoBuilder<'a> { + pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> BindSparseInfoBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn wait_semaphores( + mut self, + wait_semaphores: &'a [Semaphore], + ) -> BindSparseInfoBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphores.len() as u32; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + pub fn buffer_bind_count(mut self, buffer_bind_count: u32) -> BindSparseInfoBuilder<'a> { + self.inner.buffer_bind_count = buffer_bind_count; + self + } + pub fn buffer_binds( + mut self, + buffer_binds: &'a [SparseBufferMemoryBindInfo], + ) -> BindSparseInfoBuilder<'a> { + self.inner.buffer_bind_count = buffer_binds.len() as u32; + self.inner.p_buffer_binds = buffer_binds.as_ptr(); + self + } + pub fn image_opaque_bind_count( + mut self, + image_opaque_bind_count: u32, + ) -> BindSparseInfoBuilder<'a> { + self.inner.image_opaque_bind_count = image_opaque_bind_count; + self + } + pub fn image_opaque_binds( + mut self, + image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo], + ) -> BindSparseInfoBuilder<'a> { + self.inner.image_opaque_bind_count = image_opaque_binds.len() as u32; + self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr(); + self + } + pub fn image_bind_count(mut self, image_bind_count: u32) -> BindSparseInfoBuilder<'a> { + self.inner.image_bind_count = image_bind_count; + self + } + pub fn image_binds( + mut self, + image_binds: &'a [SparseImageMemoryBindInfo], + ) -> BindSparseInfoBuilder<'a> { + self.inner.image_bind_count = image_binds.len() as u32; + self.inner.p_image_binds = image_binds.as_ptr(); + self + } + pub fn signal_semaphore_count( + mut self, + signal_semaphore_count: u32, + ) -> BindSparseInfoBuilder<'a> { + self.inner.signal_semaphore_count = signal_semaphore_count; + self + } + pub fn signal_semaphores( + mut self, + signal_semaphores: &'a [Semaphore], + ) -> BindSparseInfoBuilder<'a> { + self.inner.signal_semaphore_count = signal_semaphores.len() as u32; + self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self + } + pub fn build(self) -> BindSparseInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageCopy { @@ -5798,6 +8115,55 @@ pub struct ImageCopy { pub dst_offset: Offset3D, pub extent: Extent3D, } +impl ImageCopy { + pub fn builder<'a>() -> ImageCopyBuilder<'a> { + ImageCopyBuilder { + inner: ImageCopy::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageCopyBuilder<'a> { + inner: ImageCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> { + type Target = ImageCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageCopyBuilder<'a> { + pub fn src_subresource( + mut self, + src_subresource: ImageSubresourceLayers, + ) -> ImageCopyBuilder<'a> { + self.inner.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: Offset3D) -> ImageCopyBuilder<'a> { + self.inner.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: ImageSubresourceLayers, + ) -> ImageCopyBuilder<'a> { + self.inner.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageCopyBuilder<'a> { + self.inner.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: Extent3D) -> ImageCopyBuilder<'a> { + self.inner.extent = extent; + self + } + pub fn build(self) -> ImageCopy { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageBlit { @@ -5816,6 +8182,51 @@ impl ::std::default::Default for ImageBlit { } } } +impl ImageBlit { + pub fn builder<'a>() -> ImageBlitBuilder<'a> { + ImageBlitBuilder { + inner: ImageBlit::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageBlitBuilder<'a> { + inner: ImageBlit, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> { + type Target = ImageBlit; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageBlitBuilder<'a> { + pub fn src_subresource( + mut self, + src_subresource: ImageSubresourceLayers, + ) -> ImageBlitBuilder<'a> { + self.inner.src_subresource = src_subresource; + self + } + pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a> { + self.inner.src_offsets = src_offsets; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: ImageSubresourceLayers, + ) -> ImageBlitBuilder<'a> { + self.inner.dst_subresource = dst_subresource; + self + } + pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a> { + self.inner.dst_offsets = dst_offsets; + self + } + pub fn build(self) -> ImageBlit { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct BufferImageCopy { @@ -5826,6 +8237,56 @@ pub struct BufferImageCopy { pub image_offset: Offset3D, pub image_extent: Extent3D, } +impl BufferImageCopy { + pub fn builder<'a>() -> BufferImageCopyBuilder<'a> { + BufferImageCopyBuilder { + inner: BufferImageCopy::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferImageCopyBuilder<'a> { + inner: BufferImageCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> { + type Target = BufferImageCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferImageCopyBuilder<'a> { + pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopyBuilder<'a> { + self.inner.buffer_offset = buffer_offset; + self + } + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> BufferImageCopyBuilder<'a> { + self.inner.buffer_row_length = buffer_row_length; + self + } + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> BufferImageCopyBuilder<'a> { + self.inner.buffer_image_height = buffer_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: ImageSubresourceLayers, + ) -> BufferImageCopyBuilder<'a> { + self.inner.image_subresource = image_subresource; + self + } + pub fn image_offset(mut self, image_offset: Offset3D) -> BufferImageCopyBuilder<'a> { + self.inner.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: Extent3D) -> BufferImageCopyBuilder<'a> { + self.inner.image_extent = image_extent; + self + } + pub fn build(self) -> BufferImageCopy { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ImageResolve { @@ -5835,6 +8296,55 @@ pub struct ImageResolve { pub dst_offset: Offset3D, pub extent: Extent3D, } +impl ImageResolve { + pub fn builder<'a>() -> ImageResolveBuilder<'a> { + ImageResolveBuilder { + inner: ImageResolve::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageResolveBuilder<'a> { + inner: ImageResolve, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> { + type Target = ImageResolve; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageResolveBuilder<'a> { + pub fn src_subresource( + mut self, + src_subresource: ImageSubresourceLayers, + ) -> ImageResolveBuilder<'a> { + self.inner.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: Offset3D) -> ImageResolveBuilder<'a> { + self.inner.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: ImageSubresourceLayers, + ) -> ImageResolveBuilder<'a> { + self.inner.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageResolveBuilder<'a> { + self.inner.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: Extent3D) -> ImageResolveBuilder<'a> { + self.inner.extent = extent; + self + } + pub fn build(self) -> ImageResolve { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ShaderModuleCreateInfo { @@ -5855,6 +8365,41 @@ impl ::std::default::Default for ShaderModuleCreateInfo { } } } +impl ShaderModuleCreateInfo { + pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> { + ShaderModuleCreateInfoBuilder { + inner: ShaderModuleCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ShaderModuleCreateInfoBuilder<'a> { + inner: ShaderModuleCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> { + type Target = ShaderModuleCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ShaderModuleCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> ShaderModuleCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn code_size(mut self, code_size: usize) -> ShaderModuleCreateInfoBuilder<'a> { + self.inner.code_size = code_size; + self + } + pub fn code(mut self, code: *const u32) -> ShaderModuleCreateInfoBuilder<'a> { + self.inner.p_code = code; + self + } + pub fn build(self) -> ShaderModuleCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutBinding { @@ -5875,6 +8420,62 @@ impl ::std::default::Default for DescriptorSetLayoutBinding { } } } +impl DescriptorSetLayoutBinding { + pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> { + DescriptorSetLayoutBindingBuilder { + inner: DescriptorSetLayoutBinding::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorSetLayoutBindingBuilder<'a> { + inner: DescriptorSetLayoutBinding, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> { + type Target = DescriptorSetLayoutBinding; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorSetLayoutBindingBuilder<'a> { + pub fn binding(mut self, binding: u32) -> DescriptorSetLayoutBindingBuilder<'a> { + self.inner.binding = binding; + self + } + pub fn descriptor_type( + mut self, + descriptor_type: DescriptorType, + ) -> DescriptorSetLayoutBindingBuilder<'a> { + self.inner.descriptor_type = descriptor_type; + self + } + pub fn descriptor_count( + mut self, + descriptor_count: u32, + ) -> DescriptorSetLayoutBindingBuilder<'a> { + self.inner.descriptor_count = descriptor_count; + self + } + pub fn stage_flags( + mut self, + stage_flags: ShaderStageFlags, + ) -> DescriptorSetLayoutBindingBuilder<'a> { + self.inner.stage_flags = stage_flags; + self + } + pub fn immutable_samplers( + mut self, + immutable_samplers: &'a [Sampler], + ) -> DescriptorSetLayoutBindingBuilder<'a> { + self.inner.descriptor_count = immutable_samplers.len() as u32; + self.inner.p_immutable_samplers = immutable_samplers.as_ptr(); + self + } + pub fn build(self) -> DescriptorSetLayoutBinding { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutCreateInfo { @@ -5895,12 +8496,85 @@ impl ::std::default::Default for DescriptorSetLayoutCreateInfo { } } } +impl DescriptorSetLayoutCreateInfo { + pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> { + DescriptorSetLayoutCreateInfoBuilder { + inner: DescriptorSetLayoutCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorSetLayoutCreateInfoBuilder<'a> { + inner: DescriptorSetLayoutCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> { + type Target = DescriptorSetLayoutCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: DescriptorSetLayoutCreateFlags, + ) -> DescriptorSetLayoutCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn binding_count(mut self, binding_count: u32) -> DescriptorSetLayoutCreateInfoBuilder<'a> { + self.inner.binding_count = binding_count; + self + } + pub fn bindings( + mut self, + bindings: &'a [DescriptorSetLayoutBinding], + ) -> DescriptorSetLayoutCreateInfoBuilder<'a> { + self.inner.binding_count = bindings.len() as u32; + self.inner.p_bindings = bindings.as_ptr(); + self + } + pub fn build(self) -> DescriptorSetLayoutCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DescriptorPoolSize { pub ty: DescriptorType, pub descriptor_count: u32, } +impl DescriptorPoolSize { + pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> { + DescriptorPoolSizeBuilder { + inner: DescriptorPoolSize::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorPoolSizeBuilder<'a> { + inner: DescriptorPoolSize, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> { + type Target = DescriptorPoolSize; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorPoolSizeBuilder<'a> { + pub fn ty(mut self, ty: DescriptorType) -> DescriptorPoolSizeBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> DescriptorPoolSizeBuilder<'a> { + self.inner.descriptor_count = descriptor_count; + self + } + pub fn build(self) -> DescriptorPoolSize { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorPoolCreateInfo { @@ -5923,6 +8597,52 @@ impl ::std::default::Default for DescriptorPoolCreateInfo { } } } +impl DescriptorPoolCreateInfo { + pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> { + DescriptorPoolCreateInfoBuilder { + inner: DescriptorPoolCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorPoolCreateInfoBuilder<'a> { + inner: DescriptorPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> { + type Target = DescriptorPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorPoolCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: DescriptorPoolCreateFlags, + ) -> DescriptorPoolCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn max_sets(mut self, max_sets: u32) -> DescriptorPoolCreateInfoBuilder<'a> { + self.inner.max_sets = max_sets; + self + } + pub fn pool_size_count(mut self, pool_size_count: u32) -> DescriptorPoolCreateInfoBuilder<'a> { + self.inner.pool_size_count = pool_size_count; + self + } + pub fn pool_sizes( + mut self, + pool_sizes: &'a [DescriptorPoolSize], + ) -> DescriptorPoolCreateInfoBuilder<'a> { + self.inner.pool_size_count = pool_sizes.len() as u32; + self.inner.p_pool_sizes = pool_sizes.as_ptr(); + self + } + pub fn build(self) -> DescriptorPoolCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetAllocateInfo { @@ -5943,6 +8663,51 @@ impl ::std::default::Default for DescriptorSetAllocateInfo { } } } +impl DescriptorSetAllocateInfo { + pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> { + DescriptorSetAllocateInfoBuilder { + inner: DescriptorSetAllocateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorSetAllocateInfoBuilder<'a> { + inner: DescriptorSetAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> { + type Target = DescriptorSetAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorSetAllocateInfoBuilder<'a> { + pub fn descriptor_pool( + mut self, + descriptor_pool: DescriptorPool, + ) -> DescriptorSetAllocateInfoBuilder<'a> { + self.inner.descriptor_pool = descriptor_pool; + self + } + pub fn descriptor_set_count( + mut self, + descriptor_set_count: u32, + ) -> DescriptorSetAllocateInfoBuilder<'a> { + self.inner.descriptor_set_count = descriptor_set_count; + self + } + pub fn set_layouts( + mut self, + set_layouts: &'a [DescriptorSetLayout], + ) -> DescriptorSetAllocateInfoBuilder<'a> { + self.inner.descriptor_set_count = set_layouts.len() as u32; + self.inner.p_set_layouts = set_layouts.as_ptr(); + self + } + pub fn build(self) -> DescriptorSetAllocateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SpecializationMapEntry { @@ -5950,6 +8715,41 @@ pub struct SpecializationMapEntry { pub offset: u32, pub size: usize, } +impl SpecializationMapEntry { + pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> { + SpecializationMapEntryBuilder { + inner: SpecializationMapEntry::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SpecializationMapEntryBuilder<'a> { + inner: SpecializationMapEntry, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> { + type Target = SpecializationMapEntry; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SpecializationMapEntryBuilder<'a> { + pub fn constant_id(mut self, constant_id: u32) -> SpecializationMapEntryBuilder<'a> { + self.inner.constant_id = constant_id; + self + } + pub fn offset(mut self, offset: u32) -> SpecializationMapEntryBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn size(mut self, size: usize) -> SpecializationMapEntryBuilder<'a> { + self.inner.size = size; + self + } + pub fn build(self) -> SpecializationMapEntry { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SpecializationInfo { @@ -5968,6 +8768,50 @@ impl ::std::default::Default for SpecializationInfo { } } } +impl SpecializationInfo { + pub fn builder<'a>() -> SpecializationInfoBuilder<'a> { + SpecializationInfoBuilder { + inner: SpecializationInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SpecializationInfoBuilder<'a> { + inner: SpecializationInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> { + type Target = SpecializationInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SpecializationInfoBuilder<'a> { + pub fn map_entry_count(mut self, map_entry_count: u32) -> SpecializationInfoBuilder<'a> { + self.inner.map_entry_count = map_entry_count; + self + } + pub fn map_entries( + mut self, + map_entries: &'a [SpecializationMapEntry], + ) -> SpecializationInfoBuilder<'a> { + self.inner.map_entry_count = map_entries.len() as u32; + self.inner.p_map_entries = map_entries.as_ptr(); + self + } + pub fn data_size(mut self, data_size: usize) -> SpecializationInfoBuilder<'a> { + self.inner.data_size = data_size; + self + } + pub fn data(mut self, data: &'a [c_void]) -> SpecializationInfoBuilder<'a> { + self.inner.data_size = data.len() as usize; + self.inner.p_data = data.as_ptr(); + self + } + pub fn build(self) -> SpecializationInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineShaderStageCreateInfo { @@ -5992,6 +8836,55 @@ impl ::std::default::Default for PipelineShaderStageCreateInfo { } } } +impl PipelineShaderStageCreateInfo { + pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> { + PipelineShaderStageCreateInfoBuilder { + inner: PipelineShaderStageCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineShaderStageCreateInfoBuilder<'a> { + inner: PipelineShaderStageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> { + type Target = PipelineShaderStageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineShaderStageCreateFlags, + ) -> PipelineShaderStageCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn stage(mut self, stage: ShaderStageFlags) -> PipelineShaderStageCreateInfoBuilder<'a> { + self.inner.stage = stage; + self + } + pub fn module(mut self, module: ShaderModule) -> PipelineShaderStageCreateInfoBuilder<'a> { + self.inner.module = module; + self + } + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> PipelineShaderStageCreateInfoBuilder<'a> { + self.inner.p_name = name.as_ptr(); + self + } + pub fn specialization_info( + mut self, + specialization_info: &'a SpecializationInfo, + ) -> PipelineShaderStageCreateInfoBuilder<'a> { + self.inner.p_specialization_info = specialization_info; + self + } + pub fn build(self) -> PipelineShaderStageCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ComputePipelineCreateInfo { @@ -6016,6 +8909,58 @@ impl ::std::default::Default for ComputePipelineCreateInfo { } } } +impl ComputePipelineCreateInfo { + pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> { + ComputePipelineCreateInfoBuilder { + inner: ComputePipelineCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ComputePipelineCreateInfoBuilder<'a> { + inner: ComputePipelineCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> { + type Target = ComputePipelineCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ComputePipelineCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: PipelineCreateFlags) -> ComputePipelineCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn stage( + mut self, + stage: PipelineShaderStageCreateInfo, + ) -> ComputePipelineCreateInfoBuilder<'a> { + self.inner.stage = stage; + self + } + pub fn layout(mut self, layout: PipelineLayout) -> ComputePipelineCreateInfoBuilder<'a> { + self.inner.layout = layout; + self + } + pub fn base_pipeline_handle( + mut self, + base_pipeline_handle: Pipeline, + ) -> ComputePipelineCreateInfoBuilder<'a> { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + pub fn base_pipeline_index( + mut self, + base_pipeline_index: i32, + ) -> ComputePipelineCreateInfoBuilder<'a> { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + pub fn build(self) -> ComputePipelineCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct VertexInputBindingDescription { @@ -6023,6 +8968,44 @@ pub struct VertexInputBindingDescription { pub stride: u32, pub input_rate: VertexInputRate, } +impl VertexInputBindingDescription { + pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> { + VertexInputBindingDescriptionBuilder { + inner: VertexInputBindingDescription::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct VertexInputBindingDescriptionBuilder<'a> { + inner: VertexInputBindingDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> { + type Target = VertexInputBindingDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> VertexInputBindingDescriptionBuilder<'a> { + pub fn binding(mut self, binding: u32) -> VertexInputBindingDescriptionBuilder<'a> { + self.inner.binding = binding; + self + } + pub fn stride(mut self, stride: u32) -> VertexInputBindingDescriptionBuilder<'a> { + self.inner.stride = stride; + self + } + pub fn input_rate( + mut self, + input_rate: VertexInputRate, + ) -> VertexInputBindingDescriptionBuilder<'a> { + self.inner.input_rate = input_rate; + self + } + pub fn build(self) -> VertexInputBindingDescription { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct VertexInputAttributeDescription { @@ -6031,6 +9014,45 @@ pub struct VertexInputAttributeDescription { pub format: Format, pub offset: u32, } +impl VertexInputAttributeDescription { + pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> { + VertexInputAttributeDescriptionBuilder { + inner: VertexInputAttributeDescription::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct VertexInputAttributeDescriptionBuilder<'a> { + inner: VertexInputAttributeDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> { + type Target = VertexInputAttributeDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> VertexInputAttributeDescriptionBuilder<'a> { + pub fn location(mut self, location: u32) -> VertexInputAttributeDescriptionBuilder<'a> { + self.inner.location = location; + self + } + pub fn binding(mut self, binding: u32) -> VertexInputAttributeDescriptionBuilder<'a> { + self.inner.binding = binding; + self + } + pub fn format(mut self, format: Format) -> VertexInputAttributeDescriptionBuilder<'a> { + self.inner.format = format; + self + } + pub fn offset(mut self, offset: u32) -> VertexInputAttributeDescriptionBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn build(self) -> VertexInputAttributeDescription { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineVertexInputStateCreateInfo { @@ -6055,6 +9077,66 @@ impl ::std::default::Default for PipelineVertexInputStateCreateInfo { } } } +impl PipelineVertexInputStateCreateInfo { + pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> { + PipelineVertexInputStateCreateInfoBuilder { + inner: PipelineVertexInputStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineVertexInputStateCreateInfoBuilder<'a> { + inner: PipelineVertexInputStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> { + type Target = PipelineVertexInputStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineVertexInputStateCreateFlags, + ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn vertex_binding_description_count( + mut self, + vertex_binding_description_count: u32, + ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { + self.inner.vertex_binding_description_count = vertex_binding_description_count; + self + } + pub fn vertex_binding_descriptions( + mut self, + vertex_binding_descriptions: &'a [VertexInputBindingDescription], + ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { + self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as u32; + self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr(); + self + } + pub fn vertex_attribute_description_count( + mut self, + vertex_attribute_description_count: u32, + ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { + self.inner.vertex_attribute_description_count = vertex_attribute_description_count; + self + } + pub fn vertex_attribute_descriptions( + mut self, + vertex_attribute_descriptions: &'a [VertexInputAttributeDescription], + ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { + self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as u32; + self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr(); + self + } + pub fn build(self) -> PipelineVertexInputStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineInputAssemblyStateCreateInfo { @@ -6075,6 +9157,50 @@ impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo { } } } +impl PipelineInputAssemblyStateCreateInfo { + pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + PipelineInputAssemblyStateCreateInfoBuilder { + inner: PipelineInputAssemblyStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> { + inner: PipelineInputAssemblyStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> { + type Target = PipelineInputAssemblyStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineInputAssemblyStateCreateFlags, + ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn topology( + mut self, + topology: PrimitiveTopology, + ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + self.inner.topology = topology; + self + } + pub fn primitive_restart_enable( + mut self, + primitive_restart_enable: Bool32, + ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + self.inner.primitive_restart_enable = primitive_restart_enable; + self + } + pub fn build(self) -> PipelineInputAssemblyStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineTessellationStateCreateInfo { @@ -6093,6 +9219,43 @@ impl ::std::default::Default for PipelineTessellationStateCreateInfo { } } } +impl PipelineTessellationStateCreateInfo { + pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> { + PipelineTessellationStateCreateInfoBuilder { + inner: PipelineTessellationStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineTessellationStateCreateInfoBuilder<'a> { + inner: PipelineTessellationStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> { + type Target = PipelineTessellationStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineTessellationStateCreateFlags, + ) -> PipelineTessellationStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn patch_control_points( + mut self, + patch_control_points: u32, + ) -> PipelineTessellationStateCreateInfoBuilder<'a> { + self.inner.patch_control_points = patch_control_points; + self + } + pub fn build(self) -> PipelineTessellationStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineViewportStateCreateInfo { @@ -6117,6 +9280,66 @@ impl ::std::default::Default for PipelineViewportStateCreateInfo { } } } +impl PipelineViewportStateCreateInfo { + pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> { + PipelineViewportStateCreateInfoBuilder { + inner: PipelineViewportStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineViewportStateCreateInfoBuilder<'a> { + inner: PipelineViewportStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> { + type Target = PipelineViewportStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineViewportStateCreateFlags, + ) -> PipelineViewportStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn viewport_count( + mut self, + viewport_count: u32, + ) -> PipelineViewportStateCreateInfoBuilder<'a> { + self.inner.viewport_count = viewport_count; + self + } + pub fn viewports( + mut self, + viewports: &'a [Viewport], + ) -> PipelineViewportStateCreateInfoBuilder<'a> { + self.inner.viewport_count = viewports.len() as u32; + self.inner.p_viewports = viewports.as_ptr(); + self + } + pub fn scissor_count( + mut self, + scissor_count: u32, + ) -> PipelineViewportStateCreateInfoBuilder<'a> { + self.inner.scissor_count = scissor_count; + self + } + pub fn scissors( + mut self, + scissors: &'a [Rect2D], + ) -> PipelineViewportStateCreateInfoBuilder<'a> { + self.inner.scissor_count = scissors.len() as u32; + self.inner.p_scissors = scissors.as_ptr(); + self + } + pub fn build(self) -> PipelineViewportStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationStateCreateInfo { @@ -6153,6 +9376,106 @@ impl ::std::default::Default for PipelineRasterizationStateCreateInfo { } } } +impl PipelineRasterizationStateCreateInfo { + pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> { + PipelineRasterizationStateCreateInfoBuilder { + inner: PipelineRasterizationStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineRasterizationStateCreateInfoBuilder<'a> { + inner: PipelineRasterizationStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> { + type Target = PipelineRasterizationStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineRasterizationStateCreateFlags, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn depth_clamp_enable( + mut self, + depth_clamp_enable: Bool32, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.depth_clamp_enable = depth_clamp_enable; + self + } + pub fn rasterizer_discard_enable( + mut self, + rasterizer_discard_enable: Bool32, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.rasterizer_discard_enable = rasterizer_discard_enable; + self + } + pub fn polygon_mode( + mut self, + polygon_mode: PolygonMode, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.polygon_mode = polygon_mode; + self + } + pub fn cull_mode( + mut self, + cull_mode: CullModeFlags, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.cull_mode = cull_mode; + self + } + pub fn front_face( + mut self, + front_face: FrontFace, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.front_face = front_face; + self + } + pub fn depth_bias_enable( + mut self, + depth_bias_enable: Bool32, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.depth_bias_enable = depth_bias_enable; + self + } + pub fn depth_bias_constant_factor( + mut self, + depth_bias_constant_factor: c_float, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.depth_bias_constant_factor = depth_bias_constant_factor; + self + } + pub fn depth_bias_clamp( + mut self, + depth_bias_clamp: c_float, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.depth_bias_clamp = depth_bias_clamp; + self + } + pub fn depth_bias_slope_factor( + mut self, + depth_bias_slope_factor: c_float, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.depth_bias_slope_factor = depth_bias_slope_factor; + self + } + pub fn line_width( + mut self, + line_width: c_float, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + self.inner.line_width = line_width; + self + } + pub fn build(self) -> PipelineRasterizationStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineMultisampleStateCreateInfo { @@ -6181,6 +9504,78 @@ impl ::std::default::Default for PipelineMultisampleStateCreateInfo { } } } +impl PipelineMultisampleStateCreateInfo { + pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> { + PipelineMultisampleStateCreateInfoBuilder { + inner: PipelineMultisampleStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineMultisampleStateCreateInfoBuilder<'a> { + inner: PipelineMultisampleStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> { + type Target = PipelineMultisampleStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineMultisampleStateCreateFlags, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn rasterization_samples( + mut self, + rasterization_samples: SampleCountFlags, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + self.inner.rasterization_samples = rasterization_samples; + self + } + pub fn sample_shading_enable( + mut self, + sample_shading_enable: Bool32, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + self.inner.sample_shading_enable = sample_shading_enable; + self + } + pub fn min_sample_shading( + mut self, + min_sample_shading: c_float, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + self.inner.min_sample_shading = min_sample_shading; + self + } + pub fn sample_mask( + mut self, + sample_mask: *const SampleMask, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + self.inner.p_sample_mask = sample_mask; + self + } + pub fn alpha_to_coverage_enable( + mut self, + alpha_to_coverage_enable: Bool32, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable; + self + } + pub fn alpha_to_one_enable( + mut self, + alpha_to_one_enable: Bool32, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + self.inner.alpha_to_one_enable = alpha_to_one_enable; + self + } + pub fn build(self) -> PipelineMultisampleStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PipelineColorBlendAttachmentState { @@ -6193,6 +9588,85 @@ pub struct PipelineColorBlendAttachmentState { pub alpha_blend_op: BlendOp, pub color_write_mask: ColorComponentFlags, } +impl PipelineColorBlendAttachmentState { + pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> { + PipelineColorBlendAttachmentStateBuilder { + inner: PipelineColorBlendAttachmentState::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineColorBlendAttachmentStateBuilder<'a> { + inner: PipelineColorBlendAttachmentState, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> { + type Target = PipelineColorBlendAttachmentState; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> { + pub fn blend_enable( + mut self, + blend_enable: Bool32, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.blend_enable = blend_enable; + self + } + pub fn src_color_blend_factor( + mut self, + src_color_blend_factor: BlendFactor, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.src_color_blend_factor = src_color_blend_factor; + self + } + pub fn dst_color_blend_factor( + mut self, + dst_color_blend_factor: BlendFactor, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.dst_color_blend_factor = dst_color_blend_factor; + self + } + pub fn color_blend_op( + mut self, + color_blend_op: BlendOp, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.color_blend_op = color_blend_op; + self + } + pub fn src_alpha_blend_factor( + mut self, + src_alpha_blend_factor: BlendFactor, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + pub fn dst_alpha_blend_factor( + mut self, + dst_alpha_blend_factor: BlendFactor, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + pub fn alpha_blend_op( + mut self, + alpha_blend_op: BlendOp, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.alpha_blend_op = alpha_blend_op; + self + } + pub fn color_write_mask( + mut self, + color_write_mask: ColorComponentFlags, + ) -> PipelineColorBlendAttachmentStateBuilder<'a> { + self.inner.color_write_mask = color_write_mask; + self + } + pub fn build(self) -> PipelineColorBlendAttachmentState { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineColorBlendStateCreateInfo { @@ -6219,6 +9693,69 @@ impl ::std::default::Default for PipelineColorBlendStateCreateInfo { } } } +impl PipelineColorBlendStateCreateInfo { + pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> { + PipelineColorBlendStateCreateInfoBuilder { + inner: PipelineColorBlendStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineColorBlendStateCreateInfoBuilder<'a> { + inner: PipelineColorBlendStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> { + type Target = PipelineColorBlendStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineColorBlendStateCreateFlags, + ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn logic_op_enable( + mut self, + logic_op_enable: Bool32, + ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { + self.inner.logic_op_enable = logic_op_enable; + self + } + pub fn logic_op(mut self, logic_op: LogicOp) -> PipelineColorBlendStateCreateInfoBuilder<'a> { + self.inner.logic_op = logic_op; + self + } + pub fn attachment_count( + mut self, + attachment_count: u32, + ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { + self.inner.attachment_count = attachment_count; + self + } + pub fn attachments( + mut self, + attachments: &'a [PipelineColorBlendAttachmentState], + ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { + self.inner.attachment_count = attachments.len() as u32; + self.inner.p_attachments = attachments.as_ptr(); + self + } + pub fn blend_constants( + mut self, + blend_constants: [c_float; 4], + ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { + self.inner.blend_constants = blend_constants; + self + } + pub fn build(self) -> PipelineColorBlendStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineDynamicStateCreateInfo { @@ -6239,6 +9776,51 @@ impl ::std::default::Default for PipelineDynamicStateCreateInfo { } } } +impl PipelineDynamicStateCreateInfo { + pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> { + PipelineDynamicStateCreateInfoBuilder { + inner: PipelineDynamicStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineDynamicStateCreateInfoBuilder<'a> { + inner: PipelineDynamicStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> { + type Target = PipelineDynamicStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineDynamicStateCreateFlags, + ) -> PipelineDynamicStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn dynamic_state_count( + mut self, + dynamic_state_count: u32, + ) -> PipelineDynamicStateCreateInfoBuilder<'a> { + self.inner.dynamic_state_count = dynamic_state_count; + self + } + pub fn dynamic_states( + mut self, + dynamic_states: &'a [DynamicState], + ) -> PipelineDynamicStateCreateInfoBuilder<'a> { + self.inner.dynamic_state_count = dynamic_states.len() as u32; + self.inner.p_dynamic_states = dynamic_states.as_ptr(); + self + } + pub fn build(self) -> PipelineDynamicStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct StencilOpState { @@ -6250,6 +9832,57 @@ pub struct StencilOpState { pub write_mask: u32, pub reference: u32, } +impl StencilOpState { + pub fn builder<'a>() -> StencilOpStateBuilder<'a> { + StencilOpStateBuilder { + inner: StencilOpState::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct StencilOpStateBuilder<'a> { + inner: StencilOpState, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> { + type Target = StencilOpState; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> StencilOpStateBuilder<'a> { + pub fn fail_op(mut self, fail_op: StencilOp) -> StencilOpStateBuilder<'a> { + self.inner.fail_op = fail_op; + self + } + pub fn pass_op(mut self, pass_op: StencilOp) -> StencilOpStateBuilder<'a> { + self.inner.pass_op = pass_op; + self + } + pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> StencilOpStateBuilder<'a> { + self.inner.depth_fail_op = depth_fail_op; + self + } + pub fn compare_op(mut self, compare_op: CompareOp) -> StencilOpStateBuilder<'a> { + self.inner.compare_op = compare_op; + self + } + pub fn compare_mask(mut self, compare_mask: u32) -> StencilOpStateBuilder<'a> { + self.inner.compare_mask = compare_mask; + self + } + pub fn write_mask(mut self, write_mask: u32) -> StencilOpStateBuilder<'a> { + self.inner.write_mask = write_mask; + self + } + pub fn reference(mut self, reference: u32) -> StencilOpStateBuilder<'a> { + self.inner.reference = reference; + self + } + pub fn build(self) -> StencilOpState { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineDepthStencilStateCreateInfo { @@ -6284,6 +9917,96 @@ impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { } } } +impl PipelineDepthStencilStateCreateInfo { + pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + PipelineDepthStencilStateCreateInfoBuilder { + inner: PipelineDepthStencilStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> { + inner: PipelineDepthStencilStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> { + type Target = PipelineDepthStencilStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineDepthStencilStateCreateFlags, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn depth_test_enable( + mut self, + depth_test_enable: Bool32, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.depth_test_enable = depth_test_enable; + self + } + pub fn depth_write_enable( + mut self, + depth_write_enable: Bool32, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.depth_write_enable = depth_write_enable; + self + } + pub fn depth_compare_op( + mut self, + depth_compare_op: CompareOp, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.depth_compare_op = depth_compare_op; + self + } + pub fn depth_bounds_test_enable( + mut self, + depth_bounds_test_enable: Bool32, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.depth_bounds_test_enable = depth_bounds_test_enable; + self + } + pub fn stencil_test_enable( + mut self, + stencil_test_enable: Bool32, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.stencil_test_enable = stencil_test_enable; + self + } + pub fn front( + mut self, + front: StencilOpState, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.front = front; + self + } + pub fn back(mut self, back: StencilOpState) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.back = back; + self + } + pub fn min_depth_bounds( + mut self, + min_depth_bounds: c_float, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.min_depth_bounds = min_depth_bounds; + self + } + pub fn max_depth_bounds( + mut self, + max_depth_bounds: c_float, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + self.inner.max_depth_bounds = max_depth_bounds; + self + } + pub fn build(self) -> PipelineDepthStencilStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct GraphicsPipelineCreateInfo { @@ -6332,6 +10055,134 @@ impl ::std::default::Default for GraphicsPipelineCreateInfo { } } } +impl GraphicsPipelineCreateInfo { + pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> { + GraphicsPipelineCreateInfoBuilder { + inner: GraphicsPipelineCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct GraphicsPipelineCreateInfoBuilder<'a> { + inner: GraphicsPipelineCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> { + type Target = GraphicsPipelineCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: PipelineCreateFlags) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn stage_count(mut self, stage_count: u32) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.stage_count = stage_count; + self + } + pub fn stages( + mut self, + stages: &'a [PipelineShaderStageCreateInfo], + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.stage_count = stages.len() as u32; + self.inner.p_stages = stages.as_ptr(); + self + } + pub fn vertex_input_state( + mut self, + vertex_input_state: &'a PipelineVertexInputStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_vertex_input_state = vertex_input_state; + self + } + pub fn input_assembly_state( + mut self, + input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_input_assembly_state = input_assembly_state; + self + } + pub fn tessellation_state( + mut self, + tessellation_state: &'a PipelineTessellationStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_tessellation_state = tessellation_state; + self + } + pub fn viewport_state( + mut self, + viewport_state: &'a PipelineViewportStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_viewport_state = viewport_state; + self + } + pub fn rasterization_state( + mut self, + rasterization_state: &'a PipelineRasterizationStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_rasterization_state = rasterization_state; + self + } + pub fn multisample_state( + mut self, + multisample_state: &'a PipelineMultisampleStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_multisample_state = multisample_state; + self + } + pub fn depth_stencil_state( + mut self, + depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_depth_stencil_state = depth_stencil_state; + self + } + pub fn color_blend_state( + mut self, + color_blend_state: &'a PipelineColorBlendStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_color_blend_state = color_blend_state; + self + } + pub fn dynamic_state( + mut self, + dynamic_state: &'a PipelineDynamicStateCreateInfo, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.p_dynamic_state = dynamic_state; + self + } + pub fn layout(mut self, layout: PipelineLayout) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.layout = layout; + self + } + pub fn render_pass(mut self, render_pass: RenderPass) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.render_pass = render_pass; + self + } + pub fn subpass(mut self, subpass: u32) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.subpass = subpass; + self + } + pub fn base_pipeline_handle( + mut self, + base_pipeline_handle: Pipeline, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + pub fn base_pipeline_index( + mut self, + base_pipeline_index: i32, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + pub fn build(self) -> GraphicsPipelineCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineCacheCreateInfo { @@ -6352,6 +10203,48 @@ impl ::std::default::Default for PipelineCacheCreateInfo { } } } +impl PipelineCacheCreateInfo { + pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> { + PipelineCacheCreateInfoBuilder { + inner: PipelineCacheCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineCacheCreateInfoBuilder<'a> { + inner: PipelineCacheCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> { + type Target = PipelineCacheCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineCacheCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> PipelineCacheCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn initial_data_size( + mut self, + initial_data_size: usize, + ) -> PipelineCacheCreateInfoBuilder<'a> { + self.inner.initial_data_size = initial_data_size; + self + } + pub fn initial_data( + mut self, + initial_data: &'a [c_void], + ) -> PipelineCacheCreateInfoBuilder<'a> { + self.inner.initial_data_size = initial_data.len() as usize; + self.inner.p_initial_data = initial_data.as_ptr(); + self + } + pub fn build(self) -> PipelineCacheCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PushConstantRange { @@ -6359,6 +10252,41 @@ pub struct PushConstantRange { pub offset: u32, pub size: u32, } +impl PushConstantRange { + pub fn builder<'a>() -> PushConstantRangeBuilder<'a> { + PushConstantRangeBuilder { + inner: PushConstantRange::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PushConstantRangeBuilder<'a> { + inner: PushConstantRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> { + type Target = PushConstantRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PushConstantRangeBuilder<'a> { + pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> PushConstantRangeBuilder<'a> { + self.inner.stage_flags = stage_flags; + self + } + pub fn offset(mut self, offset: u32) -> PushConstantRangeBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn size(mut self, size: u32) -> PushConstantRangeBuilder<'a> { + self.inner.size = size; + self + } + pub fn build(self) -> PushConstantRange { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineLayoutCreateInfo { @@ -6383,6 +10311,66 @@ impl ::std::default::Default for PipelineLayoutCreateInfo { } } } +impl PipelineLayoutCreateInfo { + pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> { + PipelineLayoutCreateInfoBuilder { + inner: PipelineLayoutCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineLayoutCreateInfoBuilder<'a> { + inner: PipelineLayoutCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> { + type Target = PipelineLayoutCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineLayoutCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineLayoutCreateFlags, + ) -> PipelineLayoutCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn set_layout_count( + mut self, + set_layout_count: u32, + ) -> PipelineLayoutCreateInfoBuilder<'a> { + self.inner.set_layout_count = set_layout_count; + self + } + pub fn set_layouts( + mut self, + set_layouts: &'a [DescriptorSetLayout], + ) -> PipelineLayoutCreateInfoBuilder<'a> { + self.inner.set_layout_count = set_layouts.len() as u32; + self.inner.p_set_layouts = set_layouts.as_ptr(); + self + } + pub fn push_constant_range_count( + mut self, + push_constant_range_count: u32, + ) -> PipelineLayoutCreateInfoBuilder<'a> { + self.inner.push_constant_range_count = push_constant_range_count; + self + } + pub fn push_constant_ranges( + mut self, + push_constant_ranges: &'a [PushConstantRange], + ) -> PipelineLayoutCreateInfoBuilder<'a> { + self.inner.push_constant_range_count = push_constant_ranges.len() as u32; + self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr(); + self + } + pub fn build(self) -> PipelineLayoutCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerCreateInfo { @@ -6429,6 +10417,105 @@ impl ::std::default::Default for SamplerCreateInfo { } } } +impl SamplerCreateInfo { + pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> { + SamplerCreateInfoBuilder { + inner: SamplerCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SamplerCreateInfoBuilder<'a> { + inner: SamplerCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> { + type Target = SamplerCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SamplerCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: SamplerCreateFlags) -> SamplerCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn mag_filter(mut self, mag_filter: Filter) -> SamplerCreateInfoBuilder<'a> { + self.inner.mag_filter = mag_filter; + self + } + pub fn min_filter(mut self, min_filter: Filter) -> SamplerCreateInfoBuilder<'a> { + self.inner.min_filter = min_filter; + self + } + pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> SamplerCreateInfoBuilder<'a> { + self.inner.mipmap_mode = mipmap_mode; + self + } + pub fn address_mode_u( + mut self, + address_mode_u: SamplerAddressMode, + ) -> SamplerCreateInfoBuilder<'a> { + self.inner.address_mode_u = address_mode_u; + self + } + pub fn address_mode_v( + mut self, + address_mode_v: SamplerAddressMode, + ) -> SamplerCreateInfoBuilder<'a> { + self.inner.address_mode_v = address_mode_v; + self + } + pub fn address_mode_w( + mut self, + address_mode_w: SamplerAddressMode, + ) -> SamplerCreateInfoBuilder<'a> { + self.inner.address_mode_w = address_mode_w; + self + } + pub fn mip_lod_bias(mut self, mip_lod_bias: c_float) -> SamplerCreateInfoBuilder<'a> { + self.inner.mip_lod_bias = mip_lod_bias; + self + } + pub fn anisotropy_enable(mut self, anisotropy_enable: Bool32) -> SamplerCreateInfoBuilder<'a> { + self.inner.anisotropy_enable = anisotropy_enable; + self + } + pub fn max_anisotropy(mut self, max_anisotropy: c_float) -> SamplerCreateInfoBuilder<'a> { + self.inner.max_anisotropy = max_anisotropy; + self + } + pub fn compare_enable(mut self, compare_enable: Bool32) -> SamplerCreateInfoBuilder<'a> { + self.inner.compare_enable = compare_enable; + self + } + pub fn compare_op(mut self, compare_op: CompareOp) -> SamplerCreateInfoBuilder<'a> { + self.inner.compare_op = compare_op; + self + } + pub fn min_lod(mut self, min_lod: c_float) -> SamplerCreateInfoBuilder<'a> { + self.inner.min_lod = min_lod; + self + } + pub fn max_lod(mut self, max_lod: c_float) -> SamplerCreateInfoBuilder<'a> { + self.inner.max_lod = max_lod; + self + } + pub fn border_color(mut self, border_color: BorderColor) -> SamplerCreateInfoBuilder<'a> { + self.inner.border_color = border_color; + self + } + pub fn unnormalized_coordinates( + mut self, + unnormalized_coordinates: Bool32, + ) -> SamplerCreateInfoBuilder<'a> { + self.inner.unnormalized_coordinates = unnormalized_coordinates; + self + } + pub fn build(self) -> SamplerCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandPoolCreateInfo { @@ -6447,6 +10534,40 @@ impl ::std::default::Default for CommandPoolCreateInfo { } } } +impl CommandPoolCreateInfo { + pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> { + CommandPoolCreateInfoBuilder { + inner: CommandPoolCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct CommandPoolCreateInfoBuilder<'a> { + inner: CommandPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> { + type Target = CommandPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> CommandPoolCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: CommandPoolCreateFlags) -> CommandPoolCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn queue_family_index( + mut self, + queue_family_index: u32, + ) -> CommandPoolCreateInfoBuilder<'a> { + self.inner.queue_family_index = queue_family_index; + self + } + pub fn build(self) -> CommandPoolCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandBufferAllocateInfo { @@ -6467,6 +10588,47 @@ impl ::std::default::Default for CommandBufferAllocateInfo { } } } +impl CommandBufferAllocateInfo { + pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> { + CommandBufferAllocateInfoBuilder { + inner: CommandBufferAllocateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct CommandBufferAllocateInfoBuilder<'a> { + inner: CommandBufferAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> { + type Target = CommandBufferAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> CommandBufferAllocateInfoBuilder<'a> { + pub fn command_pool( + mut self, + command_pool: CommandPool, + ) -> CommandBufferAllocateInfoBuilder<'a> { + self.inner.command_pool = command_pool; + self + } + pub fn level(mut self, level: CommandBufferLevel) -> CommandBufferAllocateInfoBuilder<'a> { + self.inner.level = level; + self + } + pub fn command_buffer_count( + mut self, + command_buffer_count: u32, + ) -> CommandBufferAllocateInfoBuilder<'a> { + self.inner.command_buffer_count = command_buffer_count; + self + } + pub fn build(self) -> CommandBufferAllocateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandBufferInheritanceInfo { @@ -6493,6 +10655,68 @@ impl ::std::default::Default for CommandBufferInheritanceInfo { } } } +impl CommandBufferInheritanceInfo { + pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> { + CommandBufferInheritanceInfoBuilder { + inner: CommandBufferInheritanceInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct CommandBufferInheritanceInfoBuilder<'a> { + inner: CommandBufferInheritanceInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> { + type Target = CommandBufferInheritanceInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> CommandBufferInheritanceInfoBuilder<'a> { + pub fn render_pass( + mut self, + render_pass: RenderPass, + ) -> CommandBufferInheritanceInfoBuilder<'a> { + self.inner.render_pass = render_pass; + self + } + pub fn subpass(mut self, subpass: u32) -> CommandBufferInheritanceInfoBuilder<'a> { + self.inner.subpass = subpass; + self + } + pub fn framebuffer( + mut self, + framebuffer: Framebuffer, + ) -> CommandBufferInheritanceInfoBuilder<'a> { + self.inner.framebuffer = framebuffer; + self + } + pub fn occlusion_query_enable( + mut self, + occlusion_query_enable: Bool32, + ) -> CommandBufferInheritanceInfoBuilder<'a> { + self.inner.occlusion_query_enable = occlusion_query_enable; + self + } + pub fn query_flags( + mut self, + query_flags: QueryControlFlags, + ) -> CommandBufferInheritanceInfoBuilder<'a> { + self.inner.query_flags = query_flags; + self + } + pub fn pipeline_statistics( + mut self, + pipeline_statistics: QueryPipelineStatisticFlags, + ) -> CommandBufferInheritanceInfoBuilder<'a> { + self.inner.pipeline_statistics = pipeline_statistics; + self + } + pub fn build(self) -> CommandBufferInheritanceInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CommandBufferBeginInfo { @@ -6511,6 +10735,40 @@ impl ::std::default::Default for CommandBufferBeginInfo { } } } +impl CommandBufferBeginInfo { + pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> { + CommandBufferBeginInfoBuilder { + inner: CommandBufferBeginInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct CommandBufferBeginInfoBuilder<'a> { + inner: CommandBufferBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> { + type Target = CommandBufferBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> CommandBufferBeginInfoBuilder<'a> { + pub fn flags(mut self, flags: CommandBufferUsageFlags) -> CommandBufferBeginInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn inheritance_info( + mut self, + inheritance_info: &'a CommandBufferInheritanceInfo, + ) -> CommandBufferBeginInfoBuilder<'a> { + self.inner.p_inheritance_info = inheritance_info; + self + } + pub fn build(self) -> CommandBufferBeginInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct RenderPassBeginInfo { @@ -6548,6 +10806,53 @@ impl ::std::default::Default for RenderPassBeginInfo { } } } +impl RenderPassBeginInfo { + pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> { + RenderPassBeginInfoBuilder { + inner: RenderPassBeginInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RenderPassBeginInfoBuilder<'a> { + inner: RenderPassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> { + type Target = RenderPassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RenderPassBeginInfoBuilder<'a> { + pub fn render_pass(mut self, render_pass: RenderPass) -> RenderPassBeginInfoBuilder<'a> { + self.inner.render_pass = render_pass; + self + } + pub fn framebuffer(mut self, framebuffer: Framebuffer) -> RenderPassBeginInfoBuilder<'a> { + self.inner.framebuffer = framebuffer; + self + } + pub fn render_area(mut self, render_area: Rect2D) -> RenderPassBeginInfoBuilder<'a> { + self.inner.render_area = render_area; + self + } + pub fn clear_value_count(mut self, clear_value_count: u32) -> RenderPassBeginInfoBuilder<'a> { + self.inner.clear_value_count = clear_value_count; + self + } + pub fn clear_values( + mut self, + clear_values: &'a [ClearValue], + ) -> RenderPassBeginInfoBuilder<'a> { + self.inner.clear_value_count = clear_values.len() as u32; + self.inner.p_clear_values = clear_values.as_ptr(); + self + } + pub fn build(self) -> RenderPassBeginInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub union ClearColorValue { @@ -6566,6 +10871,37 @@ pub struct ClearDepthStencilValue { pub depth: c_float, pub stencil: u32, } +impl ClearDepthStencilValue { + pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> { + ClearDepthStencilValueBuilder { + inner: ClearDepthStencilValue::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ClearDepthStencilValueBuilder<'a> { + inner: ClearDepthStencilValue, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> { + type Target = ClearDepthStencilValue; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ClearDepthStencilValueBuilder<'a> { + pub fn depth(mut self, depth: c_float) -> ClearDepthStencilValueBuilder<'a> { + self.inner.depth = depth; + self + } + pub fn stencil(mut self, stencil: u32) -> ClearDepthStencilValueBuilder<'a> { + self.inner.stencil = stencil; + self + } + pub fn build(self) -> ClearDepthStencilValue { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub union ClearValue { @@ -6593,6 +10929,41 @@ impl fmt::Debug for ClearAttachment { .finish() } } +impl ClearAttachment { + pub fn builder<'a>() -> ClearAttachmentBuilder<'a> { + ClearAttachmentBuilder { + inner: ClearAttachment::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ClearAttachmentBuilder<'a> { + inner: ClearAttachment, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> { + type Target = ClearAttachment; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ClearAttachmentBuilder<'a> { + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ClearAttachmentBuilder<'a> { + self.inner.aspect_mask = aspect_mask; + self + } + pub fn color_attachment(mut self, color_attachment: u32) -> ClearAttachmentBuilder<'a> { + self.inner.color_attachment = color_attachment; + self + } + pub fn clear_value(mut self, clear_value: ClearValue) -> ClearAttachmentBuilder<'a> { + self.inner.clear_value = clear_value; + self + } + pub fn build(self) -> ClearAttachment { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct AttachmentDescription { @@ -6606,12 +10977,111 @@ pub struct AttachmentDescription { pub initial_layout: ImageLayout, pub final_layout: ImageLayout, } +impl AttachmentDescription { + pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> { + AttachmentDescriptionBuilder { + inner: AttachmentDescription::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AttachmentDescriptionBuilder<'a> { + inner: AttachmentDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> { + type Target = AttachmentDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AttachmentDescriptionBuilder<'a> { + pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescriptionBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn format(mut self, format: Format) -> AttachmentDescriptionBuilder<'a> { + self.inner.format = format; + self + } + pub fn samples(mut self, samples: SampleCountFlags) -> AttachmentDescriptionBuilder<'a> { + self.inner.samples = samples; + self + } + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> AttachmentDescriptionBuilder<'a> { + self.inner.load_op = load_op; + self + } + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> AttachmentDescriptionBuilder<'a> { + self.inner.store_op = store_op; + self + } + pub fn stencil_load_op( + mut self, + stencil_load_op: AttachmentLoadOp, + ) -> AttachmentDescriptionBuilder<'a> { + self.inner.stencil_load_op = stencil_load_op; + self + } + pub fn stencil_store_op( + mut self, + stencil_store_op: AttachmentStoreOp, + ) -> AttachmentDescriptionBuilder<'a> { + self.inner.stencil_store_op = stencil_store_op; + self + } + pub fn initial_layout( + mut self, + initial_layout: ImageLayout, + ) -> AttachmentDescriptionBuilder<'a> { + self.inner.initial_layout = initial_layout; + self + } + pub fn final_layout(mut self, final_layout: ImageLayout) -> AttachmentDescriptionBuilder<'a> { + self.inner.final_layout = final_layout; + self + } + pub fn build(self) -> AttachmentDescription { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct AttachmentReference { pub attachment: u32, pub layout: ImageLayout, } +impl AttachmentReference { + pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> { + AttachmentReferenceBuilder { + inner: AttachmentReference::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AttachmentReferenceBuilder<'a> { + inner: AttachmentReference, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> { + type Target = AttachmentReference; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AttachmentReferenceBuilder<'a> { + pub fn attachment(mut self, attachment: u32) -> AttachmentReferenceBuilder<'a> { + self.inner.attachment = attachment; + self + } + pub fn layout(mut self, layout: ImageLayout) -> AttachmentReferenceBuilder<'a> { + self.inner.layout = layout; + self + } + pub fn build(self) -> AttachmentReference { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SubpassDescription { @@ -6642,6 +11112,100 @@ impl ::std::default::Default for SubpassDescription { } } } +impl SubpassDescription { + pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> { + SubpassDescriptionBuilder { + inner: SubpassDescription::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SubpassDescriptionBuilder<'a> { + inner: SubpassDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> { + type Target = SubpassDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SubpassDescriptionBuilder<'a> { + pub fn flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescriptionBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: PipelineBindPoint, + ) -> SubpassDescriptionBuilder<'a> { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn input_attachment_count( + mut self, + input_attachment_count: u32, + ) -> SubpassDescriptionBuilder<'a> { + self.inner.input_attachment_count = input_attachment_count; + self + } + pub fn input_attachments( + mut self, + input_attachments: &'a [AttachmentReference], + ) -> SubpassDescriptionBuilder<'a> { + self.inner.input_attachment_count = input_attachments.len() as u32; + self.inner.p_input_attachments = input_attachments.as_ptr(); + self + } + pub fn color_attachment_count( + mut self, + color_attachment_count: u32, + ) -> SubpassDescriptionBuilder<'a> { + self.inner.color_attachment_count = color_attachment_count; + self + } + pub fn color_attachments( + mut self, + color_attachments: &'a [AttachmentReference], + ) -> SubpassDescriptionBuilder<'a> { + self.inner.color_attachment_count = color_attachments.len() as u32; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + pub fn resolve_attachments( + mut self, + resolve_attachments: &'a [AttachmentReference], + ) -> SubpassDescriptionBuilder<'a> { + self.inner.color_attachment_count = resolve_attachments.len() as u32; + self.inner.p_resolve_attachments = resolve_attachments.as_ptr(); + self + } + pub fn depth_stencil_attachment( + mut self, + depth_stencil_attachment: *const AttachmentReference, + ) -> SubpassDescriptionBuilder<'a> { + self.inner.p_depth_stencil_attachment = depth_stencil_attachment; + self + } + pub fn preserve_attachment_count( + mut self, + preserve_attachment_count: u32, + ) -> SubpassDescriptionBuilder<'a> { + self.inner.preserve_attachment_count = preserve_attachment_count; + self + } + pub fn preserve_attachments( + mut self, + preserve_attachments: &'a [u32], + ) -> SubpassDescriptionBuilder<'a> { + self.inner.preserve_attachment_count = preserve_attachments.len() as u32; + self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); + self + } + pub fn build(self) -> SubpassDescription { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SubpassDependency { @@ -6653,6 +11217,66 @@ pub struct SubpassDependency { pub dst_access_mask: AccessFlags, pub dependency_flags: DependencyFlags, } +impl SubpassDependency { + pub fn builder<'a>() -> SubpassDependencyBuilder<'a> { + SubpassDependencyBuilder { + inner: SubpassDependency::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SubpassDependencyBuilder<'a> { + inner: SubpassDependency, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> { + type Target = SubpassDependency; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SubpassDependencyBuilder<'a> { + pub fn src_subpass(mut self, src_subpass: u32) -> SubpassDependencyBuilder<'a> { + self.inner.src_subpass = src_subpass; + self + } + pub fn dst_subpass(mut self, dst_subpass: u32) -> SubpassDependencyBuilder<'a> { + self.inner.dst_subpass = dst_subpass; + self + } + pub fn src_stage_mask( + mut self, + src_stage_mask: PipelineStageFlags, + ) -> SubpassDependencyBuilder<'a> { + self.inner.src_stage_mask = src_stage_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: PipelineStageFlags, + ) -> SubpassDependencyBuilder<'a> { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a> { + self.inner.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a> { + self.inner.dst_access_mask = dst_access_mask; + self + } + pub fn dependency_flags( + mut self, + dependency_flags: DependencyFlags, + ) -> SubpassDependencyBuilder<'a> { + self.inner.dependency_flags = dependency_flags; + self + } + pub fn build(self) -> SubpassDependency { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct RenderPassCreateInfo { @@ -6681,6 +11305,69 @@ impl ::std::default::Default for RenderPassCreateInfo { } } } +impl RenderPassCreateInfo { + pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> { + RenderPassCreateInfoBuilder { + inner: RenderPassCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RenderPassCreateInfoBuilder<'a> { + inner: RenderPassCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> { + type Target = RenderPassCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RenderPassCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn attachment_count(mut self, attachment_count: u32) -> RenderPassCreateInfoBuilder<'a> { + self.inner.attachment_count = attachment_count; + self + } + pub fn attachments( + mut self, + attachments: &'a [AttachmentDescription], + ) -> RenderPassCreateInfoBuilder<'a> { + self.inner.attachment_count = attachments.len() as u32; + self.inner.p_attachments = attachments.as_ptr(); + self + } + pub fn subpass_count(mut self, subpass_count: u32) -> RenderPassCreateInfoBuilder<'a> { + self.inner.subpass_count = subpass_count; + self + } + pub fn subpasses( + mut self, + subpasses: &'a [SubpassDescription], + ) -> RenderPassCreateInfoBuilder<'a> { + self.inner.subpass_count = subpasses.len() as u32; + self.inner.p_subpasses = subpasses.as_ptr(); + self + } + pub fn dependency_count(mut self, dependency_count: u32) -> RenderPassCreateInfoBuilder<'a> { + self.inner.dependency_count = dependency_count; + self + } + pub fn dependencies( + mut self, + dependencies: &'a [SubpassDependency], + ) -> RenderPassCreateInfoBuilder<'a> { + self.inner.dependency_count = dependencies.len() as u32; + self.inner.p_dependencies = dependencies.as_ptr(); + self + } + pub fn build(self) -> RenderPassCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct EventCreateInfo { @@ -6697,6 +11384,33 @@ impl ::std::default::Default for EventCreateInfo { } } } +impl EventCreateInfo { + pub fn builder<'a>() -> EventCreateInfoBuilder<'a> { + EventCreateInfoBuilder { + inner: EventCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct EventCreateInfoBuilder<'a> { + inner: EventCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { + type Target = EventCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> EventCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: EventCreateFlags) -> EventCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> EventCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FenceCreateInfo { @@ -6713,6 +11427,33 @@ impl ::std::default::Default for FenceCreateInfo { } } } +impl FenceCreateInfo { + pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> { + FenceCreateInfoBuilder { + inner: FenceCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct FenceCreateInfoBuilder<'a> { + inner: FenceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> { + type Target = FenceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> FenceCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: FenceCreateFlags) -> FenceCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> FenceCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceFeatures { @@ -6772,6 +11513,382 @@ pub struct PhysicalDeviceFeatures { pub variable_multisample_rate: Bool32, pub inherited_queries: Bool32, } +impl PhysicalDeviceFeatures { + pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> { + PhysicalDeviceFeaturesBuilder { + inner: PhysicalDeviceFeatures::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceFeaturesBuilder<'a> { + inner: PhysicalDeviceFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> { + type Target = PhysicalDeviceFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceFeaturesBuilder<'a> { + pub fn robust_buffer_access( + mut self, + robust_buffer_access: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.robust_buffer_access = robust_buffer_access; + self + } + pub fn full_draw_index_uint32( + mut self, + full_draw_index_uint32: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.full_draw_index_uint32 = full_draw_index_uint32; + self + } + pub fn image_cube_array( + mut self, + image_cube_array: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.image_cube_array = image_cube_array; + self + } + pub fn independent_blend( + mut self, + independent_blend: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.independent_blend = independent_blend; + self + } + pub fn geometry_shader(mut self, geometry_shader: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.geometry_shader = geometry_shader; + self + } + pub fn tessellation_shader( + mut self, + tessellation_shader: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.tessellation_shader = tessellation_shader; + self + } + pub fn sample_rate_shading( + mut self, + sample_rate_shading: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sample_rate_shading = sample_rate_shading; + self + } + pub fn dual_src_blend(mut self, dual_src_blend: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.dual_src_blend = dual_src_blend; + self + } + pub fn logic_op(mut self, logic_op: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.logic_op = logic_op; + self + } + pub fn multi_draw_indirect( + mut self, + multi_draw_indirect: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.multi_draw_indirect = multi_draw_indirect; + self + } + pub fn draw_indirect_first_instance( + mut self, + draw_indirect_first_instance: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.draw_indirect_first_instance = draw_indirect_first_instance; + self + } + pub fn depth_clamp(mut self, depth_clamp: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.depth_clamp = depth_clamp; + self + } + pub fn depth_bias_clamp( + mut self, + depth_bias_clamp: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.depth_bias_clamp = depth_bias_clamp; + self + } + pub fn fill_mode_non_solid( + mut self, + fill_mode_non_solid: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.fill_mode_non_solid = fill_mode_non_solid; + self + } + pub fn depth_bounds(mut self, depth_bounds: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.depth_bounds = depth_bounds; + self + } + pub fn wide_lines(mut self, wide_lines: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.wide_lines = wide_lines; + self + } + pub fn large_points(mut self, large_points: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.large_points = large_points; + self + } + pub fn alpha_to_one(mut self, alpha_to_one: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.alpha_to_one = alpha_to_one; + self + } + pub fn multi_viewport(mut self, multi_viewport: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.multi_viewport = multi_viewport; + self + } + pub fn sampler_anisotropy( + mut self, + sampler_anisotropy: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sampler_anisotropy = sampler_anisotropy; + self + } + pub fn texture_compression_etc2( + mut self, + texture_compression_etc2: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.texture_compression_etc2 = texture_compression_etc2; + self + } + pub fn texture_compression_astc_ldr( + mut self, + texture_compression_astc_ldr: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr; + self + } + pub fn texture_compression_bc( + mut self, + texture_compression_bc: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.texture_compression_bc = texture_compression_bc; + self + } + pub fn occlusion_query_precise( + mut self, + occlusion_query_precise: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.occlusion_query_precise = occlusion_query_precise; + self + } + pub fn pipeline_statistics_query( + mut self, + pipeline_statistics_query: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.pipeline_statistics_query = pipeline_statistics_query; + self + } + pub fn vertex_pipeline_stores_and_atomics( + mut self, + vertex_pipeline_stores_and_atomics: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics; + self + } + pub fn fragment_stores_and_atomics( + mut self, + fragment_stores_and_atomics: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics; + self + } + pub fn shader_tessellation_and_geometry_point_size( + mut self, + shader_tessellation_and_geometry_point_size: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_tessellation_and_geometry_point_size = + shader_tessellation_and_geometry_point_size; + self + } + pub fn shader_image_gather_extended( + mut self, + shader_image_gather_extended: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_image_gather_extended = shader_image_gather_extended; + self + } + pub fn shader_storage_image_extended_formats( + mut self, + shader_storage_image_extended_formats: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_storage_image_extended_formats = shader_storage_image_extended_formats; + self + } + pub fn shader_storage_image_multisample( + mut self, + shader_storage_image_multisample: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_storage_image_multisample = shader_storage_image_multisample; + self + } + pub fn shader_storage_image_read_without_format( + mut self, + shader_storage_image_read_without_format: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_storage_image_read_without_format = + shader_storage_image_read_without_format; + self + } + pub fn shader_storage_image_write_without_format( + mut self, + shader_storage_image_write_without_format: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_storage_image_write_without_format = + shader_storage_image_write_without_format; + self + } + pub fn shader_uniform_buffer_array_dynamic_indexing( + mut self, + shader_uniform_buffer_array_dynamic_indexing: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_uniform_buffer_array_dynamic_indexing = + shader_uniform_buffer_array_dynamic_indexing; + self + } + pub fn shader_sampled_image_array_dynamic_indexing( + mut self, + shader_sampled_image_array_dynamic_indexing: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_sampled_image_array_dynamic_indexing = + shader_sampled_image_array_dynamic_indexing; + self + } + pub fn shader_storage_buffer_array_dynamic_indexing( + mut self, + shader_storage_buffer_array_dynamic_indexing: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_storage_buffer_array_dynamic_indexing = + shader_storage_buffer_array_dynamic_indexing; + self + } + pub fn shader_storage_image_array_dynamic_indexing( + mut self, + shader_storage_image_array_dynamic_indexing: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_storage_image_array_dynamic_indexing = + shader_storage_image_array_dynamic_indexing; + self + } + pub fn shader_clip_distance( + mut self, + shader_clip_distance: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_clip_distance = shader_clip_distance; + self + } + pub fn shader_cull_distance( + mut self, + shader_cull_distance: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_cull_distance = shader_cull_distance; + self + } + pub fn shader_float64(mut self, shader_float64: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_float64 = shader_float64; + self + } + pub fn shader_int64(mut self, shader_int64: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_int64 = shader_int64; + self + } + pub fn shader_int16(mut self, shader_int16: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_int16 = shader_int16; + self + } + pub fn shader_resource_residency( + mut self, + shader_resource_residency: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_resource_residency = shader_resource_residency; + self + } + pub fn shader_resource_min_lod( + mut self, + shader_resource_min_lod: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.shader_resource_min_lod = shader_resource_min_lod; + self + } + pub fn sparse_binding(mut self, sparse_binding: Bool32) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_binding = sparse_binding; + self + } + pub fn sparse_residency_buffer( + mut self, + sparse_residency_buffer: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency_buffer = sparse_residency_buffer; + self + } + pub fn sparse_residency_image2_d( + mut self, + sparse_residency_image2_d: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency_image2_d = sparse_residency_image2_d; + self + } + pub fn sparse_residency_image3_d( + mut self, + sparse_residency_image3_d: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency_image3_d = sparse_residency_image3_d; + self + } + pub fn sparse_residency2_samples( + mut self, + sparse_residency2_samples: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency2_samples = sparse_residency2_samples; + self + } + pub fn sparse_residency4_samples( + mut self, + sparse_residency4_samples: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency4_samples = sparse_residency4_samples; + self + } + pub fn sparse_residency8_samples( + mut self, + sparse_residency8_samples: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency8_samples = sparse_residency8_samples; + self + } + pub fn sparse_residency16_samples( + mut self, + sparse_residency16_samples: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency16_samples = sparse_residency16_samples; + self + } + pub fn sparse_residency_aliased( + mut self, + sparse_residency_aliased: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.sparse_residency_aliased = sparse_residency_aliased; + self + } + pub fn variable_multisample_rate( + mut self, + variable_multisample_rate: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.variable_multisample_rate = variable_multisample_rate; + self + } + pub fn inherited_queries( + mut self, + inherited_queries: Bool32, + ) -> PhysicalDeviceFeaturesBuilder<'a> { + self.inner.inherited_queries = inherited_queries; + self + } + pub fn build(self) -> PhysicalDeviceFeatures { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PhysicalDeviceSparseProperties { @@ -6781,6 +11898,65 @@ pub struct PhysicalDeviceSparseProperties { pub residency_aligned_mip_size: Bool32, pub residency_non_resident_strict: Bool32, } +impl PhysicalDeviceSparseProperties { + pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> { + PhysicalDeviceSparsePropertiesBuilder { + inner: PhysicalDeviceSparseProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceSparsePropertiesBuilder<'a> { + inner: PhysicalDeviceSparseProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> { + type Target = PhysicalDeviceSparseProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> { + pub fn residency_standard2_d_block_shape( + mut self, + residency_standard2_d_block_shape: Bool32, + ) -> PhysicalDeviceSparsePropertiesBuilder<'a> { + self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape; + self + } + pub fn residency_standard2_d_multisample_block_shape( + mut self, + residency_standard2_d_multisample_block_shape: Bool32, + ) -> PhysicalDeviceSparsePropertiesBuilder<'a> { + self.inner.residency_standard2_d_multisample_block_shape = + residency_standard2_d_multisample_block_shape; + self + } + pub fn residency_standard3_d_block_shape( + mut self, + residency_standard3_d_block_shape: Bool32, + ) -> PhysicalDeviceSparsePropertiesBuilder<'a> { + self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape; + self + } + pub fn residency_aligned_mip_size( + mut self, + residency_aligned_mip_size: Bool32, + ) -> PhysicalDeviceSparsePropertiesBuilder<'a> { + self.inner.residency_aligned_mip_size = residency_aligned_mip_size; + self + } + pub fn residency_non_resident_strict( + mut self, + residency_non_resident_strict: Bool32, + ) -> PhysicalDeviceSparsePropertiesBuilder<'a> { + self.inner.residency_non_resident_strict = residency_non_resident_strict; + self + } + pub fn build(self) -> PhysicalDeviceSparseProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceLimits { @@ -7003,6 +12179,777 @@ impl ::std::default::Default for PhysicalDeviceLimits { } } } +impl PhysicalDeviceLimits { + pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> { + PhysicalDeviceLimitsBuilder { + inner: PhysicalDeviceLimits::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceLimitsBuilder<'a> { + inner: PhysicalDeviceLimits, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> { + type Target = PhysicalDeviceLimits; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceLimitsBuilder<'a> { + pub fn max_image_dimension1_d( + mut self, + max_image_dimension1_d: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_image_dimension1_d = max_image_dimension1_d; + self + } + pub fn max_image_dimension2_d( + mut self, + max_image_dimension2_d: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_image_dimension2_d = max_image_dimension2_d; + self + } + pub fn max_image_dimension3_d( + mut self, + max_image_dimension3_d: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_image_dimension3_d = max_image_dimension3_d; + self + } + pub fn max_image_dimension_cube( + mut self, + max_image_dimension_cube: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_image_dimension_cube = max_image_dimension_cube; + self + } + pub fn max_image_array_layers( + mut self, + max_image_array_layers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + pub fn max_texel_buffer_elements( + mut self, + max_texel_buffer_elements: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_texel_buffer_elements = max_texel_buffer_elements; + self + } + pub fn max_uniform_buffer_range( + mut self, + max_uniform_buffer_range: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_uniform_buffer_range = max_uniform_buffer_range; + self + } + pub fn max_storage_buffer_range( + mut self, + max_storage_buffer_range: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_storage_buffer_range = max_storage_buffer_range; + self + } + pub fn max_push_constants_size( + mut self, + max_push_constants_size: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_push_constants_size = max_push_constants_size; + self + } + pub fn max_memory_allocation_count( + mut self, + max_memory_allocation_count: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_memory_allocation_count = max_memory_allocation_count; + self + } + pub fn max_sampler_allocation_count( + mut self, + max_sampler_allocation_count: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_sampler_allocation_count = max_sampler_allocation_count; + self + } + pub fn buffer_image_granularity( + mut self, + buffer_image_granularity: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.buffer_image_granularity = buffer_image_granularity; + self + } + pub fn sparse_address_space_size( + mut self, + sparse_address_space_size: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sparse_address_space_size = sparse_address_space_size; + self + } + pub fn max_bound_descriptor_sets( + mut self, + max_bound_descriptor_sets: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets; + self + } + pub fn max_per_stage_descriptor_samplers( + mut self, + max_per_stage_descriptor_samplers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers; + self + } + pub fn max_per_stage_descriptor_uniform_buffers( + mut self, + max_per_stage_descriptor_uniform_buffers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_per_stage_descriptor_uniform_buffers = + max_per_stage_descriptor_uniform_buffers; + self + } + pub fn max_per_stage_descriptor_storage_buffers( + mut self, + max_per_stage_descriptor_storage_buffers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_per_stage_descriptor_storage_buffers = + max_per_stage_descriptor_storage_buffers; + self + } + pub fn max_per_stage_descriptor_sampled_images( + mut self, + max_per_stage_descriptor_sampled_images: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_per_stage_descriptor_sampled_images = + max_per_stage_descriptor_sampled_images; + self + } + pub fn max_per_stage_descriptor_storage_images( + mut self, + max_per_stage_descriptor_storage_images: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_per_stage_descriptor_storage_images = + max_per_stage_descriptor_storage_images; + self + } + pub fn max_per_stage_descriptor_input_attachments( + mut self, + max_per_stage_descriptor_input_attachments: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_per_stage_descriptor_input_attachments = + max_per_stage_descriptor_input_attachments; + self + } + pub fn max_per_stage_resources( + mut self, + max_per_stage_resources: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_per_stage_resources = max_per_stage_resources; + self + } + pub fn max_descriptor_set_samplers( + mut self, + max_descriptor_set_samplers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers; + self + } + pub fn max_descriptor_set_uniform_buffers( + mut self, + max_descriptor_set_uniform_buffers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers; + self + } + pub fn max_descriptor_set_uniform_buffers_dynamic( + mut self, + max_descriptor_set_uniform_buffers_dynamic: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_uniform_buffers_dynamic = + max_descriptor_set_uniform_buffers_dynamic; + self + } + pub fn max_descriptor_set_storage_buffers( + mut self, + max_descriptor_set_storage_buffers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers; + self + } + pub fn max_descriptor_set_storage_buffers_dynamic( + mut self, + max_descriptor_set_storage_buffers_dynamic: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_storage_buffers_dynamic = + max_descriptor_set_storage_buffers_dynamic; + self + } + pub fn max_descriptor_set_sampled_images( + mut self, + max_descriptor_set_sampled_images: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images; + self + } + pub fn max_descriptor_set_storage_images( + mut self, + max_descriptor_set_storage_images: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images; + self + } + pub fn max_descriptor_set_input_attachments( + mut self, + max_descriptor_set_input_attachments: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments; + self + } + pub fn max_vertex_input_attributes( + mut self, + max_vertex_input_attributes: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_vertex_input_attributes = max_vertex_input_attributes; + self + } + pub fn max_vertex_input_bindings( + mut self, + max_vertex_input_bindings: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_vertex_input_bindings = max_vertex_input_bindings; + self + } + pub fn max_vertex_input_attribute_offset( + mut self, + max_vertex_input_attribute_offset: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset; + self + } + pub fn max_vertex_input_binding_stride( + mut self, + max_vertex_input_binding_stride: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride; + self + } + pub fn max_vertex_output_components( + mut self, + max_vertex_output_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_vertex_output_components = max_vertex_output_components; + self + } + pub fn max_tessellation_generation_level( + mut self, + max_tessellation_generation_level: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_tessellation_generation_level = max_tessellation_generation_level; + self + } + pub fn max_tessellation_patch_size( + mut self, + max_tessellation_patch_size: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_tessellation_patch_size = max_tessellation_patch_size; + self + } + pub fn max_tessellation_control_per_vertex_input_components( + mut self, + max_tessellation_control_per_vertex_input_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner + .max_tessellation_control_per_vertex_input_components = + max_tessellation_control_per_vertex_input_components; + self + } + pub fn max_tessellation_control_per_vertex_output_components( + mut self, + max_tessellation_control_per_vertex_output_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner + .max_tessellation_control_per_vertex_output_components = + max_tessellation_control_per_vertex_output_components; + self + } + pub fn max_tessellation_control_per_patch_output_components( + mut self, + max_tessellation_control_per_patch_output_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner + .max_tessellation_control_per_patch_output_components = + max_tessellation_control_per_patch_output_components; + self + } + pub fn max_tessellation_control_total_output_components( + mut self, + max_tessellation_control_total_output_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_tessellation_control_total_output_components = + max_tessellation_control_total_output_components; + self + } + pub fn max_tessellation_evaluation_input_components( + mut self, + max_tessellation_evaluation_input_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_tessellation_evaluation_input_components = + max_tessellation_evaluation_input_components; + self + } + pub fn max_tessellation_evaluation_output_components( + mut self, + max_tessellation_evaluation_output_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_tessellation_evaluation_output_components = + max_tessellation_evaluation_output_components; + self + } + pub fn max_geometry_shader_invocations( + mut self, + max_geometry_shader_invocations: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations; + self + } + pub fn max_geometry_input_components( + mut self, + max_geometry_input_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_geometry_input_components = max_geometry_input_components; + self + } + pub fn max_geometry_output_components( + mut self, + max_geometry_output_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_geometry_output_components = max_geometry_output_components; + self + } + pub fn max_geometry_output_vertices( + mut self, + max_geometry_output_vertices: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_geometry_output_vertices = max_geometry_output_vertices; + self + } + pub fn max_geometry_total_output_components( + mut self, + max_geometry_total_output_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_geometry_total_output_components = max_geometry_total_output_components; + self + } + pub fn max_fragment_input_components( + mut self, + max_fragment_input_components: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_fragment_input_components = max_fragment_input_components; + self + } + pub fn max_fragment_output_attachments( + mut self, + max_fragment_output_attachments: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_fragment_output_attachments = max_fragment_output_attachments; + self + } + pub fn max_fragment_dual_src_attachments( + mut self, + max_fragment_dual_src_attachments: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments; + self + } + pub fn max_fragment_combined_output_resources( + mut self, + max_fragment_combined_output_resources: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources; + self + } + pub fn max_compute_shared_memory_size( + mut self, + max_compute_shared_memory_size: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size; + self + } + pub fn max_compute_work_group_count( + mut self, + max_compute_work_group_count: [u32; 3], + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_compute_work_group_count = max_compute_work_group_count; + self + } + pub fn max_compute_work_group_invocations( + mut self, + max_compute_work_group_invocations: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations; + self + } + pub fn max_compute_work_group_size( + mut self, + max_compute_work_group_size: [u32; 3], + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_compute_work_group_size = max_compute_work_group_size; + self + } + pub fn sub_pixel_precision_bits( + mut self, + sub_pixel_precision_bits: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits; + self + } + pub fn sub_texel_precision_bits( + mut self, + sub_texel_precision_bits: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sub_texel_precision_bits = sub_texel_precision_bits; + self + } + pub fn mipmap_precision_bits( + mut self, + mipmap_precision_bits: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.mipmap_precision_bits = mipmap_precision_bits; + self + } + pub fn max_draw_indexed_index_value( + mut self, + max_draw_indexed_index_value: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value; + self + } + pub fn max_draw_indirect_count( + mut self, + max_draw_indirect_count: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_draw_indirect_count = max_draw_indirect_count; + self + } + pub fn max_sampler_lod_bias( + mut self, + max_sampler_lod_bias: c_float, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_sampler_lod_bias = max_sampler_lod_bias; + self + } + pub fn max_sampler_anisotropy( + mut self, + max_sampler_anisotropy: c_float, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_sampler_anisotropy = max_sampler_anisotropy; + self + } + pub fn max_viewports(mut self, max_viewports: u32) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_viewports = max_viewports; + self + } + pub fn max_viewport_dimensions( + mut self, + max_viewport_dimensions: [u32; 2], + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_viewport_dimensions = max_viewport_dimensions; + self + } + pub fn viewport_bounds_range( + mut self, + viewport_bounds_range: [c_float; 2], + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.viewport_bounds_range = viewport_bounds_range; + self + } + pub fn viewport_sub_pixel_bits( + mut self, + viewport_sub_pixel_bits: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits; + self + } + pub fn min_memory_map_alignment( + mut self, + min_memory_map_alignment: usize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.min_memory_map_alignment = min_memory_map_alignment; + self + } + pub fn min_texel_buffer_offset_alignment( + mut self, + min_texel_buffer_offset_alignment: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment; + self + } + pub fn min_uniform_buffer_offset_alignment( + mut self, + min_uniform_buffer_offset_alignment: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment; + self + } + pub fn min_storage_buffer_offset_alignment( + mut self, + min_storage_buffer_offset_alignment: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment; + self + } + pub fn min_texel_offset(mut self, min_texel_offset: i32) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.min_texel_offset = min_texel_offset; + self + } + pub fn max_texel_offset(mut self, max_texel_offset: u32) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_texel_offset = max_texel_offset; + self + } + pub fn min_texel_gather_offset( + mut self, + min_texel_gather_offset: i32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.min_texel_gather_offset = min_texel_gather_offset; + self + } + pub fn max_texel_gather_offset( + mut self, + max_texel_gather_offset: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_texel_gather_offset = max_texel_gather_offset; + self + } + pub fn min_interpolation_offset( + mut self, + min_interpolation_offset: c_float, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.min_interpolation_offset = min_interpolation_offset; + self + } + pub fn max_interpolation_offset( + mut self, + max_interpolation_offset: c_float, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_interpolation_offset = max_interpolation_offset; + self + } + pub fn sub_pixel_interpolation_offset_bits( + mut self, + sub_pixel_interpolation_offset_bits: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits; + self + } + pub fn max_framebuffer_width( + mut self, + max_framebuffer_width: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_framebuffer_width = max_framebuffer_width; + self + } + pub fn max_framebuffer_height( + mut self, + max_framebuffer_height: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_framebuffer_height = max_framebuffer_height; + self + } + pub fn max_framebuffer_layers( + mut self, + max_framebuffer_layers: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_framebuffer_layers = max_framebuffer_layers; + self + } + pub fn framebuffer_color_sample_counts( + mut self, + framebuffer_color_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts; + self + } + pub fn framebuffer_depth_sample_counts( + mut self, + framebuffer_depth_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts; + self + } + pub fn framebuffer_stencil_sample_counts( + mut self, + framebuffer_stencil_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts; + self + } + pub fn framebuffer_no_attachments_sample_counts( + mut self, + framebuffer_no_attachments_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.framebuffer_no_attachments_sample_counts = + framebuffer_no_attachments_sample_counts; + self + } + pub fn max_color_attachments( + mut self, + max_color_attachments: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_color_attachments = max_color_attachments; + self + } + pub fn sampled_image_color_sample_counts( + mut self, + sampled_image_color_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts; + self + } + pub fn sampled_image_integer_sample_counts( + mut self, + sampled_image_integer_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts; + self + } + pub fn sampled_image_depth_sample_counts( + mut self, + sampled_image_depth_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts; + self + } + pub fn sampled_image_stencil_sample_counts( + mut self, + sampled_image_stencil_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts; + self + } + pub fn storage_image_sample_counts( + mut self, + storage_image_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.storage_image_sample_counts = storage_image_sample_counts; + self + } + pub fn max_sample_mask_words( + mut self, + max_sample_mask_words: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_sample_mask_words = max_sample_mask_words; + self + } + pub fn timestamp_compute_and_graphics( + mut self, + timestamp_compute_and_graphics: Bool32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics; + self + } + pub fn timestamp_period( + mut self, + timestamp_period: c_float, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.timestamp_period = timestamp_period; + self + } + pub fn max_clip_distances( + mut self, + max_clip_distances: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_clip_distances = max_clip_distances; + self + } + pub fn max_cull_distances( + mut self, + max_cull_distances: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_cull_distances = max_cull_distances; + self + } + pub fn max_combined_clip_and_cull_distances( + mut self, + max_combined_clip_and_cull_distances: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances; + self + } + pub fn discrete_queue_priorities( + mut self, + discrete_queue_priorities: u32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.discrete_queue_priorities = discrete_queue_priorities; + self + } + pub fn point_size_range( + mut self, + point_size_range: [c_float; 2], + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.point_size_range = point_size_range; + self + } + pub fn line_width_range( + mut self, + line_width_range: [c_float; 2], + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.line_width_range = line_width_range; + self + } + pub fn point_size_granularity( + mut self, + point_size_granularity: c_float, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.point_size_granularity = point_size_granularity; + self + } + pub fn line_width_granularity( + mut self, + line_width_granularity: c_float, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.line_width_granularity = line_width_granularity; + self + } + pub fn strict_lines(mut self, strict_lines: Bool32) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.strict_lines = strict_lines; + self + } + pub fn standard_sample_locations( + mut self, + standard_sample_locations: Bool32, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.standard_sample_locations = standard_sample_locations; + self + } + pub fn optimal_buffer_copy_offset_alignment( + mut self, + optimal_buffer_copy_offset_alignment: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment; + self + } + pub fn optimal_buffer_copy_row_pitch_alignment( + mut self, + optimal_buffer_copy_row_pitch_alignment: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.optimal_buffer_copy_row_pitch_alignment = + optimal_buffer_copy_row_pitch_alignment; + self + } + pub fn non_coherent_atom_size( + mut self, + non_coherent_atom_size: DeviceSize, + ) -> PhysicalDeviceLimitsBuilder<'a> { + self.inner.non_coherent_atom_size = non_coherent_atom_size; + self + } + pub fn build(self) -> PhysicalDeviceLimits { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SemaphoreCreateInfo { @@ -7019,6 +12966,33 @@ impl ::std::default::Default for SemaphoreCreateInfo { } } } +impl SemaphoreCreateInfo { + pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> { + SemaphoreCreateInfoBuilder { + inner: SemaphoreCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SemaphoreCreateInfoBuilder<'a> { + inner: SemaphoreCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> { + type Target = SemaphoreCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SemaphoreCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: SemaphoreCreateFlags) -> SemaphoreCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> SemaphoreCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct QueryPoolCreateInfo { @@ -7041,6 +13015,48 @@ impl ::std::default::Default for QueryPoolCreateInfo { } } } +impl QueryPoolCreateInfo { + pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> { + QueryPoolCreateInfoBuilder { + inner: QueryPoolCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct QueryPoolCreateInfoBuilder<'a> { + inner: QueryPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> { + type Target = QueryPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> QueryPoolCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: QueryPoolCreateFlags) -> QueryPoolCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn query_type(mut self, query_type: QueryType) -> QueryPoolCreateInfoBuilder<'a> { + self.inner.query_type = query_type; + self + } + pub fn query_count(mut self, query_count: u32) -> QueryPoolCreateInfoBuilder<'a> { + self.inner.query_count = query_count; + self + } + pub fn pipeline_statistics( + mut self, + pipeline_statistics: QueryPipelineStatisticFlags, + ) -> QueryPoolCreateInfoBuilder<'a> { + self.inner.pipeline_statistics = pipeline_statistics; + self + } + pub fn build(self) -> QueryPoolCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FramebufferCreateInfo { @@ -7069,6 +13085,58 @@ impl ::std::default::Default for FramebufferCreateInfo { } } } +impl FramebufferCreateInfo { + pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> { + FramebufferCreateInfoBuilder { + inner: FramebufferCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct FramebufferCreateInfoBuilder<'a> { + inner: FramebufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> { + type Target = FramebufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> FramebufferCreateInfoBuilder<'a> { + pub fn flags(mut self, flags: FramebufferCreateFlags) -> FramebufferCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn render_pass(mut self, render_pass: RenderPass) -> FramebufferCreateInfoBuilder<'a> { + self.inner.render_pass = render_pass; + self + } + pub fn attachment_count(mut self, attachment_count: u32) -> FramebufferCreateInfoBuilder<'a> { + self.inner.attachment_count = attachment_count; + self + } + pub fn attachments(mut self, attachments: &'a [ImageView]) -> FramebufferCreateInfoBuilder<'a> { + self.inner.attachment_count = attachments.len() as u32; + self.inner.p_attachments = attachments.as_ptr(); + self + } + pub fn width(mut self, width: u32) -> FramebufferCreateInfoBuilder<'a> { + self.inner.width = width; + self + } + pub fn height(mut self, height: u32) -> FramebufferCreateInfoBuilder<'a> { + self.inner.height = height; + self + } + pub fn layers(mut self, layers: u32) -> FramebufferCreateInfoBuilder<'a> { + self.inner.layers = layers; + self + } + pub fn build(self) -> FramebufferCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DrawIndirectCommand { @@ -7077,6 +13145,45 @@ pub struct DrawIndirectCommand { pub first_vertex: u32, pub first_instance: u32, } +impl DrawIndirectCommand { + pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> { + DrawIndirectCommandBuilder { + inner: DrawIndirectCommand::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DrawIndirectCommandBuilder<'a> { + inner: DrawIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> { + type Target = DrawIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DrawIndirectCommandBuilder<'a> { + pub fn vertex_count(mut self, vertex_count: u32) -> DrawIndirectCommandBuilder<'a> { + self.inner.vertex_count = vertex_count; + self + } + pub fn instance_count(mut self, instance_count: u32) -> DrawIndirectCommandBuilder<'a> { + self.inner.instance_count = instance_count; + self + } + pub fn first_vertex(mut self, first_vertex: u32) -> DrawIndirectCommandBuilder<'a> { + self.inner.first_vertex = first_vertex; + self + } + pub fn first_instance(mut self, first_instance: u32) -> DrawIndirectCommandBuilder<'a> { + self.inner.first_instance = first_instance; + self + } + pub fn build(self) -> DrawIndirectCommand { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DrawIndexedIndirectCommand { @@ -7086,6 +13193,49 @@ pub struct DrawIndexedIndirectCommand { pub vertex_offset: i32, pub first_instance: u32, } +impl DrawIndexedIndirectCommand { + pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> { + DrawIndexedIndirectCommandBuilder { + inner: DrawIndexedIndirectCommand::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DrawIndexedIndirectCommandBuilder<'a> { + inner: DrawIndexedIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> { + type Target = DrawIndexedIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DrawIndexedIndirectCommandBuilder<'a> { + pub fn index_count(mut self, index_count: u32) -> DrawIndexedIndirectCommandBuilder<'a> { + self.inner.index_count = index_count; + self + } + pub fn instance_count(mut self, instance_count: u32) -> DrawIndexedIndirectCommandBuilder<'a> { + self.inner.instance_count = instance_count; + self + } + pub fn first_index(mut self, first_index: u32) -> DrawIndexedIndirectCommandBuilder<'a> { + self.inner.first_index = first_index; + self + } + pub fn vertex_offset(mut self, vertex_offset: i32) -> DrawIndexedIndirectCommandBuilder<'a> { + self.inner.vertex_offset = vertex_offset; + self + } + pub fn first_instance(mut self, first_instance: u32) -> DrawIndexedIndirectCommandBuilder<'a> { + self.inner.first_instance = first_instance; + self + } + pub fn build(self) -> DrawIndexedIndirectCommand { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DispatchIndirectCommand { @@ -7093,6 +13243,41 @@ pub struct DispatchIndirectCommand { pub y: u32, pub z: u32, } +impl DispatchIndirectCommand { + pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> { + DispatchIndirectCommandBuilder { + inner: DispatchIndirectCommand::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DispatchIndirectCommandBuilder<'a> { + inner: DispatchIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> { + type Target = DispatchIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DispatchIndirectCommandBuilder<'a> { + pub fn x(mut self, x: u32) -> DispatchIndirectCommandBuilder<'a> { + self.inner.x = x; + self + } + pub fn y(mut self, y: u32) -> DispatchIndirectCommandBuilder<'a> { + self.inner.y = y; + self + } + pub fn z(mut self, z: u32) -> DispatchIndirectCommandBuilder<'a> { + self.inner.z = z; + self + } + pub fn build(self) -> DispatchIndirectCommand { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SubmitInfo { @@ -7121,6 +13306,70 @@ impl ::std::default::Default for SubmitInfo { } } } +impl SubmitInfo { + pub fn builder<'a>() -> SubmitInfoBuilder<'a> { + SubmitInfoBuilder { + inner: SubmitInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SubmitInfoBuilder<'a> { + inner: SubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> { + type Target = SubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SubmitInfoBuilder<'a> { + pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> SubmitInfoBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> SubmitInfoBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphores.len() as u32; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + pub fn wait_dst_stage_mask( + mut self, + wait_dst_stage_mask: &'a [PipelineStageFlags], + ) -> SubmitInfoBuilder<'a> { + self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as u32; + self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr(); + self + } + pub fn command_buffer_count(mut self, command_buffer_count: u32) -> SubmitInfoBuilder<'a> { + self.inner.command_buffer_count = command_buffer_count; + self + } + pub fn command_buffers( + mut self, + command_buffers: &'a [CommandBuffer], + ) -> SubmitInfoBuilder<'a> { + self.inner.command_buffer_count = command_buffers.len() as u32; + self.inner.p_command_buffers = command_buffers.as_ptr(); + self + } + pub fn signal_semaphore_count(mut self, signal_semaphore_count: u32) -> SubmitInfoBuilder<'a> { + self.inner.signal_semaphore_count = signal_semaphore_count; + self + } + pub fn signal_semaphores( + mut self, + signal_semaphores: &'a [Semaphore], + ) -> SubmitInfoBuilder<'a> { + self.inner.signal_semaphore_count = signal_semaphores.len() as u32; + self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self + } + pub fn build(self) -> SubmitInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPropertiesKHR { @@ -7145,24 +13394,198 @@ impl ::std::default::Default for DisplayPropertiesKHR { } } } +impl DisplayPropertiesKHR { + pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> { + DisplayPropertiesKHRBuilder { + inner: DisplayPropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPropertiesKHRBuilder<'a> { + inner: DisplayPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> { + type Target = DisplayPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPropertiesKHRBuilder<'a> { + pub fn display(mut self, display: DisplayKHR) -> DisplayPropertiesKHRBuilder<'a> { + self.inner.display = display; + self + } + pub fn display_name(mut self, display_name: *const c_char) -> DisplayPropertiesKHRBuilder<'a> { + self.inner.display_name = display_name; + self + } + pub fn physical_dimensions( + mut self, + physical_dimensions: Extent2D, + ) -> DisplayPropertiesKHRBuilder<'a> { + self.inner.physical_dimensions = physical_dimensions; + self + } + pub fn physical_resolution( + mut self, + physical_resolution: Extent2D, + ) -> DisplayPropertiesKHRBuilder<'a> { + self.inner.physical_resolution = physical_resolution; + self + } + pub fn supported_transforms( + mut self, + supported_transforms: SurfaceTransformFlagsKHR, + ) -> DisplayPropertiesKHRBuilder<'a> { + self.inner.supported_transforms = supported_transforms; + self + } + pub fn plane_reorder_possible( + mut self, + plane_reorder_possible: Bool32, + ) -> DisplayPropertiesKHRBuilder<'a> { + self.inner.plane_reorder_possible = plane_reorder_possible; + self + } + pub fn persistent_content( + mut self, + persistent_content: Bool32, + ) -> DisplayPropertiesKHRBuilder<'a> { + self.inner.persistent_content = persistent_content; + self + } + pub fn build(self) -> DisplayPropertiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DisplayPlanePropertiesKHR { pub current_display: DisplayKHR, pub current_stack_index: u32, } +impl DisplayPlanePropertiesKHR { + pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> { + DisplayPlanePropertiesKHRBuilder { + inner: DisplayPlanePropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPlanePropertiesKHRBuilder<'a> { + inner: DisplayPlanePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> { + type Target = DisplayPlanePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPlanePropertiesKHRBuilder<'a> { + pub fn current_display( + mut self, + current_display: DisplayKHR, + ) -> DisplayPlanePropertiesKHRBuilder<'a> { + self.inner.current_display = current_display; + self + } + pub fn current_stack_index( + mut self, + current_stack_index: u32, + ) -> DisplayPlanePropertiesKHRBuilder<'a> { + self.inner.current_stack_index = current_stack_index; + self + } + pub fn build(self) -> DisplayPlanePropertiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DisplayModeParametersKHR { pub visible_region: Extent2D, pub refresh_rate: u32, } +impl DisplayModeParametersKHR { + pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> { + DisplayModeParametersKHRBuilder { + inner: DisplayModeParametersKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayModeParametersKHRBuilder<'a> { + inner: DisplayModeParametersKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> { + type Target = DisplayModeParametersKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayModeParametersKHRBuilder<'a> { + pub fn visible_region( + mut self, + visible_region: Extent2D, + ) -> DisplayModeParametersKHRBuilder<'a> { + self.inner.visible_region = visible_region; + self + } + pub fn refresh_rate(mut self, refresh_rate: u32) -> DisplayModeParametersKHRBuilder<'a> { + self.inner.refresh_rate = refresh_rate; + self + } + pub fn build(self) -> DisplayModeParametersKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DisplayModePropertiesKHR { pub display_mode: DisplayModeKHR, pub parameters: DisplayModeParametersKHR, } +impl DisplayModePropertiesKHR { + pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> { + DisplayModePropertiesKHRBuilder { + inner: DisplayModePropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayModePropertiesKHRBuilder<'a> { + inner: DisplayModePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> { + type Target = DisplayModePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayModePropertiesKHRBuilder<'a> { + pub fn display_mode( + mut self, + display_mode: DisplayModeKHR, + ) -> DisplayModePropertiesKHRBuilder<'a> { + self.inner.display_mode = display_mode; + self + } + pub fn parameters( + mut self, + parameters: DisplayModeParametersKHR, + ) -> DisplayModePropertiesKHRBuilder<'a> { + self.inner.parameters = parameters; + self + } + pub fn build(self) -> DisplayModePropertiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayModeCreateInfoKHR { @@ -7181,6 +13604,43 @@ impl ::std::default::Default for DisplayModeCreateInfoKHR { } } } +impl DisplayModeCreateInfoKHR { + pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> { + DisplayModeCreateInfoKHRBuilder { + inner: DisplayModeCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayModeCreateInfoKHRBuilder<'a> { + inner: DisplayModeCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> { + type Target = DisplayModeCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { + pub fn flags( + mut self, + flags: DisplayModeCreateFlagsKHR, + ) -> DisplayModeCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn parameters( + mut self, + parameters: DisplayModeParametersKHR, + ) -> DisplayModeCreateInfoKHRBuilder<'a> { + self.inner.parameters = parameters; + self + } + pub fn build(self) -> DisplayModeCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DisplayPlaneCapabilitiesKHR { @@ -7194,6 +13654,92 @@ pub struct DisplayPlaneCapabilitiesKHR { pub min_dst_extent: Extent2D, pub max_dst_extent: Extent2D, } +impl DisplayPlaneCapabilitiesKHR { + pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + DisplayPlaneCapabilitiesKHRBuilder { + inner: DisplayPlaneCapabilitiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> { + inner: DisplayPlaneCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> { + type Target = DisplayPlaneCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> { + pub fn supported_alpha( + mut self, + supported_alpha: DisplayPlaneAlphaFlagsKHR, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.supported_alpha = supported_alpha; + self + } + pub fn min_src_position( + mut self, + min_src_position: Offset2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.min_src_position = min_src_position; + self + } + pub fn max_src_position( + mut self, + max_src_position: Offset2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.max_src_position = max_src_position; + self + } + pub fn min_src_extent( + mut self, + min_src_extent: Extent2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.min_src_extent = min_src_extent; + self + } + pub fn max_src_extent( + mut self, + max_src_extent: Extent2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.max_src_extent = max_src_extent; + self + } + pub fn min_dst_position( + mut self, + min_dst_position: Offset2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.min_dst_position = min_dst_position; + self + } + pub fn max_dst_position( + mut self, + max_dst_position: Offset2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.max_dst_position = max_dst_position; + self + } + pub fn min_dst_extent( + mut self, + min_dst_extent: Extent2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.min_dst_extent = min_dst_extent; + self + } + pub fn max_dst_extent( + mut self, + max_dst_extent: Extent2D, + ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + self.inner.max_dst_extent = max_dst_extent; + self + } + pub fn build(self) -> DisplayPlaneCapabilitiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplaySurfaceCreateInfoKHR { @@ -7224,6 +13770,79 @@ impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { } } } +impl DisplaySurfaceCreateInfoKHR { + pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + DisplaySurfaceCreateInfoKHRBuilder { + inner: DisplaySurfaceCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> { + inner: DisplaySurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> { + type Target = DisplaySurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { + pub fn flags( + mut self, + flags: DisplaySurfaceCreateFlagsKHR, + ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn display_mode( + mut self, + display_mode: DisplayModeKHR, + ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.display_mode = display_mode; + self + } + pub fn plane_index(mut self, plane_index: u32) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.plane_index = plane_index; + self + } + pub fn plane_stack_index( + mut self, + plane_stack_index: u32, + ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.plane_stack_index = plane_stack_index; + self + } + pub fn transform( + mut self, + transform: SurfaceTransformFlagsKHR, + ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.transform = transform; + self + } + pub fn global_alpha(mut self, global_alpha: c_float) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.global_alpha = global_alpha; + self + } + pub fn alpha_mode( + mut self, + alpha_mode: DisplayPlaneAlphaFlagsKHR, + ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.alpha_mode = alpha_mode; + self + } + pub fn image_extent( + mut self, + image_extent: Extent2D, + ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + self.inner.image_extent = image_extent; + self + } + pub fn build(self) -> DisplaySurfaceCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPresentInfoKHR { @@ -7244,6 +13863,41 @@ impl ::std::default::Default for DisplayPresentInfoKHR { } } } +impl DisplayPresentInfoKHR { + pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> { + DisplayPresentInfoKHRBuilder { + inner: DisplayPresentInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPresentInfoKHRBuilder<'a> { + inner: DisplayPresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> { + type Target = DisplayPresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPresentInfoKHRBuilder<'a> { + pub fn src_rect(mut self, src_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a> { + self.inner.src_rect = src_rect; + self + } + pub fn dst_rect(mut self, dst_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a> { + self.inner.dst_rect = dst_rect; + self + } + pub fn persistent(mut self, persistent: Bool32) -> DisplayPresentInfoKHRBuilder<'a> { + self.inner.persistent = persistent; + self + } + pub fn build(self) -> DisplayPresentInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SurfaceCapabilitiesKHR { @@ -7258,6 +13912,90 @@ pub struct SurfaceCapabilitiesKHR { pub supported_composite_alpha: CompositeAlphaFlagsKHR, pub supported_usage_flags: ImageUsageFlags, } +impl SurfaceCapabilitiesKHR { + pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> { + SurfaceCapabilitiesKHRBuilder { + inner: SurfaceCapabilitiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SurfaceCapabilitiesKHRBuilder<'a> { + inner: SurfaceCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> { + type Target = SurfaceCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SurfaceCapabilitiesKHRBuilder<'a> { + pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.min_image_count = min_image_count; + self + } + pub fn max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.max_image_count = max_image_count; + self + } + pub fn current_extent(mut self, current_extent: Extent2D) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.current_extent = current_extent; + self + } + pub fn min_image_extent( + mut self, + min_image_extent: Extent2D, + ) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.min_image_extent = min_image_extent; + self + } + pub fn max_image_extent( + mut self, + max_image_extent: Extent2D, + ) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.max_image_extent = max_image_extent; + self + } + pub fn max_image_array_layers( + mut self, + max_image_array_layers: u32, + ) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + pub fn supported_transforms( + mut self, + supported_transforms: SurfaceTransformFlagsKHR, + ) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.supported_transforms = supported_transforms; + self + } + pub fn current_transform( + mut self, + current_transform: SurfaceTransformFlagsKHR, + ) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.current_transform = current_transform; + self + } + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: CompositeAlphaFlagsKHR, + ) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.supported_composite_alpha = supported_composite_alpha; + self + } + pub fn supported_usage_flags( + mut self, + supported_usage_flags: ImageUsageFlags, + ) -> SurfaceCapabilitiesKHRBuilder<'a> { + self.inner.supported_usage_flags = supported_usage_flags; + self + } + pub fn build(self) -> SurfaceCapabilitiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AndroidSurfaceCreateInfoKHR { @@ -7276,6 +14014,40 @@ impl ::std::default::Default for AndroidSurfaceCreateInfoKHR { } } } +impl AndroidSurfaceCreateInfoKHR { + pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> { + AndroidSurfaceCreateInfoKHRBuilder { + inner: AndroidSurfaceCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> { + inner: AndroidSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> { + type Target = AndroidSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { + pub fn flags( + mut self, + flags: AndroidSurfaceCreateFlagsKHR, + ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn window(mut self, window: *mut ANativeWindow) -> AndroidSurfaceCreateInfoKHRBuilder<'a> { + self.inner.window = window; + self + } + pub fn build(self) -> AndroidSurfaceCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MirSurfaceCreateInfoKHR { @@ -7296,6 +14068,47 @@ impl ::std::default::Default for MirSurfaceCreateInfoKHR { } } } +impl MirSurfaceCreateInfoKHR { + pub fn builder<'a>() -> MirSurfaceCreateInfoKHRBuilder<'a> { + MirSurfaceCreateInfoKHRBuilder { + inner: MirSurfaceCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MirSurfaceCreateInfoKHRBuilder<'a> { + inner: MirSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MirSurfaceCreateInfoKHRBuilder<'a> { + type Target = MirSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MirSurfaceCreateInfoKHRBuilder<'a> { + pub fn flags(mut self, flags: MirSurfaceCreateFlagsKHR) -> MirSurfaceCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn connection( + mut self, + connection: *mut MirConnection, + ) -> MirSurfaceCreateInfoKHRBuilder<'a> { + self.inner.connection = connection; + self + } + pub fn mir_surface( + mut self, + mir_surface: *mut MirSurface, + ) -> MirSurfaceCreateInfoKHRBuilder<'a> { + self.inner.mir_surface = mir_surface; + self + } + pub fn build(self) -> MirSurfaceCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ViSurfaceCreateInfoNN { @@ -7314,6 +14127,37 @@ impl ::std::default::Default for ViSurfaceCreateInfoNN { } } } +impl ViSurfaceCreateInfoNN { + pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> { + ViSurfaceCreateInfoNNBuilder { + inner: ViSurfaceCreateInfoNN::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ViSurfaceCreateInfoNNBuilder<'a> { + inner: ViSurfaceCreateInfoNN, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> { + type Target = ViSurfaceCreateInfoNN; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { + pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> ViSurfaceCreateInfoNNBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn window(mut self, window: *mut c_void) -> ViSurfaceCreateInfoNNBuilder<'a> { + self.inner.window = window; + self + } + pub fn build(self) -> ViSurfaceCreateInfoNN { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct WaylandSurfaceCreateInfoKHR { @@ -7334,6 +14178,44 @@ impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { } } } +impl WaylandSurfaceCreateInfoKHR { + pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> { + WaylandSurfaceCreateInfoKHRBuilder { + inner: WaylandSurfaceCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> { + inner: WaylandSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> { + type Target = WaylandSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { + pub fn flags( + mut self, + flags: WaylandSurfaceCreateFlagsKHR, + ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn display(mut self, display: *mut wl_display) -> WaylandSurfaceCreateInfoKHRBuilder<'a> { + self.inner.display = display; + self + } + pub fn surface(mut self, surface: *mut wl_surface) -> WaylandSurfaceCreateInfoKHRBuilder<'a> { + self.inner.surface = surface; + self + } + pub fn build(self) -> WaylandSurfaceCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct Win32SurfaceCreateInfoKHR { @@ -7354,6 +14236,44 @@ impl ::std::default::Default for Win32SurfaceCreateInfoKHR { } } } +impl Win32SurfaceCreateInfoKHR { + pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> { + Win32SurfaceCreateInfoKHRBuilder { + inner: Win32SurfaceCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Win32SurfaceCreateInfoKHRBuilder<'a> { + inner: Win32SurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> { + type Target = Win32SurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { + pub fn flags( + mut self, + flags: Win32SurfaceCreateFlagsKHR, + ) -> Win32SurfaceCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn hinstance(mut self, hinstance: HINSTANCE) -> Win32SurfaceCreateInfoKHRBuilder<'a> { + self.inner.hinstance = hinstance; + self + } + pub fn hwnd(mut self, hwnd: HWND) -> Win32SurfaceCreateInfoKHRBuilder<'a> { + self.inner.hwnd = hwnd; + self + } + pub fn build(self) -> Win32SurfaceCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct XlibSurfaceCreateInfoKHR { @@ -7374,6 +14294,44 @@ impl ::std::default::Default for XlibSurfaceCreateInfoKHR { } } } +impl XlibSurfaceCreateInfoKHR { + pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> { + XlibSurfaceCreateInfoKHRBuilder { + inner: XlibSurfaceCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct XlibSurfaceCreateInfoKHRBuilder<'a> { + inner: XlibSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> { + type Target = XlibSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { + pub fn flags( + mut self, + flags: XlibSurfaceCreateFlagsKHR, + ) -> XlibSurfaceCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn dpy(mut self, dpy: *mut Display) -> XlibSurfaceCreateInfoKHRBuilder<'a> { + self.inner.dpy = dpy; + self + } + pub fn window(mut self, window: Window) -> XlibSurfaceCreateInfoKHRBuilder<'a> { + self.inner.window = window; + self + } + pub fn build(self) -> XlibSurfaceCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct XcbSurfaceCreateInfoKHR { @@ -7394,12 +14352,81 @@ impl ::std::default::Default for XcbSurfaceCreateInfoKHR { } } } +impl XcbSurfaceCreateInfoKHR { + pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> { + XcbSurfaceCreateInfoKHRBuilder { + inner: XcbSurfaceCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct XcbSurfaceCreateInfoKHRBuilder<'a> { + inner: XcbSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> { + type Target = XcbSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { + pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> XcbSurfaceCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn connection( + mut self, + connection: *mut xcb_connection_t, + ) -> XcbSurfaceCreateInfoKHRBuilder<'a> { + self.inner.connection = connection; + self + } + pub fn window(mut self, window: xcb_window_t) -> XcbSurfaceCreateInfoKHRBuilder<'a> { + self.inner.window = window; + self + } + pub fn build(self) -> XcbSurfaceCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SurfaceFormatKHR { pub format: Format, pub color_space: ColorSpaceKHR, } +impl SurfaceFormatKHR { + pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> { + SurfaceFormatKHRBuilder { + inner: SurfaceFormatKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SurfaceFormatKHRBuilder<'a> { + inner: SurfaceFormatKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> { + type Target = SurfaceFormatKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SurfaceFormatKHRBuilder<'a> { + pub fn format(mut self, format: Format) -> SurfaceFormatKHRBuilder<'a> { + self.inner.format = format; + self + } + pub fn color_space(mut self, color_space: ColorSpaceKHR) -> SurfaceFormatKHRBuilder<'a> { + self.inner.color_space = color_space; + self + } + pub fn build(self) -> SurfaceFormatKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SwapchainCreateInfoKHR { @@ -7446,6 +14473,124 @@ impl ::std::default::Default for SwapchainCreateInfoKHR { } } } +impl SwapchainCreateInfoKHR { + pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> { + SwapchainCreateInfoKHRBuilder { + inner: SwapchainCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SwapchainCreateInfoKHRBuilder<'a> { + inner: SwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> { + type Target = SwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SwapchainCreateInfoKHRBuilder<'a> { + pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn surface(mut self, surface: SurfaceKHR) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.surface = surface; + self + } + pub fn min_image_count(mut self, min_image_count: u32) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.min_image_count = min_image_count; + self + } + pub fn image_format(mut self, image_format: Format) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.image_format = image_format; + self + } + pub fn image_color_space( + mut self, + image_color_space: ColorSpaceKHR, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.image_color_space = image_color_space; + self + } + pub fn image_extent(mut self, image_extent: Extent2D) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.image_extent = image_extent; + self + } + pub fn image_array_layers( + mut self, + image_array_layers: u32, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.image_array_layers = image_array_layers; + self + } + pub fn image_usage( + mut self, + image_usage: ImageUsageFlags, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.image_usage = image_usage; + self + } + pub fn image_sharing_mode( + mut self, + image_sharing_mode: SharingMode, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.image_sharing_mode = image_sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.queue_family_index_count = queue_family_index_count; + self + } + pub fn queue_family_indices( + mut self, + queue_family_indices: &'a [u32], + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.queue_family_index_count = queue_family_indices.len() as u32; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + pub fn pre_transform( + mut self, + pre_transform: SurfaceTransformFlagsKHR, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.pre_transform = pre_transform; + self + } + pub fn composite_alpha( + mut self, + composite_alpha: CompositeAlphaFlagsKHR, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.composite_alpha = composite_alpha; + self + } + pub fn present_mode( + mut self, + present_mode: PresentModeKHR, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.present_mode = present_mode; + self + } + pub fn clipped(mut self, clipped: Bool32) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.clipped = clipped; + self + } + pub fn old_swapchain( + mut self, + old_swapchain: SwapchainKHR, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + self.inner.old_swapchain = old_swapchain; + self + } + pub fn build(self) -> SwapchainCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentInfoKHR { @@ -7472,6 +14617,60 @@ impl ::std::default::Default for PresentInfoKHR { } } } +impl PresentInfoKHR { + pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> { + PresentInfoKHRBuilder { + inner: PresentInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PresentInfoKHRBuilder<'a> { + inner: PresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> { + type Target = PresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PresentInfoKHRBuilder<'a> { + pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> PresentInfoKHRBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn wait_semaphores( + mut self, + wait_semaphores: &'a [Semaphore], + ) -> PresentInfoKHRBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphores.len() as u32; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + pub fn swapchain_count(mut self, swapchain_count: u32) -> PresentInfoKHRBuilder<'a> { + self.inner.swapchain_count = swapchain_count; + self + } + pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> PresentInfoKHRBuilder<'a> { + self.inner.swapchain_count = swapchains.len() as u32; + self.inner.p_swapchains = swapchains.as_ptr(); + self + } + pub fn image_indices(mut self, image_indices: &'a [u32]) -> PresentInfoKHRBuilder<'a> { + self.inner.swapchain_count = image_indices.len() as u32; + self.inner.p_image_indices = image_indices.as_ptr(); + self + } + pub fn results(mut self, results: &'a mut [Result]) -> PresentInfoKHRBuilder<'a> { + self.inner.swapchain_count = results.len() as u32; + self.inner.p_results = results.as_mut_ptr(); + self + } + pub fn build(self) -> PresentInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct DebugReportCallbackCreateInfoEXT { @@ -7503,6 +14702,50 @@ impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { } } } +impl DebugReportCallbackCreateInfoEXT { + pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> { + DebugReportCallbackCreateInfoEXTBuilder { + inner: DebugReportCallbackCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> { + inner: DebugReportCallbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> { + type Target = DebugReportCallbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: DebugReportFlagsEXT, + ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn pfn_callback( + mut self, + pfn_callback: PFN_vkDebugReportCallbackEXT, + ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> { + self.inner.pfn_callback = pfn_callback; + self + } + pub fn user_data( + mut self, + user_data: *mut c_void, + ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> { + self.inner.p_user_data = user_data; + self + } + pub fn build(self) -> DebugReportCallbackCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ValidationFlagsEXT { @@ -7521,6 +14764,44 @@ impl ::std::default::Default for ValidationFlagsEXT { } } } +impl ValidationFlagsEXT { + pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> { + ValidationFlagsEXTBuilder { + inner: ValidationFlagsEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ValidationFlagsEXTBuilder<'a> { + inner: ValidationFlagsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> { + type Target = ValidationFlagsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ValidationFlagsEXTBuilder<'a> { + pub fn disabled_validation_check_count( + mut self, + disabled_validation_check_count: u32, + ) -> ValidationFlagsEXTBuilder<'a> { + self.inner.disabled_validation_check_count = disabled_validation_check_count; + self + } + pub fn disabled_validation_checks( + mut self, + disabled_validation_checks: &'a mut [ValidationCheckEXT], + ) -> ValidationFlagsEXTBuilder<'a> { + self.inner.disabled_validation_check_count = disabled_validation_checks.len() as u32; + self.inner.p_disabled_validation_checks = disabled_validation_checks.as_mut_ptr(); + self + } + pub fn build(self) -> ValidationFlagsEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationStateRasterizationOrderAMD { @@ -7537,6 +14818,36 @@ impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD } } } +impl PipelineRasterizationStateRasterizationOrderAMD { + pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + PipelineRasterizationStateRasterizationOrderAMDBuilder { + inner: PipelineRasterizationStateRasterizationOrderAMD::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + inner: PipelineRasterizationStateRasterizationOrderAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + type Target = PipelineRasterizationStateRasterizationOrderAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + pub fn rasterization_order( + mut self, + rasterization_order: RasterizationOrderAMD, + ) -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + self.inner.rasterization_order = rasterization_order; + self + } + pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugMarkerObjectNameInfoEXT { @@ -7557,6 +14868,47 @@ impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { } } } +impl DebugMarkerObjectNameInfoEXT { + pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> { + DebugMarkerObjectNameInfoEXTBuilder { + inner: DebugMarkerObjectNameInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> { + inner: DebugMarkerObjectNameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> { + type Target = DebugMarkerObjectNameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { + pub fn object_type( + mut self, + object_type: DebugReportObjectTypeEXT, + ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> { + self.inner.object_type = object_type; + self + } + pub fn object(mut self, object: u64) -> DebugMarkerObjectNameInfoEXTBuilder<'a> { + self.inner.object = object; + self + } + pub fn object_name( + mut self, + object_name: &'a ::std::ffi::CStr, + ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> { + self.inner.p_object_name = object_name.as_ptr(); + self + } + pub fn build(self) -> DebugMarkerObjectNameInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugMarkerObjectTagInfoEXT { @@ -7581,6 +14933,53 @@ impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { } } } +impl DebugMarkerObjectTagInfoEXT { + pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + DebugMarkerObjectTagInfoEXTBuilder { + inner: DebugMarkerObjectTagInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> { + inner: DebugMarkerObjectTagInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> { + type Target = DebugMarkerObjectTagInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { + pub fn object_type( + mut self, + object_type: DebugReportObjectTypeEXT, + ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + self.inner.object_type = object_type; + self + } + pub fn object(mut self, object: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + self.inner.object = object; + self + } + pub fn tag_name(mut self, tag_name: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + self.inner.tag_name = tag_name; + self + } + pub fn tag_size(mut self, tag_size: usize) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + self.inner.tag_size = tag_size; + self + } + pub fn tag(mut self, tag: &'a [c_void]) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + self.inner.tag_size = tag.len() as usize; + self.inner.p_tag = tag.as_ptr(); + self + } + pub fn build(self) -> DebugMarkerObjectTagInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugMarkerMarkerInfoEXT { @@ -7599,6 +14998,40 @@ impl ::std::default::Default for DebugMarkerMarkerInfoEXT { } } } +impl DebugMarkerMarkerInfoEXT { + pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> { + DebugMarkerMarkerInfoEXTBuilder { + inner: DebugMarkerMarkerInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugMarkerMarkerInfoEXTBuilder<'a> { + inner: DebugMarkerMarkerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> { + type Target = DebugMarkerMarkerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { + pub fn marker_name( + mut self, + marker_name: &'a ::std::ffi::CStr, + ) -> DebugMarkerMarkerInfoEXTBuilder<'a> { + self.inner.p_marker_name = marker_name.as_ptr(); + self + } + pub fn color(mut self, color: [c_float; 4]) -> DebugMarkerMarkerInfoEXTBuilder<'a> { + self.inner.color = color; + self + } + pub fn build(self) -> DebugMarkerMarkerInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationImageCreateInfoNV { @@ -7615,6 +15048,36 @@ impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV { } } } +impl DedicatedAllocationImageCreateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> { + DedicatedAllocationImageCreateInfoNVBuilder { + inner: DedicatedAllocationImageCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> { + inner: DedicatedAllocationImageCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> { + type Target = DedicatedAllocationImageCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> { + pub fn dedicated_allocation( + mut self, + dedicated_allocation: Bool32, + ) -> DedicatedAllocationImageCreateInfoNVBuilder<'a> { + self.inner.dedicated_allocation = dedicated_allocation; + self + } + pub fn build(self) -> DedicatedAllocationImageCreateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationBufferCreateInfoNV { @@ -7631,6 +15094,36 @@ impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV { } } } +impl DedicatedAllocationBufferCreateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + DedicatedAllocationBufferCreateInfoNVBuilder { + inner: DedicatedAllocationBufferCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + inner: DedicatedAllocationBufferCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + type Target = DedicatedAllocationBufferCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + pub fn dedicated_allocation( + mut self, + dedicated_allocation: Bool32, + ) -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + self.inner.dedicated_allocation = dedicated_allocation; + self + } + pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DedicatedAllocationMemoryAllocateInfoNV { @@ -7649,6 +15142,37 @@ impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV { } } } +impl DedicatedAllocationMemoryAllocateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + DedicatedAllocationMemoryAllocateInfoNVBuilder { + inner: DedicatedAllocationMemoryAllocateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + inner: DedicatedAllocationMemoryAllocateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + type Target = DedicatedAllocationMemoryAllocateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + pub fn image(mut self, image: Image) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + self.inner.image = image; + self + } + pub fn buffer(mut self, buffer: Buffer) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ExternalImageFormatPropertiesNV { @@ -7657,6 +15181,57 @@ pub struct ExternalImageFormatPropertiesNV { pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, } +impl ExternalImageFormatPropertiesNV { + pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> { + ExternalImageFormatPropertiesNVBuilder { + inner: ExternalImageFormatPropertiesNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalImageFormatPropertiesNVBuilder<'a> { + inner: ExternalImageFormatPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> { + type Target = ExternalImageFormatPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> { + pub fn image_format_properties( + mut self, + image_format_properties: ImageFormatProperties, + ) -> ExternalImageFormatPropertiesNVBuilder<'a> { + self.inner.image_format_properties = image_format_properties; + self + } + pub fn external_memory_features( + mut self, + external_memory_features: ExternalMemoryFeatureFlagsNV, + ) -> ExternalImageFormatPropertiesNVBuilder<'a> { + self.inner.external_memory_features = external_memory_features; + self + } + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> ExternalImageFormatPropertiesNVBuilder<'a> { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> ExternalImageFormatPropertiesNVBuilder<'a> { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + pub fn build(self) -> ExternalImageFormatPropertiesNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalMemoryImageCreateInfoNV { @@ -7673,6 +15248,36 @@ impl ::std::default::Default for ExternalMemoryImageCreateInfoNV { } } } +impl ExternalMemoryImageCreateInfoNV { + pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> { + ExternalMemoryImageCreateInfoNVBuilder { + inner: ExternalMemoryImageCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> { + inner: ExternalMemoryImageCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> { + type Target = ExternalMemoryImageCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> { + pub fn handle_types( + mut self, + handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> ExternalMemoryImageCreateInfoNVBuilder<'a> { + self.inner.handle_types = handle_types; + self + } + pub fn build(self) -> ExternalMemoryImageCreateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryAllocateInfoNV { @@ -7689,6 +15294,36 @@ impl ::std::default::Default for ExportMemoryAllocateInfoNV { } } } +impl ExportMemoryAllocateInfoNV { + pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> { + ExportMemoryAllocateInfoNVBuilder { + inner: ExportMemoryAllocateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportMemoryAllocateInfoNVBuilder<'a> { + inner: ExportMemoryAllocateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> { + type Target = ExportMemoryAllocateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> { + pub fn handle_types( + mut self, + handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> ExportMemoryAllocateInfoNVBuilder<'a> { + self.inner.handle_types = handle_types; + self + } + pub fn build(self) -> ExportMemoryAllocateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryWin32HandleInfoNV { @@ -7707,6 +15342,40 @@ impl ::std::default::Default for ImportMemoryWin32HandleInfoNV { } } } +impl ImportMemoryWin32HandleInfoNV { + pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> { + ImportMemoryWin32HandleInfoNVBuilder { + inner: ImportMemoryWin32HandleInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> { + inner: ImportMemoryWin32HandleInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> { + type Target = ImportMemoryWin32HandleInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> { + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlagsNV, + ) -> ImportMemoryWin32HandleInfoNVBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoNVBuilder<'a> { + self.inner.handle = handle; + self + } + pub fn build(self) -> ImportMemoryWin32HandleInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryWin32HandleInfoNV { @@ -7725,6 +15394,40 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoNV { } } } +impl ExportMemoryWin32HandleInfoNV { + pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> { + ExportMemoryWin32HandleInfoNVBuilder { + inner: ExportMemoryWin32HandleInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> { + inner: ExportMemoryWin32HandleInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> { + type Target = ExportMemoryWin32HandleInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> { + pub fn attributes( + mut self, + attributes: *const SECURITY_ATTRIBUTES, + ) -> ExportMemoryWin32HandleInfoNVBuilder<'a> { + self.inner.p_attributes = attributes; + self + } + pub fn dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoNVBuilder<'a> { + self.inner.dw_access = dw_access; + self + } + pub fn build(self) -> ExportMemoryWin32HandleInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct Win32KeyedMutexAcquireReleaseInfoNV { @@ -7753,6 +15456,83 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { } } } +impl Win32KeyedMutexAcquireReleaseInfoNV { + pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + Win32KeyedMutexAcquireReleaseInfoNVBuilder { + inner: Win32KeyedMutexAcquireReleaseInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + inner: Win32KeyedMutexAcquireReleaseInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + type Target = Win32KeyedMutexAcquireReleaseInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + pub fn acquire_count( + mut self, + acquire_count: u32, + ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + self.inner.acquire_count = acquire_count; + self + } + pub fn acquire_syncs( + mut self, + acquire_syncs: &'a [DeviceMemory], + ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + self.inner.acquire_count = acquire_syncs.len() as u32; + self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self + } + pub fn acquire_keys( + mut self, + acquire_keys: &'a [u64], + ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + self.inner.acquire_count = acquire_keys.len() as u32; + self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self + } + pub fn acquire_timeout_milliseconds( + mut self, + acquire_timeout_milliseconds: &'a [u32], + ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + self.inner.acquire_count = acquire_timeout_milliseconds.len() as u32; + self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr(); + self + } + pub fn release_count( + mut self, + release_count: u32, + ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + self.inner.release_count = release_count; + self + } + pub fn release_syncs( + mut self, + release_syncs: &'a [DeviceMemory], + ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + self.inner.release_count = release_syncs.len() as u32; + self.inner.p_release_syncs = release_syncs.as_ptr(); + self + } + pub fn release_keys( + mut self, + release_keys: &'a [u64], + ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + self.inner.release_count = release_keys.len() as u32; + self.inner.p_release_keys = release_keys.as_ptr(); + self + } + pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGeneratedCommandsFeaturesNVX { @@ -7769,6 +15549,36 @@ impl ::std::default::Default for DeviceGeneratedCommandsFeaturesNVX { } } } +impl DeviceGeneratedCommandsFeaturesNVX { + pub fn builder<'a>() -> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { + DeviceGeneratedCommandsFeaturesNVXBuilder { + inner: DeviceGeneratedCommandsFeaturesNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { + inner: DeviceGeneratedCommandsFeaturesNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { + type Target = DeviceGeneratedCommandsFeaturesNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { + pub fn compute_binding_point_support( + mut self, + compute_binding_point_support: Bool32, + ) -> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { + self.inner.compute_binding_point_support = compute_binding_point_support; + self + } + pub fn build(self) -> DeviceGeneratedCommandsFeaturesNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGeneratedCommandsLimitsNVX { @@ -7793,6 +15603,68 @@ impl ::std::default::Default for DeviceGeneratedCommandsLimitsNVX { } } } +impl DeviceGeneratedCommandsLimitsNVX { + pub fn builder<'a>() -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + DeviceGeneratedCommandsLimitsNVXBuilder { + inner: DeviceGeneratedCommandsLimitsNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + inner: DeviceGeneratedCommandsLimitsNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + type Target = DeviceGeneratedCommandsLimitsNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + pub fn max_indirect_commands_layout_token_count( + mut self, + max_indirect_commands_layout_token_count: u32, + ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + self.inner.max_indirect_commands_layout_token_count = + max_indirect_commands_layout_token_count; + self + } + pub fn max_object_entry_counts( + mut self, + max_object_entry_counts: u32, + ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + self.inner.max_object_entry_counts = max_object_entry_counts; + self + } + pub fn min_sequence_count_buffer_offset_alignment( + mut self, + min_sequence_count_buffer_offset_alignment: u32, + ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + self.inner.min_sequence_count_buffer_offset_alignment = + min_sequence_count_buffer_offset_alignment; + self + } + pub fn min_sequence_index_buffer_offset_alignment( + mut self, + min_sequence_index_buffer_offset_alignment: u32, + ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + self.inner.min_sequence_index_buffer_offset_alignment = + min_sequence_index_buffer_offset_alignment; + self + } + pub fn min_commands_token_buffer_offset_alignment( + mut self, + min_commands_token_buffer_offset_alignment: u32, + ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + self.inner.min_commands_token_buffer_offset_alignment = + min_commands_token_buffer_offset_alignment; + self + } + pub fn build(self) -> DeviceGeneratedCommandsLimitsNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct IndirectCommandsTokenNVX { @@ -7800,6 +15672,44 @@ pub struct IndirectCommandsTokenNVX { pub buffer: Buffer, pub offset: DeviceSize, } +impl IndirectCommandsTokenNVX { + pub fn builder<'a>() -> IndirectCommandsTokenNVXBuilder<'a> { + IndirectCommandsTokenNVXBuilder { + inner: IndirectCommandsTokenNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct IndirectCommandsTokenNVXBuilder<'a> { + inner: IndirectCommandsTokenNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsTokenNVXBuilder<'a> { + type Target = IndirectCommandsTokenNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> IndirectCommandsTokenNVXBuilder<'a> { + pub fn token_type( + mut self, + token_type: IndirectCommandsTokenTypeNVX, + ) -> IndirectCommandsTokenNVXBuilder<'a> { + self.inner.token_type = token_type; + self + } + pub fn buffer(mut self, buffer: Buffer) -> IndirectCommandsTokenNVXBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn offset(mut self, offset: DeviceSize) -> IndirectCommandsTokenNVXBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn build(self) -> IndirectCommandsTokenNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct IndirectCommandsLayoutTokenNVX { @@ -7808,6 +15718,51 @@ pub struct IndirectCommandsLayoutTokenNVX { pub dynamic_count: u32, pub divisor: u32, } +impl IndirectCommandsLayoutTokenNVX { + pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVXBuilder<'a> { + IndirectCommandsLayoutTokenNVXBuilder { + inner: IndirectCommandsLayoutTokenNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct IndirectCommandsLayoutTokenNVXBuilder<'a> { + inner: IndirectCommandsLayoutTokenNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVXBuilder<'a> { + type Target = IndirectCommandsLayoutTokenNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> IndirectCommandsLayoutTokenNVXBuilder<'a> { + pub fn token_type( + mut self, + token_type: IndirectCommandsTokenTypeNVX, + ) -> IndirectCommandsLayoutTokenNVXBuilder<'a> { + self.inner.token_type = token_type; + self + } + pub fn binding_unit(mut self, binding_unit: u32) -> IndirectCommandsLayoutTokenNVXBuilder<'a> { + self.inner.binding_unit = binding_unit; + self + } + pub fn dynamic_count( + mut self, + dynamic_count: u32, + ) -> IndirectCommandsLayoutTokenNVXBuilder<'a> { + self.inner.dynamic_count = dynamic_count; + self + } + pub fn divisor(mut self, divisor: u32) -> IndirectCommandsLayoutTokenNVXBuilder<'a> { + self.inner.divisor = divisor; + self + } + pub fn build(self) -> IndirectCommandsLayoutTokenNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct IndirectCommandsLayoutCreateInfoNVX { @@ -7830,6 +15785,58 @@ impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNVX { } } } +impl IndirectCommandsLayoutCreateInfoNVX { + pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + IndirectCommandsLayoutCreateInfoNVXBuilder { + inner: IndirectCommandsLayoutCreateInfoNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + inner: IndirectCommandsLayoutCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + type Target = IndirectCommandsLayoutCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: PipelineBindPoint, + ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn flags( + mut self, + flags: IndirectCommandsLayoutUsageFlagsNVX, + ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn token_count( + mut self, + token_count: u32, + ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + self.inner.token_count = token_count; + self + } + pub fn tokens( + mut self, + tokens: &'a [IndirectCommandsLayoutTokenNVX], + ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + self.inner.token_count = tokens.len() as u32; + self.inner.p_tokens = tokens.as_ptr(); + self + } + pub fn build(self) -> IndirectCommandsLayoutCreateInfoNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CmdProcessCommandsInfoNVX { @@ -7864,6 +15871,100 @@ impl ::std::default::Default for CmdProcessCommandsInfoNVX { } } } +impl CmdProcessCommandsInfoNVX { + pub fn builder<'a>() -> CmdProcessCommandsInfoNVXBuilder<'a> { + CmdProcessCommandsInfoNVXBuilder { + inner: CmdProcessCommandsInfoNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct CmdProcessCommandsInfoNVXBuilder<'a> { + inner: CmdProcessCommandsInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CmdProcessCommandsInfoNVXBuilder<'a> { + type Target = CmdProcessCommandsInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> CmdProcessCommandsInfoNVXBuilder<'a> { + pub fn object_table( + mut self, + object_table: ObjectTableNVX, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.object_table = object_table; + self + } + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: IndirectCommandsLayoutNVX, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.indirect_commands_layout = indirect_commands_layout; + self + } + pub fn indirect_commands_token_count( + mut self, + indirect_commands_token_count: u32, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.indirect_commands_token_count = indirect_commands_token_count; + self + } + pub fn indirect_commands_tokens( + mut self, + indirect_commands_tokens: &'a [IndirectCommandsTokenNVX], + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.indirect_commands_token_count = indirect_commands_tokens.len() as u32; + self.inner.p_indirect_commands_tokens = indirect_commands_tokens.as_ptr(); + self + } + pub fn max_sequences_count( + mut self, + max_sequences_count: u32, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.max_sequences_count = max_sequences_count; + self + } + pub fn target_command_buffer( + mut self, + target_command_buffer: CommandBuffer, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.target_command_buffer = target_command_buffer; + self + } + pub fn sequences_count_buffer( + mut self, + sequences_count_buffer: Buffer, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.sequences_count_buffer = sequences_count_buffer; + self + } + pub fn sequences_count_offset( + mut self, + sequences_count_offset: DeviceSize, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.sequences_count_offset = sequences_count_offset; + self + } + pub fn sequences_index_buffer( + mut self, + sequences_index_buffer: Buffer, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.sequences_index_buffer = sequences_index_buffer; + self + } + pub fn sequences_index_offset( + mut self, + sequences_index_offset: DeviceSize, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + self.inner.sequences_index_offset = sequences_index_offset; + self + } + pub fn build(self) -> CmdProcessCommandsInfoNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct CmdReserveSpaceForCommandsInfoNVX { @@ -7884,6 +15985,50 @@ impl ::std::default::Default for CmdReserveSpaceForCommandsInfoNVX { } } } +impl CmdReserveSpaceForCommandsInfoNVX { + pub fn builder<'a>() -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + CmdReserveSpaceForCommandsInfoNVXBuilder { + inner: CmdReserveSpaceForCommandsInfoNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + inner: CmdReserveSpaceForCommandsInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + type Target = CmdReserveSpaceForCommandsInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + pub fn object_table( + mut self, + object_table: ObjectTableNVX, + ) -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + self.inner.object_table = object_table; + self + } + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: IndirectCommandsLayoutNVX, + ) -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + self.inner.indirect_commands_layout = indirect_commands_layout; + self + } + pub fn max_sequences_count( + mut self, + max_sequences_count: u32, + ) -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + self.inner.max_sequences_count = max_sequences_count; + self + } + pub fn build(self) -> CmdReserveSpaceForCommandsInfoNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ObjectTableCreateInfoNVX { @@ -7916,12 +16061,129 @@ impl ::std::default::Default for ObjectTableCreateInfoNVX { } } } +impl ObjectTableCreateInfoNVX { + pub fn builder<'a>() -> ObjectTableCreateInfoNVXBuilder<'a> { + ObjectTableCreateInfoNVXBuilder { + inner: ObjectTableCreateInfoNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ObjectTableCreateInfoNVXBuilder<'a> { + inner: ObjectTableCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ObjectTableCreateInfoNVXBuilder<'a> { + type Target = ObjectTableCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ObjectTableCreateInfoNVXBuilder<'a> { + pub fn object_count(mut self, object_count: u32) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.object_count = object_count; + self + } + pub fn object_entry_types( + mut self, + object_entry_types: &'a [ObjectEntryTypeNVX], + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.object_count = object_entry_types.len() as u32; + self.inner.p_object_entry_types = object_entry_types.as_ptr(); + self + } + pub fn object_entry_counts( + mut self, + object_entry_counts: &'a [u32], + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.object_count = object_entry_counts.len() as u32; + self.inner.p_object_entry_counts = object_entry_counts.as_ptr(); + self + } + pub fn object_entry_usage_flags( + mut self, + object_entry_usage_flags: &'a [ObjectEntryUsageFlagsNVX], + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.object_count = object_entry_usage_flags.len() as u32; + self.inner.p_object_entry_usage_flags = object_entry_usage_flags.as_ptr(); + self + } + pub fn max_uniform_buffers_per_descriptor( + mut self, + max_uniform_buffers_per_descriptor: u32, + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.max_uniform_buffers_per_descriptor = max_uniform_buffers_per_descriptor; + self + } + pub fn max_storage_buffers_per_descriptor( + mut self, + max_storage_buffers_per_descriptor: u32, + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.max_storage_buffers_per_descriptor = max_storage_buffers_per_descriptor; + self + } + pub fn max_storage_images_per_descriptor( + mut self, + max_storage_images_per_descriptor: u32, + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.max_storage_images_per_descriptor = max_storage_images_per_descriptor; + self + } + pub fn max_sampled_images_per_descriptor( + mut self, + max_sampled_images_per_descriptor: u32, + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.max_sampled_images_per_descriptor = max_sampled_images_per_descriptor; + self + } + pub fn max_pipeline_layouts( + mut self, + max_pipeline_layouts: u32, + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + self.inner.max_pipeline_layouts = max_pipeline_layouts; + self + } + pub fn build(self) -> ObjectTableCreateInfoNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableEntryNVX { pub ty: ObjectEntryTypeNVX, pub flags: ObjectEntryUsageFlagsNVX, } +impl ObjectTableEntryNVX { + pub fn builder<'a>() -> ObjectTableEntryNVXBuilder<'a> { + ObjectTableEntryNVXBuilder { + inner: ObjectTableEntryNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ObjectTableEntryNVXBuilder<'a> { + inner: ObjectTableEntryNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ObjectTableEntryNVXBuilder<'a> { + type Target = ObjectTableEntryNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ObjectTableEntryNVXBuilder<'a> { + pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableEntryNVXBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn flags(mut self, flags: ObjectEntryUsageFlagsNVX) -> ObjectTableEntryNVXBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> ObjectTableEntryNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ObjectTablePipelineEntryNVX { @@ -7929,6 +16191,44 @@ pub struct ObjectTablePipelineEntryNVX { pub flags: ObjectEntryUsageFlagsNVX, pub pipeline: Pipeline, } +impl ObjectTablePipelineEntryNVX { + pub fn builder<'a>() -> ObjectTablePipelineEntryNVXBuilder<'a> { + ObjectTablePipelineEntryNVXBuilder { + inner: ObjectTablePipelineEntryNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ObjectTablePipelineEntryNVXBuilder<'a> { + inner: ObjectTablePipelineEntryNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ObjectTablePipelineEntryNVXBuilder<'a> { + type Target = ObjectTablePipelineEntryNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ObjectTablePipelineEntryNVXBuilder<'a> { + pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTablePipelineEntryNVXBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn flags( + mut self, + flags: ObjectEntryUsageFlagsNVX, + ) -> ObjectTablePipelineEntryNVXBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn pipeline(mut self, pipeline: Pipeline) -> ObjectTablePipelineEntryNVXBuilder<'a> { + self.inner.pipeline = pipeline; + self + } + pub fn build(self) -> ObjectTablePipelineEntryNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableDescriptorSetEntryNVX { @@ -7937,6 +16237,54 @@ pub struct ObjectTableDescriptorSetEntryNVX { pub pipeline_layout: PipelineLayout, pub descriptor_set: DescriptorSet, } +impl ObjectTableDescriptorSetEntryNVX { + pub fn builder<'a>() -> ObjectTableDescriptorSetEntryNVXBuilder<'a> { + ObjectTableDescriptorSetEntryNVXBuilder { + inner: ObjectTableDescriptorSetEntryNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ObjectTableDescriptorSetEntryNVXBuilder<'a> { + inner: ObjectTableDescriptorSetEntryNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ObjectTableDescriptorSetEntryNVXBuilder<'a> { + type Target = ObjectTableDescriptorSetEntryNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ObjectTableDescriptorSetEntryNVXBuilder<'a> { + pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableDescriptorSetEntryNVXBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn flags( + mut self, + flags: ObjectEntryUsageFlagsNVX, + ) -> ObjectTableDescriptorSetEntryNVXBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn pipeline_layout( + mut self, + pipeline_layout: PipelineLayout, + ) -> ObjectTableDescriptorSetEntryNVXBuilder<'a> { + self.inner.pipeline_layout = pipeline_layout; + self + } + pub fn descriptor_set( + mut self, + descriptor_set: DescriptorSet, + ) -> ObjectTableDescriptorSetEntryNVXBuilder<'a> { + self.inner.descriptor_set = descriptor_set; + self + } + pub fn build(self) -> ObjectTableDescriptorSetEntryNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableVertexBufferEntryNVX { @@ -7944,6 +16292,44 @@ pub struct ObjectTableVertexBufferEntryNVX { pub flags: ObjectEntryUsageFlagsNVX, pub buffer: Buffer, } +impl ObjectTableVertexBufferEntryNVX { + pub fn builder<'a>() -> ObjectTableVertexBufferEntryNVXBuilder<'a> { + ObjectTableVertexBufferEntryNVXBuilder { + inner: ObjectTableVertexBufferEntryNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ObjectTableVertexBufferEntryNVXBuilder<'a> { + inner: ObjectTableVertexBufferEntryNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ObjectTableVertexBufferEntryNVXBuilder<'a> { + type Target = ObjectTableVertexBufferEntryNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ObjectTableVertexBufferEntryNVXBuilder<'a> { + pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableVertexBufferEntryNVXBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn flags( + mut self, + flags: ObjectEntryUsageFlagsNVX, + ) -> ObjectTableVertexBufferEntryNVXBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn buffer(mut self, buffer: Buffer) -> ObjectTableVertexBufferEntryNVXBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn build(self) -> ObjectTableVertexBufferEntryNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ObjectTableIndexBufferEntryNVX { @@ -7952,6 +16338,51 @@ pub struct ObjectTableIndexBufferEntryNVX { pub buffer: Buffer, pub index_type: IndexType, } +impl ObjectTableIndexBufferEntryNVX { + pub fn builder<'a>() -> ObjectTableIndexBufferEntryNVXBuilder<'a> { + ObjectTableIndexBufferEntryNVXBuilder { + inner: ObjectTableIndexBufferEntryNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ObjectTableIndexBufferEntryNVXBuilder<'a> { + inner: ObjectTableIndexBufferEntryNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ObjectTableIndexBufferEntryNVXBuilder<'a> { + type Target = ObjectTableIndexBufferEntryNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ObjectTableIndexBufferEntryNVXBuilder<'a> { + pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableIndexBufferEntryNVXBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn flags( + mut self, + flags: ObjectEntryUsageFlagsNVX, + ) -> ObjectTableIndexBufferEntryNVXBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn buffer(mut self, buffer: Buffer) -> ObjectTableIndexBufferEntryNVXBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn index_type( + mut self, + index_type: IndexType, + ) -> ObjectTableIndexBufferEntryNVXBuilder<'a> { + self.inner.index_type = index_type; + self + } + pub fn build(self) -> ObjectTableIndexBufferEntryNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ObjectTablePushConstantEntryNVX { @@ -7960,6 +16391,54 @@ pub struct ObjectTablePushConstantEntryNVX { pub pipeline_layout: PipelineLayout, pub stage_flags: ShaderStageFlags, } +impl ObjectTablePushConstantEntryNVX { + pub fn builder<'a>() -> ObjectTablePushConstantEntryNVXBuilder<'a> { + ObjectTablePushConstantEntryNVXBuilder { + inner: ObjectTablePushConstantEntryNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ObjectTablePushConstantEntryNVXBuilder<'a> { + inner: ObjectTablePushConstantEntryNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ObjectTablePushConstantEntryNVXBuilder<'a> { + type Target = ObjectTablePushConstantEntryNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ObjectTablePushConstantEntryNVXBuilder<'a> { + pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTablePushConstantEntryNVXBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn flags( + mut self, + flags: ObjectEntryUsageFlagsNVX, + ) -> ObjectTablePushConstantEntryNVXBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn pipeline_layout( + mut self, + pipeline_layout: PipelineLayout, + ) -> ObjectTablePushConstantEntryNVXBuilder<'a> { + self.inner.pipeline_layout = pipeline_layout; + self + } + pub fn stage_flags( + mut self, + stage_flags: ShaderStageFlags, + ) -> ObjectTablePushConstantEntryNVXBuilder<'a> { + self.inner.stage_flags = stage_flags; + self + } + pub fn build(self) -> ObjectTablePushConstantEntryNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceFeatures2 { @@ -7976,6 +16455,36 @@ impl ::std::default::Default for PhysicalDeviceFeatures2 { } } } +impl PhysicalDeviceFeatures2 { + pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> { + PhysicalDeviceFeatures2Builder { + inner: PhysicalDeviceFeatures2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceFeatures2Builder<'a> { + inner: PhysicalDeviceFeatures2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> { + type Target = PhysicalDeviceFeatures2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceFeatures2Builder<'a> { + pub fn features( + mut self, + features: PhysicalDeviceFeatures, + ) -> PhysicalDeviceFeatures2Builder<'a> { + self.inner.features = features; + self + } + pub fn build(self) -> PhysicalDeviceFeatures2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProperties2 { @@ -7992,6 +16501,36 @@ impl ::std::default::Default for PhysicalDeviceProperties2 { } } } +impl PhysicalDeviceProperties2 { + pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> { + PhysicalDeviceProperties2Builder { + inner: PhysicalDeviceProperties2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceProperties2Builder<'a> { + inner: PhysicalDeviceProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> { + type Target = PhysicalDeviceProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceProperties2Builder<'a> { + pub fn properties( + mut self, + properties: PhysicalDeviceProperties, + ) -> PhysicalDeviceProperties2Builder<'a> { + self.inner.properties = properties; + self + } + pub fn build(self) -> PhysicalDeviceProperties2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FormatProperties2 { @@ -8008,6 +16547,36 @@ impl ::std::default::Default for FormatProperties2 { } } } +impl FormatProperties2 { + pub fn builder<'a>() -> FormatProperties2Builder<'a> { + FormatProperties2Builder { + inner: FormatProperties2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct FormatProperties2Builder<'a> { + inner: FormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> { + type Target = FormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> FormatProperties2Builder<'a> { + pub fn format_properties( + mut self, + format_properties: FormatProperties, + ) -> FormatProperties2Builder<'a> { + self.inner.format_properties = format_properties; + self + } + pub fn build(self) -> FormatProperties2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageFormatProperties2 { @@ -8024,6 +16593,36 @@ impl ::std::default::Default for ImageFormatProperties2 { } } } +impl ImageFormatProperties2 { + pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> { + ImageFormatProperties2Builder { + inner: ImageFormatProperties2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageFormatProperties2Builder<'a> { + inner: ImageFormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> { + type Target = ImageFormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageFormatProperties2Builder<'a> { + pub fn image_format_properties( + mut self, + image_format_properties: ImageFormatProperties, + ) -> ImageFormatProperties2Builder<'a> { + self.inner.image_format_properties = image_format_properties; + self + } + pub fn build(self) -> ImageFormatProperties2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceImageFormatInfo2 { @@ -8048,6 +16647,49 @@ impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { } } } +impl PhysicalDeviceImageFormatInfo2 { + pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> { + PhysicalDeviceImageFormatInfo2Builder { + inner: PhysicalDeviceImageFormatInfo2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceImageFormatInfo2Builder<'a> { + inner: PhysicalDeviceImageFormatInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> { + type Target = PhysicalDeviceImageFormatInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { + pub fn format(mut self, format: Format) -> PhysicalDeviceImageFormatInfo2Builder<'a> { + self.inner.format = format; + self + } + pub fn ty(mut self, ty: ImageType) -> PhysicalDeviceImageFormatInfo2Builder<'a> { + self.inner.ty = ty; + self + } + pub fn tiling(mut self, tiling: ImageTiling) -> PhysicalDeviceImageFormatInfo2Builder<'a> { + self.inner.tiling = tiling; + self + } + pub fn usage(mut self, usage: ImageUsageFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a> { + self.inner.usage = usage; + self + } + pub fn flags(mut self, flags: ImageCreateFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a> { + self.inner.flags = flags; + self + } + pub fn build(self) -> PhysicalDeviceImageFormatInfo2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct QueueFamilyProperties2 { @@ -8064,6 +16706,36 @@ impl ::std::default::Default for QueueFamilyProperties2 { } } } +impl QueueFamilyProperties2 { + pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> { + QueueFamilyProperties2Builder { + inner: QueueFamilyProperties2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct QueueFamilyProperties2Builder<'a> { + inner: QueueFamilyProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> { + type Target = QueueFamilyProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> QueueFamilyProperties2Builder<'a> { + pub fn queue_family_properties( + mut self, + queue_family_properties: QueueFamilyProperties, + ) -> QueueFamilyProperties2Builder<'a> { + self.inner.queue_family_properties = queue_family_properties; + self + } + pub fn build(self) -> QueueFamilyProperties2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMemoryProperties2 { @@ -8080,6 +16752,36 @@ impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { } } } +impl PhysicalDeviceMemoryProperties2 { + pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> { + PhysicalDeviceMemoryProperties2Builder { + inner: PhysicalDeviceMemoryProperties2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMemoryProperties2Builder<'a> { + inner: PhysicalDeviceMemoryProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> { + type Target = PhysicalDeviceMemoryProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { + pub fn memory_properties( + mut self, + memory_properties: PhysicalDeviceMemoryProperties, + ) -> PhysicalDeviceMemoryProperties2Builder<'a> { + self.inner.memory_properties = memory_properties; + self + } + pub fn build(self) -> PhysicalDeviceMemoryProperties2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageFormatProperties2 { @@ -8096,6 +16798,36 @@ impl ::std::default::Default for SparseImageFormatProperties2 { } } } +impl SparseImageFormatProperties2 { + pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> { + SparseImageFormatProperties2Builder { + inner: SparseImageFormatProperties2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseImageFormatProperties2Builder<'a> { + inner: SparseImageFormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> { + type Target = SparseImageFormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseImageFormatProperties2Builder<'a> { + pub fn properties( + mut self, + properties: SparseImageFormatProperties, + ) -> SparseImageFormatProperties2Builder<'a> { + self.inner.properties = properties; + self + } + pub fn build(self) -> SparseImageFormatProperties2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSparseImageFormatInfo2 { @@ -8120,6 +16852,58 @@ impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { } } } +impl PhysicalDeviceSparseImageFormatInfo2 { + pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + PhysicalDeviceSparseImageFormatInfo2Builder { + inner: PhysicalDeviceSparseImageFormatInfo2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + inner: PhysicalDeviceSparseImageFormatInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + type Target = PhysicalDeviceSparseImageFormatInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + pub fn format(mut self, format: Format) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + self.inner.format = format; + self + } + pub fn ty(mut self, ty: ImageType) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + self.inner.ty = ty; + self + } + pub fn samples( + mut self, + samples: SampleCountFlags, + ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + self.inner.samples = samples; + self + } + pub fn usage( + mut self, + usage: ImageUsageFlags, + ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + self.inner.usage = usage; + self + } + pub fn tiling( + mut self, + tiling: ImageTiling, + ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + self.inner.tiling = tiling; + self + } + pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePushDescriptorPropertiesKHR { @@ -8136,6 +16920,36 @@ impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { } } } +impl PhysicalDevicePushDescriptorPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + PhysicalDevicePushDescriptorPropertiesKHRBuilder { + inner: PhysicalDevicePushDescriptorPropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePushDescriptorPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePushDescriptorPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + pub fn max_push_descriptors( + mut self, + max_push_descriptors: u32, + ) -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + self.inner.max_push_descriptors = max_push_descriptors; + self + } + pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentRegionsKHR { @@ -8154,6 +16968,38 @@ impl ::std::default::Default for PresentRegionsKHR { } } } +impl PresentRegionsKHR { + pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> { + PresentRegionsKHRBuilder { + inner: PresentRegionsKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PresentRegionsKHRBuilder<'a> { + inner: PresentRegionsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> { + type Target = PresentRegionsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PresentRegionsKHRBuilder<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> PresentRegionsKHRBuilder<'a> { + self.inner.swapchain_count = swapchain_count; + self + } + pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> PresentRegionsKHRBuilder<'a> { + self.inner.swapchain_count = regions.len() as u32; + self.inner.p_regions = regions.as_ptr(); + self + } + pub fn build(self) -> PresentRegionsKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentRegionKHR { @@ -8168,6 +17014,38 @@ impl ::std::default::Default for PresentRegionKHR { } } } +impl PresentRegionKHR { + pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> { + PresentRegionKHRBuilder { + inner: PresentRegionKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PresentRegionKHRBuilder<'a> { + inner: PresentRegionKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> { + type Target = PresentRegionKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PresentRegionKHRBuilder<'a> { + pub fn rectangle_count(mut self, rectangle_count: u32) -> PresentRegionKHRBuilder<'a> { + self.inner.rectangle_count = rectangle_count; + self + } + pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> PresentRegionKHRBuilder<'a> { + self.inner.rectangle_count = rectangles.len() as u32; + self.inner.p_rectangles = rectangles.as_ptr(); + self + } + pub fn build(self) -> PresentRegionKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct RectLayerKHR { @@ -8175,6 +17053,41 @@ pub struct RectLayerKHR { pub extent: Extent2D, pub layer: u32, } +impl RectLayerKHR { + pub fn builder<'a>() -> RectLayerKHRBuilder<'a> { + RectLayerKHRBuilder { + inner: RectLayerKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RectLayerKHRBuilder<'a> { + inner: RectLayerKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> { + type Target = RectLayerKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RectLayerKHRBuilder<'a> { + pub fn offset(mut self, offset: Offset2D) -> RectLayerKHRBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn extent(mut self, extent: Extent2D) -> RectLayerKHRBuilder<'a> { + self.inner.extent = extent; + self + } + pub fn layer(mut self, layer: u32) -> RectLayerKHRBuilder<'a> { + self.inner.layer = layer; + self + } + pub fn build(self) -> RectLayerKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVariablePointerFeatures { @@ -8193,6 +17106,43 @@ impl ::std::default::Default for PhysicalDeviceVariablePointerFeatures { } } } +impl PhysicalDeviceVariablePointerFeatures { + pub fn builder<'a>() -> PhysicalDeviceVariablePointerFeaturesBuilder<'a> { + PhysicalDeviceVariablePointerFeaturesBuilder { + inner: PhysicalDeviceVariablePointerFeatures::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceVariablePointerFeaturesBuilder<'a> { + inner: PhysicalDeviceVariablePointerFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointerFeaturesBuilder<'a> { + type Target = PhysicalDeviceVariablePointerFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceVariablePointerFeaturesBuilder<'a> { + pub fn variable_pointers_storage_buffer( + mut self, + variable_pointers_storage_buffer: Bool32, + ) -> PhysicalDeviceVariablePointerFeaturesBuilder<'a> { + self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer; + self + } + pub fn variable_pointers( + mut self, + variable_pointers: Bool32, + ) -> PhysicalDeviceVariablePointerFeaturesBuilder<'a> { + self.inner.variable_pointers = variable_pointers; + self + } + pub fn build(self) -> PhysicalDeviceVariablePointerFeatures { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ExternalMemoryProperties { @@ -8200,6 +17150,50 @@ pub struct ExternalMemoryProperties { pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, pub compatible_handle_types: ExternalMemoryHandleTypeFlags, } +impl ExternalMemoryProperties { + pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> { + ExternalMemoryPropertiesBuilder { + inner: ExternalMemoryProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalMemoryPropertiesBuilder<'a> { + inner: ExternalMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> { + type Target = ExternalMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalMemoryPropertiesBuilder<'a> { + pub fn external_memory_features( + mut self, + external_memory_features: ExternalMemoryFeatureFlags, + ) -> ExternalMemoryPropertiesBuilder<'a> { + self.inner.external_memory_features = external_memory_features; + self + } + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, + ) -> ExternalMemoryPropertiesBuilder<'a> { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalMemoryHandleTypeFlags, + ) -> ExternalMemoryPropertiesBuilder<'a> { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + pub fn build(self) -> ExternalMemoryProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalImageFormatInfo { @@ -8216,6 +17210,36 @@ impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo { } } } +impl PhysicalDeviceExternalImageFormatInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + PhysicalDeviceExternalImageFormatInfoBuilder { + inner: PhysicalDeviceExternalImageFormatInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + inner: PhysicalDeviceExternalImageFormatInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + type Target = PhysicalDeviceExternalImageFormatInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlags, + ) -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalImageFormatProperties { @@ -8232,6 +17256,36 @@ impl ::std::default::Default for ExternalImageFormatProperties { } } } +impl ExternalImageFormatProperties { + pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> { + ExternalImageFormatPropertiesBuilder { + inner: ExternalImageFormatProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalImageFormatPropertiesBuilder<'a> { + inner: ExternalImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> { + type Target = ExternalImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalImageFormatPropertiesBuilder<'a> { + pub fn external_memory_properties( + mut self, + external_memory_properties: ExternalMemoryProperties, + ) -> ExternalImageFormatPropertiesBuilder<'a> { + self.inner.external_memory_properties = external_memory_properties; + self + } + pub fn build(self) -> ExternalImageFormatProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalBufferInfo { @@ -8252,6 +17306,47 @@ impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { } } } +impl PhysicalDeviceExternalBufferInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> { + PhysicalDeviceExternalBufferInfoBuilder { + inner: PhysicalDeviceExternalBufferInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> { + inner: PhysicalDeviceExternalBufferInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> { + type Target = PhysicalDeviceExternalBufferInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { + pub fn flags( + mut self, + flags: BufferCreateFlags, + ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn usage(mut self, usage: BufferUsageFlags) -> PhysicalDeviceExternalBufferInfoBuilder<'a> { + self.inner.usage = usage; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlags, + ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> PhysicalDeviceExternalBufferInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalBufferProperties { @@ -8268,6 +17363,36 @@ impl ::std::default::Default for ExternalBufferProperties { } } } +impl ExternalBufferProperties { + pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> { + ExternalBufferPropertiesBuilder { + inner: ExternalBufferProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalBufferPropertiesBuilder<'a> { + inner: ExternalBufferProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> { + type Target = ExternalBufferProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalBufferPropertiesBuilder<'a> { + pub fn external_memory_properties( + mut self, + external_memory_properties: ExternalMemoryProperties, + ) -> ExternalBufferPropertiesBuilder<'a> { + self.inner.external_memory_properties = external_memory_properties; + self + } + pub fn build(self) -> ExternalBufferProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceIDProperties { @@ -8292,6 +17417,64 @@ impl ::std::default::Default for PhysicalDeviceIDProperties { } } } +impl PhysicalDeviceIDProperties { + pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> { + PhysicalDeviceIDPropertiesBuilder { + inner: PhysicalDeviceIDProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceIDPropertiesBuilder<'a> { + inner: PhysicalDeviceIDProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> { + type Target = PhysicalDeviceIDProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> { + pub fn device_uuid( + mut self, + device_uuid: [u8; UUID_SIZE], + ) -> PhysicalDeviceIDPropertiesBuilder<'a> { + self.inner.device_uuid = device_uuid; + self + } + pub fn driver_uuid( + mut self, + driver_uuid: [u8; UUID_SIZE], + ) -> PhysicalDeviceIDPropertiesBuilder<'a> { + self.inner.driver_uuid = driver_uuid; + self + } + pub fn device_luid( + mut self, + device_luid: [u8; LUID_SIZE], + ) -> PhysicalDeviceIDPropertiesBuilder<'a> { + self.inner.device_luid = device_luid; + self + } + pub fn device_node_mask( + mut self, + device_node_mask: u32, + ) -> PhysicalDeviceIDPropertiesBuilder<'a> { + self.inner.device_node_mask = device_node_mask; + self + } + pub fn device_luid_valid( + mut self, + device_luid_valid: Bool32, + ) -> PhysicalDeviceIDPropertiesBuilder<'a> { + self.inner.device_luid_valid = device_luid_valid; + self + } + pub fn build(self) -> PhysicalDeviceIDProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalMemoryImageCreateInfo { @@ -8308,6 +17491,36 @@ impl ::std::default::Default for ExternalMemoryImageCreateInfo { } } } +impl ExternalMemoryImageCreateInfo { + pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> { + ExternalMemoryImageCreateInfoBuilder { + inner: ExternalMemoryImageCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalMemoryImageCreateInfoBuilder<'a> { + inner: ExternalMemoryImageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> { + type Target = ExternalMemoryImageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> { + pub fn handle_types( + mut self, + handle_types: ExternalMemoryHandleTypeFlags, + ) -> ExternalMemoryImageCreateInfoBuilder<'a> { + self.inner.handle_types = handle_types; + self + } + pub fn build(self) -> ExternalMemoryImageCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalMemoryBufferCreateInfo { @@ -8324,6 +17537,36 @@ impl ::std::default::Default for ExternalMemoryBufferCreateInfo { } } } +impl ExternalMemoryBufferCreateInfo { + pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> { + ExternalMemoryBufferCreateInfoBuilder { + inner: ExternalMemoryBufferCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalMemoryBufferCreateInfoBuilder<'a> { + inner: ExternalMemoryBufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> { + type Target = ExternalMemoryBufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> { + pub fn handle_types( + mut self, + handle_types: ExternalMemoryHandleTypeFlags, + ) -> ExternalMemoryBufferCreateInfoBuilder<'a> { + self.inner.handle_types = handle_types; + self + } + pub fn build(self) -> ExternalMemoryBufferCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryAllocateInfo { @@ -8340,6 +17583,36 @@ impl ::std::default::Default for ExportMemoryAllocateInfo { } } } +impl ExportMemoryAllocateInfo { + pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> { + ExportMemoryAllocateInfoBuilder { + inner: ExportMemoryAllocateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportMemoryAllocateInfoBuilder<'a> { + inner: ExportMemoryAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> { + type Target = ExportMemoryAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportMemoryAllocateInfoBuilder<'a> { + pub fn handle_types( + mut self, + handle_types: ExternalMemoryHandleTypeFlags, + ) -> ExportMemoryAllocateInfoBuilder<'a> { + self.inner.handle_types = handle_types; + self + } + pub fn build(self) -> ExportMemoryAllocateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryWin32HandleInfoKHR { @@ -8360,6 +17633,44 @@ impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR { } } } +impl ImportMemoryWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + ImportMemoryWin32HandleInfoKHRBuilder { + inner: ImportMemoryWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> { + inner: ImportMemoryWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> { + type Target = ImportMemoryWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlags, + ) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + self.inner.handle = handle; + self + } + pub fn name(mut self, name: LPCWSTR) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + self.inner.name = name; + self + } + pub fn build(self) -> ImportMemoryWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportMemoryWin32HandleInfoKHR { @@ -8380,6 +17691,44 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { } } } +impl ExportMemoryWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + ExportMemoryWin32HandleInfoKHRBuilder { + inner: ExportMemoryWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> { + inner: ExportMemoryWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> { + type Target = ExportMemoryWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + pub fn attributes( + mut self, + attributes: *const SECURITY_ATTRIBUTES, + ) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + self.inner.p_attributes = attributes; + self + } + pub fn dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + self.inner.dw_access = dw_access; + self + } + pub fn name(mut self, name: LPCWSTR) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + self.inner.name = name; + self + } + pub fn build(self) -> ExportMemoryWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryWin32HandlePropertiesKHR { @@ -8396,6 +17745,36 @@ impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { } } } +impl MemoryWin32HandlePropertiesKHR { + pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> { + MemoryWin32HandlePropertiesKHRBuilder { + inner: MemoryWin32HandlePropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> { + inner: MemoryWin32HandlePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> { + type Target = MemoryWin32HandlePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { + pub fn memory_type_bits( + mut self, + memory_type_bits: u32, + ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> { + self.inner.memory_type_bits = memory_type_bits; + self + } + pub fn build(self) -> MemoryWin32HandlePropertiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryGetWin32HandleInfoKHR { @@ -8414,6 +17793,40 @@ impl ::std::default::Default for MemoryGetWin32HandleInfoKHR { } } } +impl MemoryGetWin32HandleInfoKHR { + pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> { + MemoryGetWin32HandleInfoKHRBuilder { + inner: MemoryGetWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> { + inner: MemoryGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> { + type Target = MemoryGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { + pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetWin32HandleInfoKHRBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlags, + ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> MemoryGetWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryFdInfoKHR { @@ -8432,6 +17845,40 @@ impl ::std::default::Default for ImportMemoryFdInfoKHR { } } } +impl ImportMemoryFdInfoKHR { + pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> { + ImportMemoryFdInfoKHRBuilder { + inner: ImportMemoryFdInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportMemoryFdInfoKHRBuilder<'a> { + inner: ImportMemoryFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> { + type Target = ImportMemoryFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportMemoryFdInfoKHRBuilder<'a> { + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlags, + ) -> ImportMemoryFdInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn fd(mut self, fd: c_int) -> ImportMemoryFdInfoKHRBuilder<'a> { + self.inner.fd = fd; + self + } + pub fn build(self) -> ImportMemoryFdInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryFdPropertiesKHR { @@ -8448,6 +17895,33 @@ impl ::std::default::Default for MemoryFdPropertiesKHR { } } } +impl MemoryFdPropertiesKHR { + pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> { + MemoryFdPropertiesKHRBuilder { + inner: MemoryFdPropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryFdPropertiesKHRBuilder<'a> { + inner: MemoryFdPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> { + type Target = MemoryFdPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryFdPropertiesKHRBuilder<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> MemoryFdPropertiesKHRBuilder<'a> { + self.inner.memory_type_bits = memory_type_bits; + self + } + pub fn build(self) -> MemoryFdPropertiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryGetFdInfoKHR { @@ -8466,6 +17940,40 @@ impl ::std::default::Default for MemoryGetFdInfoKHR { } } } +impl MemoryGetFdInfoKHR { + pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> { + MemoryGetFdInfoKHRBuilder { + inner: MemoryGetFdInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryGetFdInfoKHRBuilder<'a> { + inner: MemoryGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> { + type Target = MemoryGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryGetFdInfoKHRBuilder<'a> { + pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetFdInfoKHRBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlags, + ) -> MemoryGetFdInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> MemoryGetFdInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct Win32KeyedMutexAcquireReleaseInfoKHR { @@ -8494,6 +18002,83 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { } } } +impl Win32KeyedMutexAcquireReleaseInfoKHR { + pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + Win32KeyedMutexAcquireReleaseInfoKHRBuilder { + inner: Win32KeyedMutexAcquireReleaseInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + inner: Win32KeyedMutexAcquireReleaseInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + type Target = Win32KeyedMutexAcquireReleaseInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + pub fn acquire_count( + mut self, + acquire_count: u32, + ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + self.inner.acquire_count = acquire_count; + self + } + pub fn acquire_syncs( + mut self, + acquire_syncs: &'a [DeviceMemory], + ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + self.inner.acquire_count = acquire_syncs.len() as u32; + self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self + } + pub fn acquire_keys( + mut self, + acquire_keys: &'a [u64], + ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + self.inner.acquire_count = acquire_keys.len() as u32; + self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self + } + pub fn acquire_timeouts( + mut self, + acquire_timeouts: &'a [u32], + ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + self.inner.acquire_count = acquire_timeouts.len() as u32; + self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr(); + self + } + pub fn release_count( + mut self, + release_count: u32, + ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + self.inner.release_count = release_count; + self + } + pub fn release_syncs( + mut self, + release_syncs: &'a [DeviceMemory], + ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + self.inner.release_count = release_syncs.len() as u32; + self.inner.p_release_syncs = release_syncs.as_ptr(); + self + } + pub fn release_keys( + mut self, + release_keys: &'a [u64], + ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + self.inner.release_count = release_keys.len() as u32; + self.inner.p_release_keys = release_keys.as_ptr(); + self + } + pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalSemaphoreInfo { @@ -8510,6 +18095,36 @@ impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo { } } } +impl PhysicalDeviceExternalSemaphoreInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + PhysicalDeviceExternalSemaphoreInfoBuilder { + inner: PhysicalDeviceExternalSemaphoreInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + inner: PhysicalDeviceExternalSemaphoreInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + type Target = PhysicalDeviceExternalSemaphoreInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + pub fn handle_type( + mut self, + handle_type: ExternalSemaphoreHandleTypeFlags, + ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalSemaphoreProperties { @@ -8530,6 +18145,50 @@ impl ::std::default::Default for ExternalSemaphoreProperties { } } } +impl ExternalSemaphoreProperties { + pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> { + ExternalSemaphorePropertiesBuilder { + inner: ExternalSemaphoreProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalSemaphorePropertiesBuilder<'a> { + inner: ExternalSemaphoreProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> { + type Target = ExternalSemaphoreProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalSemaphorePropertiesBuilder<'a> { + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, + ) -> ExternalSemaphorePropertiesBuilder<'a> { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalSemaphoreHandleTypeFlags, + ) -> ExternalSemaphorePropertiesBuilder<'a> { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + pub fn external_semaphore_features( + mut self, + external_semaphore_features: ExternalSemaphoreFeatureFlags, + ) -> ExternalSemaphorePropertiesBuilder<'a> { + self.inner.external_semaphore_features = external_semaphore_features; + self + } + pub fn build(self) -> ExternalSemaphoreProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportSemaphoreCreateInfo { @@ -8546,6 +18205,36 @@ impl ::std::default::Default for ExportSemaphoreCreateInfo { } } } +impl ExportSemaphoreCreateInfo { + pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> { + ExportSemaphoreCreateInfoBuilder { + inner: ExportSemaphoreCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportSemaphoreCreateInfoBuilder<'a> { + inner: ExportSemaphoreCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> { + type Target = ExportSemaphoreCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportSemaphoreCreateInfoBuilder<'a> { + pub fn handle_types( + mut self, + handle_types: ExternalSemaphoreHandleTypeFlags, + ) -> ExportSemaphoreCreateInfoBuilder<'a> { + self.inner.handle_types = handle_types; + self + } + pub fn build(self) -> ExportSemaphoreCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportSemaphoreWin32HandleInfoKHR { @@ -8570,6 +18259,58 @@ impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR { } } } +impl ImportSemaphoreWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + ImportSemaphoreWin32HandleInfoKHRBuilder { + inner: ImportSemaphoreWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + inner: ImportSemaphoreWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + type Target = ImportSemaphoreWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + pub fn semaphore( + mut self, + semaphore: Semaphore, + ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.semaphore = semaphore; + self + } + pub fn flags( + mut self, + flags: SemaphoreImportFlags, + ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalSemaphoreHandleTypeFlags, + ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: HANDLE) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.handle = handle; + self + } + pub fn name(mut self, name: LPCWSTR) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.name = name; + self + } + pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportSemaphoreWin32HandleInfoKHR { @@ -8590,6 +18331,44 @@ impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { } } } +impl ExportSemaphoreWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + ExportSemaphoreWin32HandleInfoKHRBuilder { + inner: ExportSemaphoreWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + inner: ExportSemaphoreWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + type Target = ExportSemaphoreWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + pub fn attributes( + mut self, + attributes: *const SECURITY_ATTRIBUTES, + ) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.p_attributes = attributes; + self + } + pub fn dw_access(mut self, dw_access: DWORD) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.dw_access = dw_access; + self + } + pub fn name(mut self, name: LPCWSTR) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + self.inner.name = name; + self + } + pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct D3D12FenceSubmitInfoKHR { @@ -8612,6 +18391,59 @@ impl ::std::default::Default for D3D12FenceSubmitInfoKHR { } } } +impl D3D12FenceSubmitInfoKHR { + pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> { + D3D12FenceSubmitInfoKHRBuilder { + inner: D3D12FenceSubmitInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct D3D12FenceSubmitInfoKHRBuilder<'a> { + inner: D3D12FenceSubmitInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> { + type Target = D3D12FenceSubmitInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { + pub fn wait_semaphore_values_count( + mut self, + wait_semaphore_values_count: u32, + ) -> D3D12FenceSubmitInfoKHRBuilder<'a> { + self.inner.wait_semaphore_values_count = wait_semaphore_values_count; + self + } + pub fn wait_semaphore_values( + mut self, + wait_semaphore_values: &'a [u64], + ) -> D3D12FenceSubmitInfoKHRBuilder<'a> { + self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as u32; + self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); + self + } + pub fn signal_semaphore_values_count( + mut self, + signal_semaphore_values_count: u32, + ) -> D3D12FenceSubmitInfoKHRBuilder<'a> { + self.inner.signal_semaphore_values_count = signal_semaphore_values_count; + self + } + pub fn signal_semaphore_values( + mut self, + signal_semaphore_values: &'a [u64], + ) -> D3D12FenceSubmitInfoKHRBuilder<'a> { + self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as u32; + self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); + self + } + pub fn build(self) -> D3D12FenceSubmitInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SemaphoreGetWin32HandleInfoKHR { @@ -8630,6 +18462,40 @@ impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR { } } } +impl SemaphoreGetWin32HandleInfoKHR { + pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + SemaphoreGetWin32HandleInfoKHRBuilder { + inner: SemaphoreGetWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + inner: SemaphoreGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + type Target = SemaphoreGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + self.inner.semaphore = semaphore; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalSemaphoreHandleTypeFlags, + ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportSemaphoreFdInfoKHR { @@ -8652,6 +18518,48 @@ impl ::std::default::Default for ImportSemaphoreFdInfoKHR { } } } +impl ImportSemaphoreFdInfoKHR { + pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> { + ImportSemaphoreFdInfoKHRBuilder { + inner: ImportSemaphoreFdInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportSemaphoreFdInfoKHRBuilder<'a> { + inner: ImportSemaphoreFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> { + type Target = ImportSemaphoreFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { + pub fn semaphore(mut self, semaphore: Semaphore) -> ImportSemaphoreFdInfoKHRBuilder<'a> { + self.inner.semaphore = semaphore; + self + } + pub fn flags(mut self, flags: SemaphoreImportFlags) -> ImportSemaphoreFdInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalSemaphoreHandleTypeFlags, + ) -> ImportSemaphoreFdInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn fd(mut self, fd: c_int) -> ImportSemaphoreFdInfoKHRBuilder<'a> { + self.inner.fd = fd; + self + } + pub fn build(self) -> ImportSemaphoreFdInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SemaphoreGetFdInfoKHR { @@ -8670,6 +18578,40 @@ impl ::std::default::Default for SemaphoreGetFdInfoKHR { } } } +impl SemaphoreGetFdInfoKHR { + pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> { + SemaphoreGetFdInfoKHRBuilder { + inner: SemaphoreGetFdInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SemaphoreGetFdInfoKHRBuilder<'a> { + inner: SemaphoreGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> { + type Target = SemaphoreGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { + pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetFdInfoKHRBuilder<'a> { + self.inner.semaphore = semaphore; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalSemaphoreHandleTypeFlags, + ) -> SemaphoreGetFdInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> SemaphoreGetFdInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalFenceInfo { @@ -8686,6 +18628,36 @@ impl ::std::default::Default for PhysicalDeviceExternalFenceInfo { } } } +impl PhysicalDeviceExternalFenceInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> { + PhysicalDeviceExternalFenceInfoBuilder { + inner: PhysicalDeviceExternalFenceInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> { + inner: PhysicalDeviceExternalFenceInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> { + type Target = PhysicalDeviceExternalFenceInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { + pub fn handle_type( + mut self, + handle_type: ExternalFenceHandleTypeFlags, + ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> PhysicalDeviceExternalFenceInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalFenceProperties { @@ -8706,6 +18678,50 @@ impl ::std::default::Default for ExternalFenceProperties { } } } +impl ExternalFenceProperties { + pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> { + ExternalFencePropertiesBuilder { + inner: ExternalFenceProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalFencePropertiesBuilder<'a> { + inner: ExternalFenceProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> { + type Target = ExternalFenceProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalFencePropertiesBuilder<'a> { + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalFenceHandleTypeFlags, + ) -> ExternalFencePropertiesBuilder<'a> { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalFenceHandleTypeFlags, + ) -> ExternalFencePropertiesBuilder<'a> { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + pub fn external_fence_features( + mut self, + external_fence_features: ExternalFenceFeatureFlags, + ) -> ExternalFencePropertiesBuilder<'a> { + self.inner.external_fence_features = external_fence_features; + self + } + pub fn build(self) -> ExternalFenceProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportFenceCreateInfo { @@ -8722,6 +18738,36 @@ impl ::std::default::Default for ExportFenceCreateInfo { } } } +impl ExportFenceCreateInfo { + pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> { + ExportFenceCreateInfoBuilder { + inner: ExportFenceCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportFenceCreateInfoBuilder<'a> { + inner: ExportFenceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> { + type Target = ExportFenceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportFenceCreateInfoBuilder<'a> { + pub fn handle_types( + mut self, + handle_types: ExternalFenceHandleTypeFlags, + ) -> ExportFenceCreateInfoBuilder<'a> { + self.inner.handle_types = handle_types; + self + } + pub fn build(self) -> ExportFenceCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportFenceWin32HandleInfoKHR { @@ -8746,6 +18792,52 @@ impl ::std::default::Default for ImportFenceWin32HandleInfoKHR { } } } +impl ImportFenceWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + ImportFenceWin32HandleInfoKHRBuilder { + inner: ImportFenceWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> { + inner: ImportFenceWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> { + type Target = ImportFenceWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { + pub fn fence(mut self, fence: Fence) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.fence = fence; + self + } + pub fn flags(mut self, flags: FenceImportFlags) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalFenceHandleTypeFlags, + ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: HANDLE) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.handle = handle; + self + } + pub fn name(mut self, name: LPCWSTR) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.name = name; + self + } + pub fn build(self) -> ImportFenceWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExportFenceWin32HandleInfoKHR { @@ -8766,6 +18858,44 @@ impl ::std::default::Default for ExportFenceWin32HandleInfoKHR { } } } +impl ExportFenceWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> { + ExportFenceWin32HandleInfoKHRBuilder { + inner: ExportFenceWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> { + inner: ExportFenceWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> { + type Target = ExportFenceWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> { + pub fn attributes( + mut self, + attributes: *const SECURITY_ATTRIBUTES, + ) -> ExportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.p_attributes = attributes; + self + } + pub fn dw_access(mut self, dw_access: DWORD) -> ExportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.dw_access = dw_access; + self + } + pub fn name(mut self, name: LPCWSTR) -> ExportFenceWin32HandleInfoKHRBuilder<'a> { + self.inner.name = name; + self + } + pub fn build(self) -> ExportFenceWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FenceGetWin32HandleInfoKHR { @@ -8784,6 +18914,40 @@ impl ::std::default::Default for FenceGetWin32HandleInfoKHR { } } } +impl FenceGetWin32HandleInfoKHR { + pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> { + FenceGetWin32HandleInfoKHRBuilder { + inner: FenceGetWin32HandleInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct FenceGetWin32HandleInfoKHRBuilder<'a> { + inner: FenceGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> { + type Target = FenceGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { + pub fn fence(mut self, fence: Fence) -> FenceGetWin32HandleInfoKHRBuilder<'a> { + self.inner.fence = fence; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalFenceHandleTypeFlags, + ) -> FenceGetWin32HandleInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> FenceGetWin32HandleInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportFenceFdInfoKHR { @@ -8806,6 +18970,48 @@ impl ::std::default::Default for ImportFenceFdInfoKHR { } } } +impl ImportFenceFdInfoKHR { + pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> { + ImportFenceFdInfoKHRBuilder { + inner: ImportFenceFdInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportFenceFdInfoKHRBuilder<'a> { + inner: ImportFenceFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> { + type Target = ImportFenceFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportFenceFdInfoKHRBuilder<'a> { + pub fn fence(mut self, fence: Fence) -> ImportFenceFdInfoKHRBuilder<'a> { + self.inner.fence = fence; + self + } + pub fn flags(mut self, flags: FenceImportFlags) -> ImportFenceFdInfoKHRBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalFenceHandleTypeFlags, + ) -> ImportFenceFdInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn fd(mut self, fd: c_int) -> ImportFenceFdInfoKHRBuilder<'a> { + self.inner.fd = fd; + self + } + pub fn build(self) -> ImportFenceFdInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct FenceGetFdInfoKHR { @@ -8824,6 +19030,40 @@ impl ::std::default::Default for FenceGetFdInfoKHR { } } } +impl FenceGetFdInfoKHR { + pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> { + FenceGetFdInfoKHRBuilder { + inner: FenceGetFdInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct FenceGetFdInfoKHRBuilder<'a> { + inner: FenceGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> { + type Target = FenceGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> FenceGetFdInfoKHRBuilder<'a> { + pub fn fence(mut self, fence: Fence) -> FenceGetFdInfoKHRBuilder<'a> { + self.inner.fence = fence; + self + } + pub fn handle_type( + mut self, + handle_type: ExternalFenceHandleTypeFlags, + ) -> FenceGetFdInfoKHRBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn build(self) -> FenceGetFdInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewFeatures { @@ -8844,6 +19084,47 @@ impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { } } } +impl PhysicalDeviceMultiviewFeatures { + pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + PhysicalDeviceMultiviewFeaturesBuilder { + inner: PhysicalDeviceMultiviewFeatures::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> { + inner: PhysicalDeviceMultiviewFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> { + type Target = PhysicalDeviceMultiviewFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + pub fn multiview(mut self, multiview: Bool32) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + self.inner.multiview = multiview; + self + } + pub fn multiview_geometry_shader( + mut self, + multiview_geometry_shader: Bool32, + ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + self.inner.multiview_geometry_shader = multiview_geometry_shader; + self + } + pub fn multiview_tessellation_shader( + mut self, + multiview_tessellation_shader: Bool32, + ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + self.inner.multiview_tessellation_shader = multiview_tessellation_shader; + self + } + pub fn build(self) -> PhysicalDeviceMultiviewFeatures { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewProperties { @@ -8862,6 +19143,43 @@ impl ::std::default::Default for PhysicalDeviceMultiviewProperties { } } } +impl PhysicalDeviceMultiviewProperties { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + PhysicalDeviceMultiviewPropertiesBuilder { + inner: PhysicalDeviceMultiviewProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> { + inner: PhysicalDeviceMultiviewProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> { + type Target = PhysicalDeviceMultiviewProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + pub fn max_multiview_view_count( + mut self, + max_multiview_view_count: u32, + ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + self.inner.max_multiview_view_count = max_multiview_view_count; + self + } + pub fn max_multiview_instance_index( + mut self, + max_multiview_instance_index: u32, + ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + self.inner.max_multiview_instance_index = max_multiview_instance_index; + self + } + pub fn build(self) -> PhysicalDeviceMultiviewProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct RenderPassMultiviewCreateInfo { @@ -8888,6 +19206,68 @@ impl ::std::default::Default for RenderPassMultiviewCreateInfo { } } } +impl RenderPassMultiviewCreateInfo { + pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> { + RenderPassMultiviewCreateInfoBuilder { + inner: RenderPassMultiviewCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RenderPassMultiviewCreateInfoBuilder<'a> { + inner: RenderPassMultiviewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> { + type Target = RenderPassMultiviewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { + pub fn subpass_count(mut self, subpass_count: u32) -> RenderPassMultiviewCreateInfoBuilder<'a> { + self.inner.subpass_count = subpass_count; + self + } + pub fn view_masks(mut self, view_masks: &'a [u32]) -> RenderPassMultiviewCreateInfoBuilder<'a> { + self.inner.subpass_count = view_masks.len() as u32; + self.inner.p_view_masks = view_masks.as_ptr(); + self + } + pub fn dependency_count( + mut self, + dependency_count: u32, + ) -> RenderPassMultiviewCreateInfoBuilder<'a> { + self.inner.dependency_count = dependency_count; + self + } + pub fn view_offsets( + mut self, + view_offsets: &'a [i32], + ) -> RenderPassMultiviewCreateInfoBuilder<'a> { + self.inner.dependency_count = view_offsets.len() as u32; + self.inner.p_view_offsets = view_offsets.as_ptr(); + self + } + pub fn correlation_mask_count( + mut self, + correlation_mask_count: u32, + ) -> RenderPassMultiviewCreateInfoBuilder<'a> { + self.inner.correlation_mask_count = correlation_mask_count; + self + } + pub fn correlation_masks( + mut self, + correlation_masks: &'a [u32], + ) -> RenderPassMultiviewCreateInfoBuilder<'a> { + self.inner.correlation_mask_count = correlation_masks.len() as u32; + self.inner.p_correlation_masks = correlation_masks.as_ptr(); + self + } + pub fn build(self) -> RenderPassMultiviewCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2EXT { @@ -8924,6 +19304,100 @@ impl ::std::default::Default for SurfaceCapabilities2EXT { } } } +impl SurfaceCapabilities2EXT { + pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> { + SurfaceCapabilities2EXTBuilder { + inner: SurfaceCapabilities2EXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SurfaceCapabilities2EXTBuilder<'a> { + inner: SurfaceCapabilities2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> { + type Target = SurfaceCapabilities2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SurfaceCapabilities2EXTBuilder<'a> { + pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.min_image_count = min_image_count; + self + } + pub fn max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.max_image_count = max_image_count; + self + } + pub fn current_extent( + mut self, + current_extent: Extent2D, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.current_extent = current_extent; + self + } + pub fn min_image_extent( + mut self, + min_image_extent: Extent2D, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.min_image_extent = min_image_extent; + self + } + pub fn max_image_extent( + mut self, + max_image_extent: Extent2D, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.max_image_extent = max_image_extent; + self + } + pub fn max_image_array_layers( + mut self, + max_image_array_layers: u32, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + pub fn supported_transforms( + mut self, + supported_transforms: SurfaceTransformFlagsKHR, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.supported_transforms = supported_transforms; + self + } + pub fn current_transform( + mut self, + current_transform: SurfaceTransformFlagsKHR, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.current_transform = current_transform; + self + } + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: CompositeAlphaFlagsKHR, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.supported_composite_alpha = supported_composite_alpha; + self + } + pub fn supported_usage_flags( + mut self, + supported_usage_flags: ImageUsageFlags, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.supported_usage_flags = supported_usage_flags; + self + } + pub fn supported_surface_counters( + mut self, + supported_surface_counters: SurfaceCounterFlagsEXT, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + self.inner.supported_surface_counters = supported_surface_counters; + self + } + pub fn build(self) -> SurfaceCapabilities2EXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPowerInfoEXT { @@ -8940,6 +19414,36 @@ impl ::std::default::Default for DisplayPowerInfoEXT { } } } +impl DisplayPowerInfoEXT { + pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> { + DisplayPowerInfoEXTBuilder { + inner: DisplayPowerInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPowerInfoEXTBuilder<'a> { + inner: DisplayPowerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> { + type Target = DisplayPowerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPowerInfoEXTBuilder<'a> { + pub fn power_state( + mut self, + power_state: DisplayPowerStateEXT, + ) -> DisplayPowerInfoEXTBuilder<'a> { + self.inner.power_state = power_state; + self + } + pub fn build(self) -> DisplayPowerInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceEventInfoEXT { @@ -8956,6 +19460,36 @@ impl ::std::default::Default for DeviceEventInfoEXT { } } } +impl DeviceEventInfoEXT { + pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> { + DeviceEventInfoEXTBuilder { + inner: DeviceEventInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceEventInfoEXTBuilder<'a> { + inner: DeviceEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> { + type Target = DeviceEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceEventInfoEXTBuilder<'a> { + pub fn device_event( + mut self, + device_event: DeviceEventTypeEXT, + ) -> DeviceEventInfoEXTBuilder<'a> { + self.inner.device_event = device_event; + self + } + pub fn build(self) -> DeviceEventInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayEventInfoEXT { @@ -8972,6 +19506,36 @@ impl ::std::default::Default for DisplayEventInfoEXT { } } } +impl DisplayEventInfoEXT { + pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> { + DisplayEventInfoEXTBuilder { + inner: DisplayEventInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayEventInfoEXTBuilder<'a> { + inner: DisplayEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> { + type Target = DisplayEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayEventInfoEXTBuilder<'a> { + pub fn display_event( + mut self, + display_event: DisplayEventTypeEXT, + ) -> DisplayEventInfoEXTBuilder<'a> { + self.inner.display_event = display_event; + self + } + pub fn build(self) -> DisplayEventInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SwapchainCounterCreateInfoEXT { @@ -8988,6 +19552,36 @@ impl ::std::default::Default for SwapchainCounterCreateInfoEXT { } } } +impl SwapchainCounterCreateInfoEXT { + pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> { + SwapchainCounterCreateInfoEXTBuilder { + inner: SwapchainCounterCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SwapchainCounterCreateInfoEXTBuilder<'a> { + inner: SwapchainCounterCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> { + type Target = SwapchainCounterCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> { + pub fn surface_counters( + mut self, + surface_counters: SurfaceCounterFlagsEXT, + ) -> SwapchainCounterCreateInfoEXTBuilder<'a> { + self.inner.surface_counters = surface_counters; + self + } + pub fn build(self) -> SwapchainCounterCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceGroupProperties { @@ -9008,6 +19602,50 @@ impl ::std::default::Default for PhysicalDeviceGroupProperties { } } } +impl PhysicalDeviceGroupProperties { + pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> { + PhysicalDeviceGroupPropertiesBuilder { + inner: PhysicalDeviceGroupProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceGroupPropertiesBuilder<'a> { + inner: PhysicalDeviceGroupProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> { + type Target = PhysicalDeviceGroupProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { + pub fn physical_device_count( + mut self, + physical_device_count: u32, + ) -> PhysicalDeviceGroupPropertiesBuilder<'a> { + self.inner.physical_device_count = physical_device_count; + self + } + pub fn physical_devices( + mut self, + physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], + ) -> PhysicalDeviceGroupPropertiesBuilder<'a> { + self.inner.physical_devices = physical_devices; + self + } + pub fn subset_allocation( + mut self, + subset_allocation: Bool32, + ) -> PhysicalDeviceGroupPropertiesBuilder<'a> { + self.inner.subset_allocation = subset_allocation; + self + } + pub fn build(self) -> PhysicalDeviceGroupProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryAllocateFlagsInfo { @@ -9026,6 +19664,37 @@ impl ::std::default::Default for MemoryAllocateFlagsInfo { } } } +impl MemoryAllocateFlagsInfo { + pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> { + MemoryAllocateFlagsInfoBuilder { + inner: MemoryAllocateFlagsInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryAllocateFlagsInfoBuilder<'a> { + inner: MemoryAllocateFlagsInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> { + type Target = MemoryAllocateFlagsInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryAllocateFlagsInfoBuilder<'a> { + pub fn flags(mut self, flags: MemoryAllocateFlags) -> MemoryAllocateFlagsInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn device_mask(mut self, device_mask: u32) -> MemoryAllocateFlagsInfoBuilder<'a> { + self.inner.device_mask = device_mask; + self + } + pub fn build(self) -> MemoryAllocateFlagsInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryInfo { @@ -9046,6 +19715,41 @@ impl ::std::default::Default for BindBufferMemoryInfo { } } } +impl BindBufferMemoryInfo { + pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> { + BindBufferMemoryInfoBuilder { + inner: BindBufferMemoryInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BindBufferMemoryInfoBuilder<'a> { + inner: BindBufferMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> { + type Target = BindBufferMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BindBufferMemoryInfoBuilder<'a> { + pub fn buffer(mut self, buffer: Buffer) -> BindBufferMemoryInfoBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn memory(mut self, memory: DeviceMemory) -> BindBufferMemoryInfoBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> BindBufferMemoryInfoBuilder<'a> { + self.inner.memory_offset = memory_offset; + self + } + pub fn build(self) -> BindBufferMemoryInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindBufferMemoryDeviceGroupInfo { @@ -9064,6 +19768,44 @@ impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { } } } +impl BindBufferMemoryDeviceGroupInfo { + pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + BindBufferMemoryDeviceGroupInfoBuilder { + inner: BindBufferMemoryDeviceGroupInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> { + inner: BindBufferMemoryDeviceGroupInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> { + type Target = BindBufferMemoryDeviceGroupInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + pub fn device_index_count( + mut self, + device_index_count: u32, + ) -> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + self.inner.device_index_count = device_index_count; + self + } + pub fn device_indices( + mut self, + device_indices: &'a [u32], + ) -> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + self.inner.device_index_count = device_indices.len() as u32; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + pub fn build(self) -> BindBufferMemoryDeviceGroupInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImageMemoryInfo { @@ -9084,6 +19826,41 @@ impl ::std::default::Default for BindImageMemoryInfo { } } } +impl BindImageMemoryInfo { + pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> { + BindImageMemoryInfoBuilder { + inner: BindImageMemoryInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BindImageMemoryInfoBuilder<'a> { + inner: BindImageMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> { + type Target = BindImageMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BindImageMemoryInfoBuilder<'a> { + pub fn image(mut self, image: Image) -> BindImageMemoryInfoBuilder<'a> { + self.inner.image = image; + self + } + pub fn memory(mut self, memory: DeviceMemory) -> BindImageMemoryInfoBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> BindImageMemoryInfoBuilder<'a> { + self.inner.memory_offset = memory_offset; + self + } + pub fn build(self) -> BindImageMemoryInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImageMemoryDeviceGroupInfo { @@ -9106,6 +19883,59 @@ impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { } } } +impl BindImageMemoryDeviceGroupInfo { + pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> { + BindImageMemoryDeviceGroupInfoBuilder { + inner: BindImageMemoryDeviceGroupInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> { + inner: BindImageMemoryDeviceGroupInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> { + type Target = BindImageMemoryDeviceGroupInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { + pub fn device_index_count( + mut self, + device_index_count: u32, + ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> { + self.inner.device_index_count = device_index_count; + self + } + pub fn device_indices( + mut self, + device_indices: &'a [u32], + ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> { + self.inner.device_index_count = device_indices.len() as u32; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + pub fn split_instance_bind_region_count( + mut self, + split_instance_bind_region_count: u32, + ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> { + self.inner.split_instance_bind_region_count = split_instance_bind_region_count; + self + } + pub fn split_instance_bind_regions( + mut self, + split_instance_bind_regions: &'a [Rect2D], + ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> { + self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as u32; + self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr(); + self + } + pub fn build(self) -> BindImageMemoryDeviceGroupInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupRenderPassBeginInfo { @@ -9126,6 +19956,48 @@ impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { } } } +impl DeviceGroupRenderPassBeginInfo { + pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> { + DeviceGroupRenderPassBeginInfoBuilder { + inner: DeviceGroupRenderPassBeginInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> { + inner: DeviceGroupRenderPassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> { + type Target = DeviceGroupRenderPassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> { + pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupRenderPassBeginInfoBuilder<'a> { + self.inner.device_mask = device_mask; + self + } + pub fn device_render_area_count( + mut self, + device_render_area_count: u32, + ) -> DeviceGroupRenderPassBeginInfoBuilder<'a> { + self.inner.device_render_area_count = device_render_area_count; + self + } + pub fn device_render_areas( + mut self, + device_render_areas: &'a [Rect2D], + ) -> DeviceGroupRenderPassBeginInfoBuilder<'a> { + self.inner.device_render_area_count = device_render_areas.len() as u32; + self.inner.p_device_render_areas = device_render_areas.as_ptr(); + self + } + pub fn build(self) -> DeviceGroupRenderPassBeginInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupCommandBufferBeginInfo { @@ -9142,6 +20014,33 @@ impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { } } } +impl DeviceGroupCommandBufferBeginInfo { + pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> { + DeviceGroupCommandBufferBeginInfoBuilder { + inner: DeviceGroupCommandBufferBeginInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> { + inner: DeviceGroupCommandBufferBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> { + type Target = DeviceGroupCommandBufferBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> { + pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupCommandBufferBeginInfoBuilder<'a> { + self.inner.device_mask = device_mask; + self + } + pub fn build(self) -> DeviceGroupCommandBufferBeginInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupSubmitInfo { @@ -9168,6 +20067,74 @@ impl ::std::default::Default for DeviceGroupSubmitInfo { } } } +impl DeviceGroupSubmitInfo { + pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> { + DeviceGroupSubmitInfoBuilder { + inner: DeviceGroupSubmitInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupSubmitInfoBuilder<'a> { + inner: DeviceGroupSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> { + type Target = DeviceGroupSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupSubmitInfoBuilder<'a> { + pub fn wait_semaphore_count( + mut self, + wait_semaphore_count: u32, + ) -> DeviceGroupSubmitInfoBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn wait_semaphore_device_indices( + mut self, + wait_semaphore_device_indices: &'a [u32], + ) -> DeviceGroupSubmitInfoBuilder<'a> { + self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as u32; + self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr(); + self + } + pub fn command_buffer_count( + mut self, + command_buffer_count: u32, + ) -> DeviceGroupSubmitInfoBuilder<'a> { + self.inner.command_buffer_count = command_buffer_count; + self + } + pub fn command_buffer_device_masks( + mut self, + command_buffer_device_masks: &'a [u32], + ) -> DeviceGroupSubmitInfoBuilder<'a> { + self.inner.command_buffer_count = command_buffer_device_masks.len() as u32; + self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr(); + self + } + pub fn signal_semaphore_count( + mut self, + signal_semaphore_count: u32, + ) -> DeviceGroupSubmitInfoBuilder<'a> { + self.inner.signal_semaphore_count = signal_semaphore_count; + self + } + pub fn signal_semaphore_device_indices( + mut self, + signal_semaphore_device_indices: &'a [u32], + ) -> DeviceGroupSubmitInfoBuilder<'a> { + self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as u32; + self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr(); + self + } + pub fn build(self) -> DeviceGroupSubmitInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupBindSparseInfo { @@ -9186,6 +20153,43 @@ impl ::std::default::Default for DeviceGroupBindSparseInfo { } } } +impl DeviceGroupBindSparseInfo { + pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> { + DeviceGroupBindSparseInfoBuilder { + inner: DeviceGroupBindSparseInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupBindSparseInfoBuilder<'a> { + inner: DeviceGroupBindSparseInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> { + type Target = DeviceGroupBindSparseInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupBindSparseInfoBuilder<'a> { + pub fn resource_device_index( + mut self, + resource_device_index: u32, + ) -> DeviceGroupBindSparseInfoBuilder<'a> { + self.inner.resource_device_index = resource_device_index; + self + } + pub fn memory_device_index( + mut self, + memory_device_index: u32, + ) -> DeviceGroupBindSparseInfoBuilder<'a> { + self.inner.memory_device_index = memory_device_index; + self + } + pub fn build(self) -> DeviceGroupBindSparseInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupPresentCapabilitiesKHR { @@ -9204,6 +20208,43 @@ impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { } } } +impl DeviceGroupPresentCapabilitiesKHR { + pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + DeviceGroupPresentCapabilitiesKHRBuilder { + inner: DeviceGroupPresentCapabilitiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + inner: DeviceGroupPresentCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + type Target = DeviceGroupPresentCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + pub fn present_mask( + mut self, + present_mask: [u32; MAX_DEVICE_GROUP_SIZE], + ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + self.inner.present_mask = present_mask; + self + } + pub fn modes( + mut self, + modes: DeviceGroupPresentModeFlagsKHR, + ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + self.inner.modes = modes; + self + } + pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageSwapchainCreateInfoKHR { @@ -9220,6 +20261,33 @@ impl ::std::default::Default for ImageSwapchainCreateInfoKHR { } } } +impl ImageSwapchainCreateInfoKHR { + pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> { + ImageSwapchainCreateInfoKHRBuilder { + inner: ImageSwapchainCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageSwapchainCreateInfoKHRBuilder<'a> { + inner: ImageSwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> { + type Target = ImageSwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> { + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> ImageSwapchainCreateInfoKHRBuilder<'a> { + self.inner.swapchain = swapchain; + self + } + pub fn build(self) -> ImageSwapchainCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImageMemorySwapchainInfoKHR { @@ -9238,6 +20306,40 @@ impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { } } } +impl BindImageMemorySwapchainInfoKHR { + pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> { + BindImageMemorySwapchainInfoKHRBuilder { + inner: BindImageMemorySwapchainInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> { + inner: BindImageMemorySwapchainInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> { + type Target = BindImageMemorySwapchainInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> { + pub fn swapchain( + mut self, + swapchain: SwapchainKHR, + ) -> BindImageMemorySwapchainInfoKHRBuilder<'a> { + self.inner.swapchain = swapchain; + self + } + pub fn image_index(mut self, image_index: u32) -> BindImageMemorySwapchainInfoKHRBuilder<'a> { + self.inner.image_index = image_index; + self + } + pub fn build(self) -> BindImageMemorySwapchainInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AcquireNextImageInfoKHR { @@ -9262,6 +20364,49 @@ impl ::std::default::Default for AcquireNextImageInfoKHR { } } } +impl AcquireNextImageInfoKHR { + pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> { + AcquireNextImageInfoKHRBuilder { + inner: AcquireNextImageInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AcquireNextImageInfoKHRBuilder<'a> { + inner: AcquireNextImageInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> { + type Target = AcquireNextImageInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AcquireNextImageInfoKHRBuilder<'a> { + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> AcquireNextImageInfoKHRBuilder<'a> { + self.inner.swapchain = swapchain; + self + } + pub fn timeout(mut self, timeout: u64) -> AcquireNextImageInfoKHRBuilder<'a> { + self.inner.timeout = timeout; + self + } + pub fn semaphore(mut self, semaphore: Semaphore) -> AcquireNextImageInfoKHRBuilder<'a> { + self.inner.semaphore = semaphore; + self + } + pub fn fence(mut self, fence: Fence) -> AcquireNextImageInfoKHRBuilder<'a> { + self.inner.fence = fence; + self + } + pub fn device_mask(mut self, device_mask: u32) -> AcquireNextImageInfoKHRBuilder<'a> { + self.inner.device_mask = device_mask; + self + } + pub fn build(self) -> AcquireNextImageInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupPresentInfoKHR { @@ -9282,6 +20427,45 @@ impl ::std::default::Default for DeviceGroupPresentInfoKHR { } } } +impl DeviceGroupPresentInfoKHR { + pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> { + DeviceGroupPresentInfoKHRBuilder { + inner: DeviceGroupPresentInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupPresentInfoKHRBuilder<'a> { + inner: DeviceGroupPresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> { + type Target = DeviceGroupPresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> DeviceGroupPresentInfoKHRBuilder<'a> { + self.inner.swapchain_count = swapchain_count; + self + } + pub fn device_masks(mut self, device_masks: &'a [u32]) -> DeviceGroupPresentInfoKHRBuilder<'a> { + self.inner.swapchain_count = device_masks.len() as u32; + self.inner.p_device_masks = device_masks.as_ptr(); + self + } + pub fn mode( + mut self, + mode: DeviceGroupPresentModeFlagsKHR, + ) -> DeviceGroupPresentInfoKHRBuilder<'a> { + self.inner.mode = mode; + self + } + pub fn build(self) -> DeviceGroupPresentInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupDeviceCreateInfo { @@ -9300,6 +20484,44 @@ impl ::std::default::Default for DeviceGroupDeviceCreateInfo { } } } +impl DeviceGroupDeviceCreateInfo { + pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> { + DeviceGroupDeviceCreateInfoBuilder { + inner: DeviceGroupDeviceCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupDeviceCreateInfoBuilder<'a> { + inner: DeviceGroupDeviceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> { + type Target = DeviceGroupDeviceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> { + pub fn physical_device_count( + mut self, + physical_device_count: u32, + ) -> DeviceGroupDeviceCreateInfoBuilder<'a> { + self.inner.physical_device_count = physical_device_count; + self + } + pub fn physical_devices( + mut self, + physical_devices: &'a [PhysicalDevice], + ) -> DeviceGroupDeviceCreateInfoBuilder<'a> { + self.inner.physical_device_count = physical_devices.len() as u32; + self.inner.p_physical_devices = physical_devices.as_ptr(); + self + } + pub fn build(self) -> DeviceGroupDeviceCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceGroupSwapchainCreateInfoKHR { @@ -9316,6 +20538,36 @@ impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR { } } } +impl DeviceGroupSwapchainCreateInfoKHR { + pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + DeviceGroupSwapchainCreateInfoKHRBuilder { + inner: DeviceGroupSwapchainCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + inner: DeviceGroupSwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + type Target = DeviceGroupSwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + pub fn modes( + mut self, + modes: DeviceGroupPresentModeFlagsKHR, + ) -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + self.inner.modes = modes; + self + } + pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct DescriptorUpdateTemplateEntry { @@ -9326,6 +20578,62 @@ pub struct DescriptorUpdateTemplateEntry { pub offset: usize, pub stride: usize, } +impl DescriptorUpdateTemplateEntry { + pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> { + DescriptorUpdateTemplateEntryBuilder { + inner: DescriptorUpdateTemplateEntry::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorUpdateTemplateEntryBuilder<'a> { + inner: DescriptorUpdateTemplateEntry, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> { + type Target = DescriptorUpdateTemplateEntry; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> { + pub fn dst_binding(mut self, dst_binding: u32) -> DescriptorUpdateTemplateEntryBuilder<'a> { + self.inner.dst_binding = dst_binding; + self + } + pub fn dst_array_element( + mut self, + dst_array_element: u32, + ) -> DescriptorUpdateTemplateEntryBuilder<'a> { + self.inner.dst_array_element = dst_array_element; + self + } + pub fn descriptor_count( + mut self, + descriptor_count: u32, + ) -> DescriptorUpdateTemplateEntryBuilder<'a> { + self.inner.descriptor_count = descriptor_count; + self + } + pub fn descriptor_type( + mut self, + descriptor_type: DescriptorType, + ) -> DescriptorUpdateTemplateEntryBuilder<'a> { + self.inner.descriptor_type = descriptor_type; + self + } + pub fn offset(mut self, offset: usize) -> DescriptorUpdateTemplateEntryBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn stride(mut self, stride: usize) -> DescriptorUpdateTemplateEntryBuilder<'a> { + self.inner.stride = stride; + self + } + pub fn build(self) -> DescriptorUpdateTemplateEntry { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorUpdateTemplateCreateInfo { @@ -9356,12 +20664,120 @@ impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { } } } +impl DescriptorUpdateTemplateCreateInfo { + pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + DescriptorUpdateTemplateCreateInfoBuilder { + inner: DescriptorUpdateTemplateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> { + inner: DescriptorUpdateTemplateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> { + type Target = DescriptorUpdateTemplateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + pub fn flags( + mut self, + flags: DescriptorUpdateTemplateCreateFlags, + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn descriptor_update_entry_count( + mut self, + descriptor_update_entry_count: u32, + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.descriptor_update_entry_count = descriptor_update_entry_count; + self + } + pub fn descriptor_update_entries( + mut self, + descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry], + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as u32; + self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr(); + self + } + pub fn template_type( + mut self, + template_type: DescriptorUpdateTemplateType, + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.template_type = template_type; + self + } + pub fn descriptor_set_layout( + mut self, + descriptor_set_layout: DescriptorSetLayout, + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.descriptor_set_layout = descriptor_set_layout; + self + } + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: PipelineBindPoint, + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn pipeline_layout( + mut self, + pipeline_layout: PipelineLayout, + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.pipeline_layout = pipeline_layout; + self + } + pub fn set(mut self, set: u32) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + self.inner.set = set; + self + } + pub fn build(self) -> DescriptorUpdateTemplateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct XYColorEXT { pub x: c_float, pub y: c_float, } +impl XYColorEXT { + pub fn builder<'a>() -> XYColorEXTBuilder<'a> { + XYColorEXTBuilder { + inner: XYColorEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct XYColorEXTBuilder<'a> { + inner: XYColorEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> { + type Target = XYColorEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> XYColorEXTBuilder<'a> { + pub fn x(mut self, x: c_float) -> XYColorEXTBuilder<'a> { + self.inner.x = x; + self + } + pub fn y(mut self, y: c_float) -> XYColorEXTBuilder<'a> { + self.inner.y = y; + self + } + pub fn build(self) -> XYColorEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct HdrMetadataEXT { @@ -9392,11 +20808,111 @@ impl ::std::default::Default for HdrMetadataEXT { } } } +impl HdrMetadataEXT { + pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> { + HdrMetadataEXTBuilder { + inner: HdrMetadataEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct HdrMetadataEXTBuilder<'a> { + inner: HdrMetadataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> { + type Target = HdrMetadataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> HdrMetadataEXTBuilder<'a> { + pub fn display_primary_red( + mut self, + display_primary_red: XYColorEXT, + ) -> HdrMetadataEXTBuilder<'a> { + self.inner.display_primary_red = display_primary_red; + self + } + pub fn display_primary_green( + mut self, + display_primary_green: XYColorEXT, + ) -> HdrMetadataEXTBuilder<'a> { + self.inner.display_primary_green = display_primary_green; + self + } + pub fn display_primary_blue( + mut self, + display_primary_blue: XYColorEXT, + ) -> HdrMetadataEXTBuilder<'a> { + self.inner.display_primary_blue = display_primary_blue; + self + } + pub fn white_point(mut self, white_point: XYColorEXT) -> HdrMetadataEXTBuilder<'a> { + self.inner.white_point = white_point; + self + } + pub fn max_luminance(mut self, max_luminance: c_float) -> HdrMetadataEXTBuilder<'a> { + self.inner.max_luminance = max_luminance; + self + } + pub fn min_luminance(mut self, min_luminance: c_float) -> HdrMetadataEXTBuilder<'a> { + self.inner.min_luminance = min_luminance; + self + } + pub fn max_content_light_level( + mut self, + max_content_light_level: c_float, + ) -> HdrMetadataEXTBuilder<'a> { + self.inner.max_content_light_level = max_content_light_level; + self + } + pub fn max_frame_average_light_level( + mut self, + max_frame_average_light_level: c_float, + ) -> HdrMetadataEXTBuilder<'a> { + self.inner.max_frame_average_light_level = max_frame_average_light_level; + self + } + pub fn build(self) -> HdrMetadataEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct RefreshCycleDurationGOOGLE { pub refresh_duration: u64, } +impl RefreshCycleDurationGOOGLE { + pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> { + RefreshCycleDurationGOOGLEBuilder { + inner: RefreshCycleDurationGOOGLE::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RefreshCycleDurationGOOGLEBuilder<'a> { + inner: RefreshCycleDurationGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> { + type Target = RefreshCycleDurationGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> { + pub fn refresh_duration( + mut self, + refresh_duration: u64, + ) -> RefreshCycleDurationGOOGLEBuilder<'a> { + self.inner.refresh_duration = refresh_duration; + self + } + pub fn build(self) -> RefreshCycleDurationGOOGLE { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PastPresentationTimingGOOGLE { @@ -9406,6 +20922,61 @@ pub struct PastPresentationTimingGOOGLE { pub earliest_present_time: u64, pub present_margin: u64, } +impl PastPresentationTimingGOOGLE { + pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> { + PastPresentationTimingGOOGLEBuilder { + inner: PastPresentationTimingGOOGLE::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PastPresentationTimingGOOGLEBuilder<'a> { + inner: PastPresentationTimingGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> { + type Target = PastPresentationTimingGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PastPresentationTimingGOOGLEBuilder<'a> { + pub fn present_id(mut self, present_id: u32) -> PastPresentationTimingGOOGLEBuilder<'a> { + self.inner.present_id = present_id; + self + } + pub fn desired_present_time( + mut self, + desired_present_time: u64, + ) -> PastPresentationTimingGOOGLEBuilder<'a> { + self.inner.desired_present_time = desired_present_time; + self + } + pub fn actual_present_time( + mut self, + actual_present_time: u64, + ) -> PastPresentationTimingGOOGLEBuilder<'a> { + self.inner.actual_present_time = actual_present_time; + self + } + pub fn earliest_present_time( + mut self, + earliest_present_time: u64, + ) -> PastPresentationTimingGOOGLEBuilder<'a> { + self.inner.earliest_present_time = earliest_present_time; + self + } + pub fn present_margin( + mut self, + present_margin: u64, + ) -> PastPresentationTimingGOOGLEBuilder<'a> { + self.inner.present_margin = present_margin; + self + } + pub fn build(self) -> PastPresentationTimingGOOGLE { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PresentTimesInfoGOOGLE { @@ -9424,12 +20995,78 @@ impl ::std::default::Default for PresentTimesInfoGOOGLE { } } } +impl PresentTimesInfoGOOGLE { + pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> { + PresentTimesInfoGOOGLEBuilder { + inner: PresentTimesInfoGOOGLE::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PresentTimesInfoGOOGLEBuilder<'a> { + inner: PresentTimesInfoGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> { + type Target = PresentTimesInfoGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PresentTimesInfoGOOGLEBuilder<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> PresentTimesInfoGOOGLEBuilder<'a> { + self.inner.swapchain_count = swapchain_count; + self + } + pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> PresentTimesInfoGOOGLEBuilder<'a> { + self.inner.swapchain_count = times.len() as u32; + self.inner.p_times = times.as_ptr(); + self + } + pub fn build(self) -> PresentTimesInfoGOOGLE { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct PresentTimeGOOGLE { pub present_id: u32, pub desired_present_time: u64, } +impl PresentTimeGOOGLE { + pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> { + PresentTimeGOOGLEBuilder { + inner: PresentTimeGOOGLE::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PresentTimeGOOGLEBuilder<'a> { + inner: PresentTimeGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> { + type Target = PresentTimeGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PresentTimeGOOGLEBuilder<'a> { + pub fn present_id(mut self, present_id: u32) -> PresentTimeGOOGLEBuilder<'a> { + self.inner.present_id = present_id; + self + } + pub fn desired_present_time( + mut self, + desired_present_time: u64, + ) -> PresentTimeGOOGLEBuilder<'a> { + self.inner.desired_present_time = desired_present_time; + self + } + pub fn build(self) -> PresentTimeGOOGLE { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct IOSSurfaceCreateInfoMVK { @@ -9448,6 +21085,37 @@ impl ::std::default::Default for IOSSurfaceCreateInfoMVK { } } } +impl IOSSurfaceCreateInfoMVK { + pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> { + IOSSurfaceCreateInfoMVKBuilder { + inner: IOSSurfaceCreateInfoMVK::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct IOSSurfaceCreateInfoMVKBuilder<'a> { + inner: IOSSurfaceCreateInfoMVK, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> { + type Target = IOSSurfaceCreateInfoMVK; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { + pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> IOSSurfaceCreateInfoMVKBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn view(mut self, view: *const c_void) -> IOSSurfaceCreateInfoMVKBuilder<'a> { + self.inner.p_view = view; + self + } + pub fn build(self) -> IOSSurfaceCreateInfoMVK { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MacOSSurfaceCreateInfoMVK { @@ -9466,12 +21134,77 @@ impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { } } } +impl MacOSSurfaceCreateInfoMVK { + pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + MacOSSurfaceCreateInfoMVKBuilder { + inner: MacOSSurfaceCreateInfoMVK::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { + inner: MacOSSurfaceCreateInfoMVK, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { + type Target = MacOSSurfaceCreateInfoMVK; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { + pub fn flags( + mut self, + flags: MacOSSurfaceCreateFlagsMVK, + ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn view(mut self, view: *const c_void) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + self.inner.p_view = view; + self + } + pub fn build(self) -> MacOSSurfaceCreateInfoMVK { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ViewportWScalingNV { pub xcoeff: c_float, pub ycoeff: c_float, } +impl ViewportWScalingNV { + pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> { + ViewportWScalingNVBuilder { + inner: ViewportWScalingNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ViewportWScalingNVBuilder<'a> { + inner: ViewportWScalingNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> { + type Target = ViewportWScalingNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ViewportWScalingNVBuilder<'a> { + pub fn xcoeff(mut self, xcoeff: c_float) -> ViewportWScalingNVBuilder<'a> { + self.inner.xcoeff = xcoeff; + self + } + pub fn ycoeff(mut self, ycoeff: c_float) -> ViewportWScalingNVBuilder<'a> { + self.inner.ycoeff = ycoeff; + self + } + pub fn build(self) -> ViewportWScalingNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineViewportWScalingStateCreateInfoNV { @@ -9492,6 +21225,51 @@ impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { } } } +impl PipelineViewportWScalingStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + PipelineViewportWScalingStateCreateInfoNVBuilder { + inner: PipelineViewportWScalingStateCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportWScalingStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportWScalingStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + pub fn viewport_w_scaling_enable( + mut self, + viewport_w_scaling_enable: Bool32, + ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable; + self + } + pub fn viewport_count( + mut self, + viewport_count: u32, + ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + self.inner.viewport_count = viewport_count; + self + } + pub fn viewport_w_scalings( + mut self, + viewport_w_scalings: &'a [ViewportWScalingNV], + ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + self.inner.viewport_count = viewport_w_scalings.len() as u32; + self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr(); + self + } + pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ViewportSwizzleNV { @@ -9500,6 +21278,45 @@ pub struct ViewportSwizzleNV { pub z: ViewportCoordinateSwizzleNV, pub w: ViewportCoordinateSwizzleNV, } +impl ViewportSwizzleNV { + pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> { + ViewportSwizzleNVBuilder { + inner: ViewportSwizzleNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ViewportSwizzleNVBuilder<'a> { + inner: ViewportSwizzleNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> { + type Target = ViewportSwizzleNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ViewportSwizzleNVBuilder<'a> { + pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> { + self.inner.x = x; + self + } + pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> { + self.inner.y = y; + self + } + pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> { + self.inner.z = z; + self + } + pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> { + self.inner.w = w; + self + } + pub fn build(self) -> ViewportSwizzleNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineViewportSwizzleStateCreateInfoNV { @@ -9520,6 +21337,51 @@ impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { } } } +impl PipelineViewportSwizzleStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + PipelineViewportSwizzleStateCreateInfoNVBuilder { + inner: PipelineViewportSwizzleStateCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportSwizzleStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportSwizzleStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineViewportSwizzleStateCreateFlagsNV, + ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn viewport_count( + mut self, + viewport_count: u32, + ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + self.inner.viewport_count = viewport_count; + self + } + pub fn viewport_swizzles( + mut self, + viewport_swizzles: &'a [ViewportSwizzleNV], + ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + self.inner.viewport_count = viewport_swizzles.len() as u32; + self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr(); + self + } + pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { @@ -9536,6 +21398,36 @@ impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { } } } +impl PhysicalDeviceDiscardRectanglePropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + PhysicalDeviceDiscardRectanglePropertiesEXTBuilder { + inner: PhysicalDeviceDiscardRectanglePropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDiscardRectanglePropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDiscardRectanglePropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + pub fn max_discard_rectangles( + mut self, + max_discard_rectangles: u32, + ) -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + self.inner.max_discard_rectangles = max_discard_rectangles; + self + } + pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineDiscardRectangleStateCreateInfoEXT { @@ -9558,6 +21450,58 @@ impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { } } } +impl PipelineDiscardRectangleStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + PipelineDiscardRectangleStateCreateInfoEXTBuilder { + inner: PipelineDiscardRectangleStateCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + inner: PipelineDiscardRectangleStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + type Target = PipelineDiscardRectangleStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineDiscardRectangleStateCreateFlagsEXT, + ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn discard_rectangle_mode( + mut self, + discard_rectangle_mode: DiscardRectangleModeEXT, + ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + self.inner.discard_rectangle_mode = discard_rectangle_mode; + self + } + pub fn discard_rectangle_count( + mut self, + discard_rectangle_count: u32, + ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + self.inner.discard_rectangle_count = discard_rectangle_count; + self + } + pub fn discard_rectangles( + mut self, + discard_rectangles: &'a [Rect2D], + ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + self.inner.discard_rectangle_count = discard_rectangles.len() as u32; + self.inner.p_discard_rectangles = discard_rectangles.as_ptr(); + self + } + pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { @@ -9574,6 +21518,36 @@ impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropert } } } +impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder { + inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + pub fn per_view_position_all_components( + mut self, + per_view_position_all_components: Bool32, + ) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + self.inner.per_view_position_all_components = per_view_position_all_components; + self + } + pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct InputAttachmentAspectReference { @@ -9581,6 +21555,47 @@ pub struct InputAttachmentAspectReference { pub input_attachment_index: u32, pub aspect_mask: ImageAspectFlags, } +impl InputAttachmentAspectReference { + pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> { + InputAttachmentAspectReferenceBuilder { + inner: InputAttachmentAspectReference::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct InputAttachmentAspectReferenceBuilder<'a> { + inner: InputAttachmentAspectReference, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> { + type Target = InputAttachmentAspectReference; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> InputAttachmentAspectReferenceBuilder<'a> { + pub fn subpass(mut self, subpass: u32) -> InputAttachmentAspectReferenceBuilder<'a> { + self.inner.subpass = subpass; + self + } + pub fn input_attachment_index( + mut self, + input_attachment_index: u32, + ) -> InputAttachmentAspectReferenceBuilder<'a> { + self.inner.input_attachment_index = input_attachment_index; + self + } + pub fn aspect_mask( + mut self, + aspect_mask: ImageAspectFlags, + ) -> InputAttachmentAspectReferenceBuilder<'a> { + self.inner.aspect_mask = aspect_mask; + self + } + pub fn build(self) -> InputAttachmentAspectReference { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct RenderPassInputAttachmentAspectCreateInfo { @@ -9599,6 +21614,44 @@ impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { } } } +impl RenderPassInputAttachmentAspectCreateInfo { + pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + RenderPassInputAttachmentAspectCreateInfoBuilder { + inner: RenderPassInputAttachmentAspectCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + inner: RenderPassInputAttachmentAspectCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + type Target = RenderPassInputAttachmentAspectCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + pub fn aspect_reference_count( + mut self, + aspect_reference_count: u32, + ) -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + self.inner.aspect_reference_count = aspect_reference_count; + self + } + pub fn aspect_references( + mut self, + aspect_references: &'a [InputAttachmentAspectReference], + ) -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + self.inner.aspect_reference_count = aspect_references.len() as u32; + self.inner.p_aspect_references = aspect_references.as_ptr(); + self + } + pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSurfaceInfo2KHR { @@ -9615,6 +21668,33 @@ impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR { } } } +impl PhysicalDeviceSurfaceInfo2KHR { + pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + PhysicalDeviceSurfaceInfo2KHRBuilder { + inner: PhysicalDeviceSurfaceInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + inner: PhysicalDeviceSurfaceInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + type Target = PhysicalDeviceSurfaceInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + pub fn surface(mut self, surface: SurfaceKHR) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + self.inner.surface = surface; + self + } + pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SurfaceCapabilities2KHR { @@ -9631,6 +21711,36 @@ impl ::std::default::Default for SurfaceCapabilities2KHR { } } } +impl SurfaceCapabilities2KHR { + pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> { + SurfaceCapabilities2KHRBuilder { + inner: SurfaceCapabilities2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SurfaceCapabilities2KHRBuilder<'a> { + inner: SurfaceCapabilities2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> { + type Target = SurfaceCapabilities2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SurfaceCapabilities2KHRBuilder<'a> { + pub fn surface_capabilities( + mut self, + surface_capabilities: SurfaceCapabilitiesKHR, + ) -> SurfaceCapabilities2KHRBuilder<'a> { + self.inner.surface_capabilities = surface_capabilities; + self + } + pub fn build(self) -> SurfaceCapabilities2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SurfaceFormat2KHR { @@ -9647,6 +21757,36 @@ impl ::std::default::Default for SurfaceFormat2KHR { } } } +impl SurfaceFormat2KHR { + pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> { + SurfaceFormat2KHRBuilder { + inner: SurfaceFormat2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SurfaceFormat2KHRBuilder<'a> { + inner: SurfaceFormat2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { + type Target = SurfaceFormat2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SurfaceFormat2KHRBuilder<'a> { + pub fn surface_format( + mut self, + surface_format: SurfaceFormatKHR, + ) -> SurfaceFormat2KHRBuilder<'a> { + self.inner.surface_format = surface_format; + self + } + pub fn build(self) -> SurfaceFormat2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayProperties2KHR { @@ -9663,6 +21803,36 @@ impl ::std::default::Default for DisplayProperties2KHR { } } } +impl DisplayProperties2KHR { + pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> { + DisplayProperties2KHRBuilder { + inner: DisplayProperties2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayProperties2KHRBuilder<'a> { + inner: DisplayProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> { + type Target = DisplayProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayProperties2KHRBuilder<'a> { + pub fn display_properties( + mut self, + display_properties: DisplayPropertiesKHR, + ) -> DisplayProperties2KHRBuilder<'a> { + self.inner.display_properties = display_properties; + self + } + pub fn build(self) -> DisplayProperties2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneProperties2KHR { @@ -9679,6 +21849,36 @@ impl ::std::default::Default for DisplayPlaneProperties2KHR { } } } +impl DisplayPlaneProperties2KHR { + pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> { + DisplayPlaneProperties2KHRBuilder { + inner: DisplayPlaneProperties2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPlaneProperties2KHRBuilder<'a> { + inner: DisplayPlaneProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> { + type Target = DisplayPlaneProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { + pub fn display_plane_properties( + mut self, + display_plane_properties: DisplayPlanePropertiesKHR, + ) -> DisplayPlaneProperties2KHRBuilder<'a> { + self.inner.display_plane_properties = display_plane_properties; + self + } + pub fn build(self) -> DisplayPlaneProperties2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayModeProperties2KHR { @@ -9695,6 +21895,36 @@ impl ::std::default::Default for DisplayModeProperties2KHR { } } } +impl DisplayModeProperties2KHR { + pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> { + DisplayModeProperties2KHRBuilder { + inner: DisplayModeProperties2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayModeProperties2KHRBuilder<'a> { + inner: DisplayModeProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> { + type Target = DisplayModeProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayModeProperties2KHRBuilder<'a> { + pub fn display_mode_properties( + mut self, + display_mode_properties: DisplayModePropertiesKHR, + ) -> DisplayModeProperties2KHRBuilder<'a> { + self.inner.display_mode_properties = display_mode_properties; + self + } + pub fn build(self) -> DisplayModeProperties2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneInfo2KHR { @@ -9713,6 +21943,37 @@ impl ::std::default::Default for DisplayPlaneInfo2KHR { } } } +impl DisplayPlaneInfo2KHR { + pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> { + DisplayPlaneInfo2KHRBuilder { + inner: DisplayPlaneInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPlaneInfo2KHRBuilder<'a> { + inner: DisplayPlaneInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> { + type Target = DisplayPlaneInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { + pub fn mode(mut self, mode: DisplayModeKHR) -> DisplayPlaneInfo2KHRBuilder<'a> { + self.inner.mode = mode; + self + } + pub fn plane_index(mut self, plane_index: u32) -> DisplayPlaneInfo2KHRBuilder<'a> { + self.inner.plane_index = plane_index; + self + } + pub fn build(self) -> DisplayPlaneInfo2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DisplayPlaneCapabilities2KHR { @@ -9729,6 +21990,36 @@ impl ::std::default::Default for DisplayPlaneCapabilities2KHR { } } } +impl DisplayPlaneCapabilities2KHR { + pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> { + DisplayPlaneCapabilities2KHRBuilder { + inner: DisplayPlaneCapabilities2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DisplayPlaneCapabilities2KHRBuilder<'a> { + inner: DisplayPlaneCapabilities2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> { + type Target = DisplayPlaneCapabilities2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { + pub fn capabilities( + mut self, + capabilities: DisplayPlaneCapabilitiesKHR, + ) -> DisplayPlaneCapabilities2KHRBuilder<'a> { + self.inner.capabilities = capabilities; + self + } + pub fn build(self) -> DisplayPlaneCapabilities2KHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SharedPresentSurfaceCapabilitiesKHR { @@ -9745,6 +22036,36 @@ impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { } } } +impl SharedPresentSurfaceCapabilitiesKHR { + pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + SharedPresentSurfaceCapabilitiesKHRBuilder { + inner: SharedPresentSurfaceCapabilitiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + inner: SharedPresentSurfaceCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + type Target = SharedPresentSurfaceCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + pub fn shared_present_supported_usage_flags( + mut self, + shared_present_supported_usage_flags: ImageUsageFlags, + ) -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags; + self + } + pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDevice16BitStorageFeatures { @@ -9767,6 +22088,58 @@ impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { } } } +impl PhysicalDevice16BitStorageFeatures { + pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + PhysicalDevice16BitStorageFeaturesBuilder { + inner: PhysicalDevice16BitStorageFeatures::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> { + inner: PhysicalDevice16BitStorageFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> { + type Target = PhysicalDevice16BitStorageFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + pub fn storage_buffer16_bit_access( + mut self, + storage_buffer16_bit_access: Bool32, + ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access; + self + } + pub fn uniform_and_storage_buffer16_bit_access( + mut self, + uniform_and_storage_buffer16_bit_access: Bool32, + ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + self.inner.uniform_and_storage_buffer16_bit_access = + uniform_and_storage_buffer16_bit_access; + self + } + pub fn storage_push_constant16( + mut self, + storage_push_constant16: Bool32, + ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + self.inner.storage_push_constant16 = storage_push_constant16; + self + } + pub fn storage_input_output16( + mut self, + storage_input_output16: Bool32, + ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + self.inner.storage_input_output16 = storage_input_output16; + self + } + pub fn build(self) -> PhysicalDevice16BitStorageFeatures { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSubgroupProperties { @@ -9789,6 +22162,57 @@ impl ::std::default::Default for PhysicalDeviceSubgroupProperties { } } } +impl PhysicalDeviceSubgroupProperties { + pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + PhysicalDeviceSubgroupPropertiesBuilder { + inner: PhysicalDeviceSubgroupProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> { + inner: PhysicalDeviceSubgroupProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> { + type Target = PhysicalDeviceSubgroupProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + pub fn subgroup_size( + mut self, + subgroup_size: u32, + ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + self.inner.subgroup_size = subgroup_size; + self + } + pub fn supported_stages( + mut self, + supported_stages: ShaderStageFlags, + ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + self.inner.supported_stages = supported_stages; + self + } + pub fn supported_operations( + mut self, + supported_operations: SubgroupFeatureFlags, + ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + self.inner.supported_operations = supported_operations; + self + } + pub fn quad_operations_in_all_stages( + mut self, + quad_operations_in_all_stages: Bool32, + ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages; + self + } + pub fn build(self) -> PhysicalDeviceSubgroupProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BufferMemoryRequirementsInfo2 { @@ -9805,6 +22229,33 @@ impl ::std::default::Default for BufferMemoryRequirementsInfo2 { } } } +impl BufferMemoryRequirementsInfo2 { + pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> { + BufferMemoryRequirementsInfo2Builder { + inner: BufferMemoryRequirementsInfo2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferMemoryRequirementsInfo2Builder<'a> { + inner: BufferMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> { + type Target = BufferMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { + pub fn buffer(mut self, buffer: Buffer) -> BufferMemoryRequirementsInfo2Builder<'a> { + self.inner.buffer = buffer; + self + } + pub fn build(self) -> BufferMemoryRequirementsInfo2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageMemoryRequirementsInfo2 { @@ -9821,6 +22272,33 @@ impl ::std::default::Default for ImageMemoryRequirementsInfo2 { } } } +impl ImageMemoryRequirementsInfo2 { + pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> { + ImageMemoryRequirementsInfo2Builder { + inner: ImageMemoryRequirementsInfo2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageMemoryRequirementsInfo2Builder<'a> { + inner: ImageMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> { + type Target = ImageMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { + pub fn image(mut self, image: Image) -> ImageMemoryRequirementsInfo2Builder<'a> { + self.inner.image = image; + self + } + pub fn build(self) -> ImageMemoryRequirementsInfo2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageSparseMemoryRequirementsInfo2 { @@ -9837,6 +22315,33 @@ impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 { } } } +impl ImageSparseMemoryRequirementsInfo2 { + pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> { + ImageSparseMemoryRequirementsInfo2Builder { + inner: ImageSparseMemoryRequirementsInfo2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> { + inner: ImageSparseMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> { + type Target = ImageSparseMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { + pub fn image(mut self, image: Image) -> ImageSparseMemoryRequirementsInfo2Builder<'a> { + self.inner.image = image; + self + } + pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryRequirements2 { @@ -9853,6 +22358,36 @@ impl ::std::default::Default for MemoryRequirements2 { } } } +impl MemoryRequirements2 { + pub fn builder<'a>() -> MemoryRequirements2Builder<'a> { + MemoryRequirements2Builder { + inner: MemoryRequirements2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryRequirements2Builder<'a> { + inner: MemoryRequirements2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> { + type Target = MemoryRequirements2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryRequirements2Builder<'a> { + pub fn memory_requirements( + mut self, + memory_requirements: MemoryRequirements, + ) -> MemoryRequirements2Builder<'a> { + self.inner.memory_requirements = memory_requirements; + self + } + pub fn build(self) -> MemoryRequirements2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SparseImageMemoryRequirements2 { @@ -9869,6 +22404,36 @@ impl ::std::default::Default for SparseImageMemoryRequirements2 { } } } +impl SparseImageMemoryRequirements2 { + pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> { + SparseImageMemoryRequirements2Builder { + inner: SparseImageMemoryRequirements2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SparseImageMemoryRequirements2Builder<'a> { + inner: SparseImageMemoryRequirements2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> { + type Target = SparseImageMemoryRequirements2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SparseImageMemoryRequirements2Builder<'a> { + pub fn memory_requirements( + mut self, + memory_requirements: SparseImageMemoryRequirements, + ) -> SparseImageMemoryRequirements2Builder<'a> { + self.inner.memory_requirements = memory_requirements; + self + } + pub fn build(self) -> SparseImageMemoryRequirements2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDevicePointClippingProperties { @@ -9885,6 +22450,36 @@ impl ::std::default::Default for PhysicalDevicePointClippingProperties { } } } +impl PhysicalDevicePointClippingProperties { + pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> { + PhysicalDevicePointClippingPropertiesBuilder { + inner: PhysicalDevicePointClippingProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> { + inner: PhysicalDevicePointClippingProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> { + type Target = PhysicalDevicePointClippingProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> { + pub fn point_clipping_behavior( + mut self, + point_clipping_behavior: PointClippingBehavior, + ) -> PhysicalDevicePointClippingPropertiesBuilder<'a> { + self.inner.point_clipping_behavior = point_clipping_behavior; + self + } + pub fn build(self) -> PhysicalDevicePointClippingProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedRequirements { @@ -9903,6 +22498,43 @@ impl ::std::default::Default for MemoryDedicatedRequirements { } } } +impl MemoryDedicatedRequirements { + pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> { + MemoryDedicatedRequirementsBuilder { + inner: MemoryDedicatedRequirements::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryDedicatedRequirementsBuilder<'a> { + inner: MemoryDedicatedRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> { + type Target = MemoryDedicatedRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryDedicatedRequirementsBuilder<'a> { + pub fn prefers_dedicated_allocation( + mut self, + prefers_dedicated_allocation: Bool32, + ) -> MemoryDedicatedRequirementsBuilder<'a> { + self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation; + self + } + pub fn requires_dedicated_allocation( + mut self, + requires_dedicated_allocation: Bool32, + ) -> MemoryDedicatedRequirementsBuilder<'a> { + self.inner.requires_dedicated_allocation = requires_dedicated_allocation; + self + } + pub fn build(self) -> MemoryDedicatedRequirements { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryDedicatedAllocateInfo { @@ -9921,6 +22553,37 @@ impl ::std::default::Default for MemoryDedicatedAllocateInfo { } } } +impl MemoryDedicatedAllocateInfo { + pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> { + MemoryDedicatedAllocateInfoBuilder { + inner: MemoryDedicatedAllocateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryDedicatedAllocateInfoBuilder<'a> { + inner: MemoryDedicatedAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> { + type Target = MemoryDedicatedAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> { + pub fn image(mut self, image: Image) -> MemoryDedicatedAllocateInfoBuilder<'a> { + self.inner.image = image; + self + } + pub fn buffer(mut self, buffer: Buffer) -> MemoryDedicatedAllocateInfoBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn build(self) -> MemoryDedicatedAllocateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageViewUsageCreateInfo { @@ -9937,6 +22600,33 @@ impl ::std::default::Default for ImageViewUsageCreateInfo { } } } +impl ImageViewUsageCreateInfo { + pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> { + ImageViewUsageCreateInfoBuilder { + inner: ImageViewUsageCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageViewUsageCreateInfoBuilder<'a> { + inner: ImageViewUsageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> { + type Target = ImageViewUsageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageViewUsageCreateInfoBuilder<'a> { + pub fn usage(mut self, usage: ImageUsageFlags) -> ImageViewUsageCreateInfoBuilder<'a> { + self.inner.usage = usage; + self + } + pub fn build(self) -> ImageViewUsageCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineTessellationDomainOriginStateCreateInfo { @@ -9953,6 +22643,36 @@ impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo } } } +impl PipelineTessellationDomainOriginStateCreateInfo { + pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + PipelineTessellationDomainOriginStateCreateInfoBuilder { + inner: PipelineTessellationDomainOriginStateCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + inner: PipelineTessellationDomainOriginStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + type Target = PipelineTessellationDomainOriginStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + pub fn domain_origin( + mut self, + domain_origin: TessellationDomainOrigin, + ) -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + self.inner.domain_origin = domain_origin; + self + } + pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionInfo { @@ -9969,6 +22689,36 @@ impl ::std::default::Default for SamplerYcbcrConversionInfo { } } } +impl SamplerYcbcrConversionInfo { + pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> { + SamplerYcbcrConversionInfoBuilder { + inner: SamplerYcbcrConversionInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SamplerYcbcrConversionInfoBuilder<'a> { + inner: SamplerYcbcrConversionInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> { + type Target = SamplerYcbcrConversionInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SamplerYcbcrConversionInfoBuilder<'a> { + pub fn conversion( + mut self, + conversion: SamplerYcbcrConversion, + ) -> SamplerYcbcrConversionInfoBuilder<'a> { + self.inner.conversion = conversion; + self + } + pub fn build(self) -> SamplerYcbcrConversionInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionCreateInfo { @@ -9999,6 +22749,82 @@ impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { } } } +impl SamplerYcbcrConversionCreateInfo { + pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + SamplerYcbcrConversionCreateInfoBuilder { + inner: SamplerYcbcrConversionCreateInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> { + inner: SamplerYcbcrConversionCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> { + type Target = SamplerYcbcrConversionCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { + pub fn format(mut self, format: Format) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.format = format; + self + } + pub fn ycbcr_model( + mut self, + ycbcr_model: SamplerYcbcrModelConversion, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.ycbcr_model = ycbcr_model; + self + } + pub fn ycbcr_range( + mut self, + ycbcr_range: SamplerYcbcrRange, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.ycbcr_range = ycbcr_range; + self + } + pub fn components( + mut self, + components: ComponentMapping, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.components = components; + self + } + pub fn x_chroma_offset( + mut self, + x_chroma_offset: ChromaLocation, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.x_chroma_offset = x_chroma_offset; + self + } + pub fn y_chroma_offset( + mut self, + y_chroma_offset: ChromaLocation, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.y_chroma_offset = y_chroma_offset; + self + } + pub fn chroma_filter( + mut self, + chroma_filter: Filter, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.chroma_filter = chroma_filter; + self + } + pub fn force_explicit_reconstruction( + mut self, + force_explicit_reconstruction: Bool32, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + self.inner.force_explicit_reconstruction = force_explicit_reconstruction; + self + } + pub fn build(self) -> SamplerYcbcrConversionCreateInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct BindImagePlaneMemoryInfo { @@ -10015,6 +22841,36 @@ impl ::std::default::Default for BindImagePlaneMemoryInfo { } } } +impl BindImagePlaneMemoryInfo { + pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> { + BindImagePlaneMemoryInfoBuilder { + inner: BindImagePlaneMemoryInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BindImagePlaneMemoryInfoBuilder<'a> { + inner: BindImagePlaneMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> { + type Target = BindImagePlaneMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BindImagePlaneMemoryInfoBuilder<'a> { + pub fn plane_aspect( + mut self, + plane_aspect: ImageAspectFlags, + ) -> BindImagePlaneMemoryInfoBuilder<'a> { + self.inner.plane_aspect = plane_aspect; + self + } + pub fn build(self) -> BindImagePlaneMemoryInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImagePlaneMemoryRequirementsInfo { @@ -10031,6 +22887,36 @@ impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo { } } } +impl ImagePlaneMemoryRequirementsInfo { + pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> { + ImagePlaneMemoryRequirementsInfoBuilder { + inner: ImagePlaneMemoryRequirementsInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> { + inner: ImagePlaneMemoryRequirementsInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> { + type Target = ImagePlaneMemoryRequirementsInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> { + pub fn plane_aspect( + mut self, + plane_aspect: ImageAspectFlags, + ) -> ImagePlaneMemoryRequirementsInfoBuilder<'a> { + self.inner.plane_aspect = plane_aspect; + self + } + pub fn build(self) -> ImagePlaneMemoryRequirementsInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { @@ -10047,6 +22933,36 @@ impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { } } } +impl PhysicalDeviceSamplerYcbcrConversionFeatures { + pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder { + inner: PhysicalDeviceSamplerYcbcrConversionFeatures::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + inner: PhysicalDeviceSamplerYcbcrConversionFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + type Target = PhysicalDeviceSamplerYcbcrConversionFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + pub fn sampler_ycbcr_conversion( + mut self, + sampler_ycbcr_conversion: Bool32, + ) -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion; + self + } + pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerYcbcrConversionImageFormatProperties { @@ -10063,6 +22979,37 @@ impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { } } } +impl SamplerYcbcrConversionImageFormatProperties { + pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + SamplerYcbcrConversionImageFormatPropertiesBuilder { + inner: SamplerYcbcrConversionImageFormatProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + inner: SamplerYcbcrConversionImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + type Target = SamplerYcbcrConversionImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + pub fn combined_image_sampler_descriptor_count( + mut self, + combined_image_sampler_descriptor_count: u32, + ) -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + self.inner.combined_image_sampler_descriptor_count = + combined_image_sampler_descriptor_count; + self + } + pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct TextureLODGatherFormatPropertiesAMD { @@ -10079,6 +23026,36 @@ impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD { } } } +impl TextureLODGatherFormatPropertiesAMD { + pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> { + TextureLODGatherFormatPropertiesAMDBuilder { + inner: TextureLODGatherFormatPropertiesAMD::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> { + inner: TextureLODGatherFormatPropertiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> { + type Target = TextureLODGatherFormatPropertiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> { + pub fn supports_texture_gather_lod_bias_amd( + mut self, + supports_texture_gather_lod_bias_amd: Bool32, + ) -> TextureLODGatherFormatPropertiesAMDBuilder<'a> { + self.inner.supports_texture_gather_lod_bias_amd = supports_texture_gather_lod_bias_amd; + self + } + pub fn build(self) -> TextureLODGatherFormatPropertiesAMD { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ProtectedSubmitInfo { @@ -10095,6 +23072,33 @@ impl ::std::default::Default for ProtectedSubmitInfo { } } } +impl ProtectedSubmitInfo { + pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> { + ProtectedSubmitInfoBuilder { + inner: ProtectedSubmitInfo::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ProtectedSubmitInfoBuilder<'a> { + inner: ProtectedSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> { + type Target = ProtectedSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ProtectedSubmitInfoBuilder<'a> { + pub fn protected_submit(mut self, protected_submit: Bool32) -> ProtectedSubmitInfoBuilder<'a> { + self.inner.protected_submit = protected_submit; + self + } + pub fn build(self) -> ProtectedSubmitInfo { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryFeatures { @@ -10111,6 +23115,36 @@ impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { } } } +impl PhysicalDeviceProtectedMemoryFeatures { + pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + PhysicalDeviceProtectedMemoryFeaturesBuilder { + inner: PhysicalDeviceProtectedMemoryFeatures::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + inner: PhysicalDeviceProtectedMemoryFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + type Target = PhysicalDeviceProtectedMemoryFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + pub fn protected_memory( + mut self, + protected_memory: Bool32, + ) -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + self.inner.protected_memory = protected_memory; + self + } + pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceProtectedMemoryProperties { @@ -10127,6 +23161,36 @@ impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties { } } } +impl PhysicalDeviceProtectedMemoryProperties { + pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + PhysicalDeviceProtectedMemoryPropertiesBuilder { + inner: PhysicalDeviceProtectedMemoryProperties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + inner: PhysicalDeviceProtectedMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + type Target = PhysicalDeviceProtectedMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + pub fn protected_no_fault( + mut self, + protected_no_fault: Bool32, + ) -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + self.inner.protected_no_fault = protected_no_fault; + self + } + pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceQueueInfo2 { @@ -10147,6 +23211,41 @@ impl ::std::default::Default for DeviceQueueInfo2 { } } } +impl DeviceQueueInfo2 { + pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> { + DeviceQueueInfo2Builder { + inner: DeviceQueueInfo2::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceQueueInfo2Builder<'a> { + inner: DeviceQueueInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> { + type Target = DeviceQueueInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceQueueInfo2Builder<'a> { + pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueInfo2Builder<'a> { + self.inner.flags = flags; + self + } + pub fn queue_family_index(mut self, queue_family_index: u32) -> DeviceQueueInfo2Builder<'a> { + self.inner.queue_family_index = queue_family_index; + self + } + pub fn queue_index(mut self, queue_index: u32) -> DeviceQueueInfo2Builder<'a> { + self.inner.queue_index = queue_index; + self + } + pub fn build(self) -> DeviceQueueInfo2 { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineCoverageToColorStateCreateInfoNV { @@ -10167,6 +23266,50 @@ impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { } } } +impl PipelineCoverageToColorStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + PipelineCoverageToColorStateCreateInfoNVBuilder { + inner: PipelineCoverageToColorStateCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageToColorStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageToColorStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineCoverageToColorStateCreateFlagsNV, + ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn coverage_to_color_enable( + mut self, + coverage_to_color_enable: Bool32, + ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + self.inner.coverage_to_color_enable = coverage_to_color_enable; + self + } + pub fn coverage_to_color_location( + mut self, + coverage_to_color_location: u32, + ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + self.inner.coverage_to_color_location = coverage_to_color_location; + self + } + pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { @@ -10185,12 +23328,80 @@ impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT } } } +impl PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { + PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder { + inner: PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceSamplerFilterMinmaxPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { + pub fn filter_minmax_single_component_formats( + mut self, + filter_minmax_single_component_formats: Bool32, + ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { + self.inner.filter_minmax_single_component_formats = filter_minmax_single_component_formats; + self + } + pub fn filter_minmax_image_component_mapping( + mut self, + filter_minmax_image_component_mapping: Bool32, + ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { + self.inner.filter_minmax_image_component_mapping = filter_minmax_image_component_mapping; + self + } + pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SampleLocationEXT { pub x: c_float, pub y: c_float, } +impl SampleLocationEXT { + pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> { + SampleLocationEXTBuilder { + inner: SampleLocationEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SampleLocationEXTBuilder<'a> { + inner: SampleLocationEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> { + type Target = SampleLocationEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SampleLocationEXTBuilder<'a> { + pub fn x(mut self, x: c_float) -> SampleLocationEXTBuilder<'a> { + self.inner.x = x; + self + } + pub fn y(mut self, y: c_float) -> SampleLocationEXTBuilder<'a> { + self.inner.y = y; + self + } + pub fn build(self) -> SampleLocationEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SampleLocationsInfoEXT { @@ -10213,18 +23424,141 @@ impl ::std::default::Default for SampleLocationsInfoEXT { } } } +impl SampleLocationsInfoEXT { + pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> { + SampleLocationsInfoEXTBuilder { + inner: SampleLocationsInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SampleLocationsInfoEXTBuilder<'a> { + inner: SampleLocationsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> { + type Target = SampleLocationsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SampleLocationsInfoEXTBuilder<'a> { + pub fn sample_locations_per_pixel( + mut self, + sample_locations_per_pixel: SampleCountFlags, + ) -> SampleLocationsInfoEXTBuilder<'a> { + self.inner.sample_locations_per_pixel = sample_locations_per_pixel; + self + } + pub fn sample_location_grid_size( + mut self, + sample_location_grid_size: Extent2D, + ) -> SampleLocationsInfoEXTBuilder<'a> { + self.inner.sample_location_grid_size = sample_location_grid_size; + self + } + pub fn sample_locations_count( + mut self, + sample_locations_count: u32, + ) -> SampleLocationsInfoEXTBuilder<'a> { + self.inner.sample_locations_count = sample_locations_count; + self + } + pub fn sample_locations( + mut self, + sample_locations: &'a [SampleLocationEXT], + ) -> SampleLocationsInfoEXTBuilder<'a> { + self.inner.sample_locations_count = sample_locations.len() as u32; + self.inner.p_sample_locations = sample_locations.as_ptr(); + self + } + pub fn build(self) -> SampleLocationsInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct AttachmentSampleLocationsEXT { pub attachment_index: u32, pub sample_locations_info: SampleLocationsInfoEXT, } +impl AttachmentSampleLocationsEXT { + pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> { + AttachmentSampleLocationsEXTBuilder { + inner: AttachmentSampleLocationsEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AttachmentSampleLocationsEXTBuilder<'a> { + inner: AttachmentSampleLocationsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> { + type Target = AttachmentSampleLocationsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AttachmentSampleLocationsEXTBuilder<'a> { + pub fn attachment_index( + mut self, + attachment_index: u32, + ) -> AttachmentSampleLocationsEXTBuilder<'a> { + self.inner.attachment_index = attachment_index; + self + } + pub fn sample_locations_info( + mut self, + sample_locations_info: SampleLocationsInfoEXT, + ) -> AttachmentSampleLocationsEXTBuilder<'a> { + self.inner.sample_locations_info = sample_locations_info; + self + } + pub fn build(self) -> AttachmentSampleLocationsEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct SubpassSampleLocationsEXT { pub subpass_index: u32, pub sample_locations_info: SampleLocationsInfoEXT, } +impl SubpassSampleLocationsEXT { + pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> { + SubpassSampleLocationsEXTBuilder { + inner: SubpassSampleLocationsEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SubpassSampleLocationsEXTBuilder<'a> { + inner: SubpassSampleLocationsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> { + type Target = SubpassSampleLocationsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SubpassSampleLocationsEXTBuilder<'a> { + pub fn subpass_index(mut self, subpass_index: u32) -> SubpassSampleLocationsEXTBuilder<'a> { + self.inner.subpass_index = subpass_index; + self + } + pub fn sample_locations_info( + mut self, + sample_locations_info: SampleLocationsInfoEXT, + ) -> SubpassSampleLocationsEXTBuilder<'a> { + self.inner.sample_locations_info = sample_locations_info; + self + } + pub fn build(self) -> SubpassSampleLocationsEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct RenderPassSampleLocationsBeginInfoEXT { @@ -10247,6 +23581,62 @@ impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { } } } +impl RenderPassSampleLocationsBeginInfoEXT { + pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + RenderPassSampleLocationsBeginInfoEXTBuilder { + inner: RenderPassSampleLocationsBeginInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + inner: RenderPassSampleLocationsBeginInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + type Target = RenderPassSampleLocationsBeginInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + pub fn attachment_initial_sample_locations_count( + mut self, + attachment_initial_sample_locations_count: u32, + ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + self.inner.attachment_initial_sample_locations_count = + attachment_initial_sample_locations_count; + self + } + pub fn attachment_initial_sample_locations( + mut self, + attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT], + ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + self.inner.attachment_initial_sample_locations_count = + attachment_initial_sample_locations.len() as u32; + self.inner.p_attachment_initial_sample_locations = + attachment_initial_sample_locations.as_ptr(); + self + } + pub fn post_subpass_sample_locations_count( + mut self, + post_subpass_sample_locations_count: u32, + ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations_count; + self + } + pub fn post_subpass_sample_locations( + mut self, + post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT], + ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as u32; + self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr(); + self + } + pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineSampleLocationsStateCreateInfoEXT { @@ -10265,6 +23655,43 @@ impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { } } } +impl PipelineSampleLocationsStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + PipelineSampleLocationsStateCreateInfoEXTBuilder { + inner: PipelineSampleLocationsStateCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + inner: PipelineSampleLocationsStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + type Target = PipelineSampleLocationsStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + pub fn sample_locations_enable( + mut self, + sample_locations_enable: Bool32, + ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + self.inner.sample_locations_enable = sample_locations_enable; + self + } + pub fn sample_locations_info( + mut self, + sample_locations_info: SampleLocationsInfoEXT, + ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + self.inner.sample_locations_info = sample_locations_info; + self + } + pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceSampleLocationsPropertiesEXT { @@ -10289,6 +23716,64 @@ impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { } } } +impl PhysicalDeviceSampleLocationsPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + PhysicalDeviceSampleLocationsPropertiesEXTBuilder { + inner: PhysicalDeviceSampleLocationsPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceSampleLocationsPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceSampleLocationsPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + pub fn sample_location_sample_counts( + mut self, + sample_location_sample_counts: SampleCountFlags, + ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + self.inner.sample_location_sample_counts = sample_location_sample_counts; + self + } + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: Extent2D, + ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + pub fn sample_location_coordinate_range( + mut self, + sample_location_coordinate_range: [c_float; 2], + ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + self.inner.sample_location_coordinate_range = sample_location_coordinate_range; + self + } + pub fn sample_location_sub_pixel_bits( + mut self, + sample_location_sub_pixel_bits: u32, + ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits; + self + } + pub fn variable_sample_locations( + mut self, + variable_sample_locations: Bool32, + ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + self.inner.variable_sample_locations = variable_sample_locations; + self + } + pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MultisamplePropertiesEXT { @@ -10305,6 +23790,36 @@ impl ::std::default::Default for MultisamplePropertiesEXT { } } } +impl MultisamplePropertiesEXT { + pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> { + MultisamplePropertiesEXTBuilder { + inner: MultisamplePropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MultisamplePropertiesEXTBuilder<'a> { + inner: MultisamplePropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> { + type Target = MultisamplePropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MultisamplePropertiesEXTBuilder<'a> { + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: Extent2D, + ) -> MultisamplePropertiesEXTBuilder<'a> { + self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + pub fn build(self) -> MultisamplePropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct SamplerReductionModeCreateInfoEXT { @@ -10321,6 +23836,36 @@ impl ::std::default::Default for SamplerReductionModeCreateInfoEXT { } } } +impl SamplerReductionModeCreateInfoEXT { + pub fn builder<'a>() -> SamplerReductionModeCreateInfoEXTBuilder<'a> { + SamplerReductionModeCreateInfoEXTBuilder { + inner: SamplerReductionModeCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SamplerReductionModeCreateInfoEXTBuilder<'a> { + inner: SamplerReductionModeCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoEXTBuilder<'a> { + type Target = SamplerReductionModeCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SamplerReductionModeCreateInfoEXTBuilder<'a> { + pub fn reduction_mode( + mut self, + reduction_mode: SamplerReductionModeEXT, + ) -> SamplerReductionModeCreateInfoEXTBuilder<'a> { + self.inner.reduction_mode = reduction_mode; + self + } + pub fn build(self) -> SamplerReductionModeCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { @@ -10337,6 +23882,36 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT } } } +impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder { + inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + pub fn advanced_blend_coherent_operations( + mut self, + advanced_blend_coherent_operations: Bool32, + ) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations; + self + } + pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { @@ -10363,6 +23938,73 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesE } } } +impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder { + inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + pub fn advanced_blend_max_color_attachments( + mut self, + advanced_blend_max_color_attachments: u32, + ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments; + self + } + pub fn advanced_blend_independent_blend( + mut self, + advanced_blend_independent_blend: Bool32, + ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend; + self + } + pub fn advanced_blend_non_premultiplied_src_color( + mut self, + advanced_blend_non_premultiplied_src_color: Bool32, + ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + self.inner.advanced_blend_non_premultiplied_src_color = + advanced_blend_non_premultiplied_src_color; + self + } + pub fn advanced_blend_non_premultiplied_dst_color( + mut self, + advanced_blend_non_premultiplied_dst_color: Bool32, + ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + self.inner.advanced_blend_non_premultiplied_dst_color = + advanced_blend_non_premultiplied_dst_color; + self + } + pub fn advanced_blend_correlated_overlap( + mut self, + advanced_blend_correlated_overlap: Bool32, + ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap; + self + } + pub fn advanced_blend_all_operations( + mut self, + advanced_blend_all_operations: Bool32, + ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + self.inner.advanced_blend_all_operations = advanced_blend_all_operations; + self + } + pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { @@ -10383,6 +24025,50 @@ impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT { } } } +impl PipelineColorBlendAdvancedStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + PipelineColorBlendAdvancedStateCreateInfoEXTBuilder { + inner: PipelineColorBlendAdvancedStateCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + inner: PipelineColorBlendAdvancedStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + type Target = PipelineColorBlendAdvancedStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + pub fn src_premultiplied( + mut self, + src_premultiplied: Bool32, + ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + self.inner.src_premultiplied = src_premultiplied; + self + } + pub fn dst_premultiplied( + mut self, + dst_premultiplied: Bool32, + ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + self.inner.dst_premultiplied = dst_premultiplied; + self + } + pub fn blend_overlap( + mut self, + blend_overlap: BlendOverlapEXT, + ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + self.inner.blend_overlap = blend_overlap; + self + } + pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineCoverageModulationStateCreateInfoNV { @@ -10407,6 +24093,65 @@ impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { } } } +impl PipelineCoverageModulationStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + PipelineCoverageModulationStateCreateInfoNVBuilder { + inner: PipelineCoverageModulationStateCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageModulationStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageModulationStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineCoverageModulationStateCreateFlagsNV, + ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn coverage_modulation_mode( + mut self, + coverage_modulation_mode: CoverageModulationModeNV, + ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + self.inner.coverage_modulation_mode = coverage_modulation_mode; + self + } + pub fn coverage_modulation_table_enable( + mut self, + coverage_modulation_table_enable: Bool32, + ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable; + self + } + pub fn coverage_modulation_table_count( + mut self, + coverage_modulation_table_count: u32, + ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + self.inner.coverage_modulation_table_count = coverage_modulation_table_count; + self + } + pub fn coverage_modulation_table( + mut self, + coverage_modulation_table: &'a [c_float], + ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as u32; + self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr(); + self + } + pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImageFormatListCreateInfoKHR { @@ -10425,6 +24170,44 @@ impl ::std::default::Default for ImageFormatListCreateInfoKHR { } } } +impl ImageFormatListCreateInfoKHR { + pub fn builder<'a>() -> ImageFormatListCreateInfoKHRBuilder<'a> { + ImageFormatListCreateInfoKHRBuilder { + inner: ImageFormatListCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImageFormatListCreateInfoKHRBuilder<'a> { + inner: ImageFormatListCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoKHRBuilder<'a> { + type Target = ImageFormatListCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImageFormatListCreateInfoKHRBuilder<'a> { + pub fn view_format_count( + mut self, + view_format_count: u32, + ) -> ImageFormatListCreateInfoKHRBuilder<'a> { + self.inner.view_format_count = view_format_count; + self + } + pub fn view_formats( + mut self, + view_formats: &'a [Format], + ) -> ImageFormatListCreateInfoKHRBuilder<'a> { + self.inner.view_format_count = view_formats.len() as u32; + self.inner.p_view_formats = view_formats.as_ptr(); + self + } + pub fn build(self) -> ImageFormatListCreateInfoKHR { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ValidationCacheCreateInfoEXT { @@ -10445,6 +24228,51 @@ impl ::std::default::Default for ValidationCacheCreateInfoEXT { } } } +impl ValidationCacheCreateInfoEXT { + pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> { + ValidationCacheCreateInfoEXTBuilder { + inner: ValidationCacheCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ValidationCacheCreateInfoEXTBuilder<'a> { + inner: ValidationCacheCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> { + type Target = ValidationCacheCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: ValidationCacheCreateFlagsEXT, + ) -> ValidationCacheCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn initial_data_size( + mut self, + initial_data_size: usize, + ) -> ValidationCacheCreateInfoEXTBuilder<'a> { + self.inner.initial_data_size = initial_data_size; + self + } + pub fn initial_data( + mut self, + initial_data: &'a [c_void], + ) -> ValidationCacheCreateInfoEXTBuilder<'a> { + self.inner.initial_data_size = initial_data.len() as usize; + self.inner.p_initial_data = initial_data.as_ptr(); + self + } + pub fn build(self) -> ValidationCacheCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ShaderModuleValidationCacheCreateInfoEXT { @@ -10461,6 +24289,36 @@ impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { } } } +impl ShaderModuleValidationCacheCreateInfoEXT { + pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + ShaderModuleValidationCacheCreateInfoEXTBuilder { + inner: ShaderModuleValidationCacheCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + inner: ShaderModuleValidationCacheCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + type Target = ShaderModuleValidationCacheCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + pub fn validation_cache( + mut self, + validation_cache: ValidationCacheEXT, + ) -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + self.inner.validation_cache = validation_cache; + self + } + pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceMaintenance3Properties { @@ -10479,6 +24337,43 @@ impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { } } } +impl PhysicalDeviceMaintenance3Properties { + pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + PhysicalDeviceMaintenance3PropertiesBuilder { + inner: PhysicalDeviceMaintenance3Properties::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + inner: PhysicalDeviceMaintenance3Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + type Target = PhysicalDeviceMaintenance3Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + pub fn max_per_set_descriptors( + mut self, + max_per_set_descriptors: u32, + ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + self.inner.max_per_set_descriptors = max_per_set_descriptors; + self + } + pub fn max_memory_allocation_size( + mut self, + max_memory_allocation_size: DeviceSize, + ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + self.inner.max_memory_allocation_size = max_memory_allocation_size; + self + } + pub fn build(self) -> PhysicalDeviceMaintenance3Properties { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutSupport { @@ -10495,6 +24390,33 @@ impl ::std::default::Default for DescriptorSetLayoutSupport { } } } +impl DescriptorSetLayoutSupport { + pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> { + DescriptorSetLayoutSupportBuilder { + inner: DescriptorSetLayoutSupport::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorSetLayoutSupportBuilder<'a> { + inner: DescriptorSetLayoutSupport, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> { + type Target = DescriptorSetLayoutSupport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorSetLayoutSupportBuilder<'a> { + pub fn supported(mut self, supported: Bool32) -> DescriptorSetLayoutSupportBuilder<'a> { + self.inner.supported = supported; + self + } + pub fn build(self) -> DescriptorSetLayoutSupport { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderDrawParameterFeatures { @@ -10511,6 +24433,36 @@ impl ::std::default::Default for PhysicalDeviceShaderDrawParameterFeatures { } } } +impl PhysicalDeviceShaderDrawParameterFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { + PhysicalDeviceShaderDrawParameterFeaturesBuilder { + inner: PhysicalDeviceShaderDrawParameterFeatures::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderDrawParameterFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderDrawParameterFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { + pub fn shader_draw_parameters( + mut self, + shader_draw_parameters: Bool32, + ) -> PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { + self.inner.shader_draw_parameters = shader_draw_parameters; + self + } + pub fn build(self) -> PhysicalDeviceShaderDrawParameterFeatures { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct NativeBufferANDROID { @@ -10533,6 +24485,45 @@ impl ::std::default::Default for NativeBufferANDROID { } } } +impl NativeBufferANDROID { + pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> { + NativeBufferANDROIDBuilder { + inner: NativeBufferANDROID::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct NativeBufferANDROIDBuilder<'a> { + inner: NativeBufferANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> { + type Target = NativeBufferANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> NativeBufferANDROIDBuilder<'a> { + pub fn handle(mut self, handle: *const c_void) -> NativeBufferANDROIDBuilder<'a> { + self.inner.handle = handle; + self + } + pub fn stride(mut self, stride: c_int) -> NativeBufferANDROIDBuilder<'a> { + self.inner.stride = stride; + self + } + pub fn format(mut self, format: c_int) -> NativeBufferANDROIDBuilder<'a> { + self.inner.format = format; + self + } + pub fn usage(mut self, usage: c_int) -> NativeBufferANDROIDBuilder<'a> { + self.inner.usage = usage; + self + } + pub fn build(self) -> NativeBufferANDROID { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ShaderResourceUsageAMD { @@ -10542,6 +24533,58 @@ pub struct ShaderResourceUsageAMD { pub lds_usage_size_in_bytes: usize, pub scratch_mem_usage_in_bytes: usize, } +impl ShaderResourceUsageAMD { + pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> { + ShaderResourceUsageAMDBuilder { + inner: ShaderResourceUsageAMD::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ShaderResourceUsageAMDBuilder<'a> { + inner: ShaderResourceUsageAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> { + type Target = ShaderResourceUsageAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ShaderResourceUsageAMDBuilder<'a> { + pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> ShaderResourceUsageAMDBuilder<'a> { + self.inner.num_used_vgprs = num_used_vgprs; + self + } + pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> ShaderResourceUsageAMDBuilder<'a> { + self.inner.num_used_sgprs = num_used_sgprs; + self + } + pub fn lds_size_per_local_work_group( + mut self, + lds_size_per_local_work_group: u32, + ) -> ShaderResourceUsageAMDBuilder<'a> { + self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group; + self + } + pub fn lds_usage_size_in_bytes( + mut self, + lds_usage_size_in_bytes: usize, + ) -> ShaderResourceUsageAMDBuilder<'a> { + self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes; + self + } + pub fn scratch_mem_usage_in_bytes( + mut self, + scratch_mem_usage_in_bytes: usize, + ) -> ShaderResourceUsageAMDBuilder<'a> { + self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes; + self + } + pub fn build(self) -> ShaderResourceUsageAMD { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ShaderStatisticsInfoAMD { @@ -10566,6 +24609,78 @@ impl ::std::default::Default for ShaderStatisticsInfoAMD { } } } +impl ShaderStatisticsInfoAMD { + pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> { + ShaderStatisticsInfoAMDBuilder { + inner: ShaderStatisticsInfoAMD::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ShaderStatisticsInfoAMDBuilder<'a> { + inner: ShaderStatisticsInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> { + type Target = ShaderStatisticsInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ShaderStatisticsInfoAMDBuilder<'a> { + pub fn shader_stage_mask( + mut self, + shader_stage_mask: ShaderStageFlags, + ) -> ShaderStatisticsInfoAMDBuilder<'a> { + self.inner.shader_stage_mask = shader_stage_mask; + self + } + pub fn resource_usage( + mut self, + resource_usage: ShaderResourceUsageAMD, + ) -> ShaderStatisticsInfoAMDBuilder<'a> { + self.inner.resource_usage = resource_usage; + self + } + pub fn num_physical_vgprs( + mut self, + num_physical_vgprs: u32, + ) -> ShaderStatisticsInfoAMDBuilder<'a> { + self.inner.num_physical_vgprs = num_physical_vgprs; + self + } + pub fn num_physical_sgprs( + mut self, + num_physical_sgprs: u32, + ) -> ShaderStatisticsInfoAMDBuilder<'a> { + self.inner.num_physical_sgprs = num_physical_sgprs; + self + } + pub fn num_available_vgprs( + mut self, + num_available_vgprs: u32, + ) -> ShaderStatisticsInfoAMDBuilder<'a> { + self.inner.num_available_vgprs = num_available_vgprs; + self + } + pub fn num_available_sgprs( + mut self, + num_available_sgprs: u32, + ) -> ShaderStatisticsInfoAMDBuilder<'a> { + self.inner.num_available_sgprs = num_available_sgprs; + self + } + pub fn compute_work_group_size( + mut self, + compute_work_group_size: [u32; 3], + ) -> ShaderStatisticsInfoAMDBuilder<'a> { + self.inner.compute_work_group_size = compute_work_group_size; + self + } + pub fn build(self) -> ShaderStatisticsInfoAMD { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DeviceQueueGlobalPriorityCreateInfoEXT { @@ -10582,6 +24697,36 @@ impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoEXT { } } } +impl DeviceQueueGlobalPriorityCreateInfoEXT { + pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { + DeviceQueueGlobalPriorityCreateInfoEXTBuilder { + inner: DeviceQueueGlobalPriorityCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { + inner: DeviceQueueGlobalPriorityCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { + type Target = DeviceQueueGlobalPriorityCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { + pub fn global_priority( + mut self, + global_priority: QueueGlobalPriorityEXT, + ) -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { + self.inner.global_priority = global_priority; + self + } + pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugUtilsObjectNameInfoEXT { @@ -10602,6 +24747,47 @@ impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { } } } +impl DebugUtilsObjectNameInfoEXT { + pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> { + DebugUtilsObjectNameInfoEXTBuilder { + inner: DebugUtilsObjectNameInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> { + inner: DebugUtilsObjectNameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> { + type Target = DebugUtilsObjectNameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { + pub fn object_type( + mut self, + object_type: ObjectType, + ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> { + self.inner.object_type = object_type; + self + } + pub fn object_handle(mut self, object_handle: u64) -> DebugUtilsObjectNameInfoEXTBuilder<'a> { + self.inner.object_handle = object_handle; + self + } + pub fn object_name( + mut self, + object_name: &'a ::std::ffi::CStr, + ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> { + self.inner.p_object_name = object_name.as_ptr(); + self + } + pub fn build(self) -> DebugUtilsObjectNameInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugUtilsObjectTagInfoEXT { @@ -10626,6 +24812,50 @@ impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { } } } +impl DebugUtilsObjectTagInfoEXT { + pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + DebugUtilsObjectTagInfoEXTBuilder { + inner: DebugUtilsObjectTagInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> { + inner: DebugUtilsObjectTagInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> { + type Target = DebugUtilsObjectTagInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { + pub fn object_type(mut self, object_type: ObjectType) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + self.inner.object_type = object_type; + self + } + pub fn object_handle(mut self, object_handle: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + self.inner.object_handle = object_handle; + self + } + pub fn tag_name(mut self, tag_name: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + self.inner.tag_name = tag_name; + self + } + pub fn tag_size(mut self, tag_size: usize) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + self.inner.tag_size = tag_size; + self + } + pub fn tag(mut self, tag: &'a [c_void]) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + self.inner.tag_size = tag.len() as usize; + self.inner.p_tag = tag.as_ptr(); + self + } + pub fn build(self) -> DebugUtilsObjectTagInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugUtilsLabelEXT { @@ -10644,6 +24874,37 @@ impl ::std::default::Default for DebugUtilsLabelEXT { } } } +impl DebugUtilsLabelEXT { + pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> { + DebugUtilsLabelEXTBuilder { + inner: DebugUtilsLabelEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugUtilsLabelEXTBuilder<'a> { + inner: DebugUtilsLabelEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> { + type Target = DebugUtilsLabelEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugUtilsLabelEXTBuilder<'a> { + pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> DebugUtilsLabelEXTBuilder<'a> { + self.inner.p_label_name = label_name.as_ptr(); + self + } + pub fn color(mut self, color: [c_float; 4]) -> DebugUtilsLabelEXTBuilder<'a> { + self.inner.color = color; + self + } + pub fn build(self) -> DebugUtilsLabelEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone)] pub struct DebugUtilsMessengerCreateInfoEXT { @@ -10666,7 +24927,8 @@ impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { .field( "pfn_user_callback", &(self.pfn_user_callback.map(|x| x as *const ())), - ).field("p_user_data", &self.p_user_data) + ) + .field("p_user_data", &self.p_user_data) .finish() } } @@ -10683,6 +24945,64 @@ impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { } } } +impl DebugUtilsMessengerCreateInfoEXT { + pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + DebugUtilsMessengerCreateInfoEXTBuilder { + inner: DebugUtilsMessengerCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + inner: DebugUtilsMessengerCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + type Target = DebugUtilsMessengerCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: DebugUtilsMessengerCreateFlagsEXT, + ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn message_severity( + mut self, + message_severity: DebugUtilsMessageSeverityFlagsEXT, + ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + self.inner.message_severity = message_severity; + self + } + pub fn message_type( + mut self, + message_type: DebugUtilsMessageTypeFlagsEXT, + ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + self.inner.message_type = message_type; + self + } + pub fn pfn_user_callback( + mut self, + pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, + ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + self.inner.pfn_user_callback = pfn_user_callback; + self + } + pub fn user_data( + mut self, + user_data: *mut c_void, + ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + self.inner.p_user_data = user_data; + self + } + pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DebugUtilsMessengerCallbackDataEXT { @@ -10717,6 +25037,102 @@ impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { } } } +impl DebugUtilsMessengerCallbackDataEXT { + pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + DebugUtilsMessengerCallbackDataEXTBuilder { + inner: DebugUtilsMessengerCallbackDataEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + inner: DebugUtilsMessengerCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + type Target = DebugUtilsMessengerCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + pub fn flags( + mut self, + flags: DebugUtilsMessengerCallbackDataFlagsEXT, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn message_id_name( + mut self, + message_id_name: &'a ::std::ffi::CStr, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.p_message_id_name = message_id_name.as_ptr(); + self + } + pub fn message_id_number( + mut self, + message_id_number: i32, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.message_id_number = message_id_number; + self + } + pub fn message( + mut self, + message: &'a ::std::ffi::CStr, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.p_message = message.as_ptr(); + self + } + pub fn queue_label_count( + mut self, + queue_label_count: u32, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.queue_label_count = queue_label_count; + self + } + pub fn queue_labels( + mut self, + queue_labels: &'a mut [DebugUtilsLabelEXT], + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.queue_label_count = queue_labels.len() as u32; + self.inner.p_queue_labels = queue_labels.as_mut_ptr(); + self + } + pub fn cmd_buf_label_count( + mut self, + cmd_buf_label_count: u32, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.cmd_buf_label_count = cmd_buf_label_count; + self + } + pub fn cmd_buf_labels( + mut self, + cmd_buf_labels: &'a mut [DebugUtilsLabelEXT], + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.cmd_buf_label_count = cmd_buf_labels.len() as u32; + self.inner.p_cmd_buf_labels = cmd_buf_labels.as_mut_ptr(); + self + } + pub fn object_count( + mut self, + object_count: u32, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.object_count = object_count; + self + } + pub fn objects( + mut self, + objects: &'a mut [DebugUtilsObjectNameInfoEXT], + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + self.inner.object_count = objects.len() as u32; + self.inner.p_objects = objects.as_mut_ptr(); + self + } + pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportMemoryHostPointerInfoEXT { @@ -10735,6 +25151,43 @@ impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { } } } +impl ImportMemoryHostPointerInfoEXT { + pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> { + ImportMemoryHostPointerInfoEXTBuilder { + inner: ImportMemoryHostPointerInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> { + inner: ImportMemoryHostPointerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> { + type Target = ImportMemoryHostPointerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> { + pub fn handle_type( + mut self, + handle_type: ExternalMemoryHandleTypeFlags, + ) -> ImportMemoryHostPointerInfoEXTBuilder<'a> { + self.inner.handle_type = handle_type; + self + } + pub fn host_pointer( + mut self, + host_pointer: *mut c_void, + ) -> ImportMemoryHostPointerInfoEXTBuilder<'a> { + self.inner.p_host_pointer = host_pointer; + self + } + pub fn build(self) -> ImportMemoryHostPointerInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryHostPointerPropertiesEXT { @@ -10751,6 +25204,36 @@ impl ::std::default::Default for MemoryHostPointerPropertiesEXT { } } } +impl MemoryHostPointerPropertiesEXT { + pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> { + MemoryHostPointerPropertiesEXTBuilder { + inner: MemoryHostPointerPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryHostPointerPropertiesEXTBuilder<'a> { + inner: MemoryHostPointerPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> { + type Target = MemoryHostPointerPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { + pub fn memory_type_bits( + mut self, + memory_type_bits: u32, + ) -> MemoryHostPointerPropertiesEXTBuilder<'a> { + self.inner.memory_type_bits = memory_type_bits; + self + } + pub fn build(self) -> MemoryHostPointerPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { @@ -10767,6 +25250,36 @@ impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { } } } +impl PhysicalDeviceExternalMemoryHostPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder { + inner: PhysicalDeviceExternalMemoryHostPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceExternalMemoryHostPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + pub fn min_imported_host_pointer_alignment( + mut self, + min_imported_host_pointer_alignment: DeviceSize, + ) -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment; + self + } + pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { @@ -10799,6 +25312,97 @@ impl ::std::default::Default for PhysicalDeviceConservativeRasterizationProperti } } } +impl PhysicalDeviceConservativeRasterizationPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder { + inner: PhysicalDeviceConservativeRasterizationPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceConservativeRasterizationPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + pub fn primitive_overestimation_size( + mut self, + primitive_overestimation_size: c_float, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.primitive_overestimation_size = primitive_overestimation_size; + self + } + pub fn max_extra_primitive_overestimation_size( + mut self, + max_extra_primitive_overestimation_size: c_float, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.max_extra_primitive_overestimation_size = + max_extra_primitive_overestimation_size; + self + } + pub fn extra_primitive_overestimation_size_granularity( + mut self, + extra_primitive_overestimation_size_granularity: c_float, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.extra_primitive_overestimation_size_granularity = + extra_primitive_overestimation_size_granularity; + self + } + pub fn primitive_underestimation( + mut self, + primitive_underestimation: Bool32, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.primitive_underestimation = primitive_underestimation; + self + } + pub fn conservative_point_and_line_rasterization( + mut self, + conservative_point_and_line_rasterization: Bool32, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.conservative_point_and_line_rasterization = + conservative_point_and_line_rasterization; + self + } + pub fn degenerate_triangles_rasterized( + mut self, + degenerate_triangles_rasterized: Bool32, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized; + self + } + pub fn degenerate_lines_rasterized( + mut self, + degenerate_lines_rasterized: Bool32, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized; + self + } + pub fn fully_covered_fragment_shader_input_variable( + mut self, + fully_covered_fragment_shader_input_variable: Bool32, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.fully_covered_fragment_shader_input_variable = + fully_covered_fragment_shader_input_variable; + self + } + pub fn conservative_rasterization_post_depth_coverage( + mut self, + conservative_rasterization_post_depth_coverage: Bool32, + ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + self.inner.conservative_rasterization_post_depth_coverage = + conservative_rasterization_post_depth_coverage; + self + } + pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceShaderCorePropertiesAMD { @@ -10841,6 +25445,127 @@ impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { } } } +impl PhysicalDeviceShaderCorePropertiesAMD { + pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + PhysicalDeviceShaderCorePropertiesAMDBuilder { + inner: PhysicalDeviceShaderCorePropertiesAMD::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + inner: PhysicalDeviceShaderCorePropertiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + type Target = PhysicalDeviceShaderCorePropertiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + pub fn shader_engine_count( + mut self, + shader_engine_count: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.shader_engine_count = shader_engine_count; + self + } + pub fn shader_arrays_per_engine_count( + mut self, + shader_arrays_per_engine_count: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count; + self + } + pub fn compute_units_per_shader_array( + mut self, + compute_units_per_shader_array: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.compute_units_per_shader_array = compute_units_per_shader_array; + self + } + pub fn simd_per_compute_unit( + mut self, + simd_per_compute_unit: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.simd_per_compute_unit = simd_per_compute_unit; + self + } + pub fn wavefronts_per_simd( + mut self, + wavefronts_per_simd: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.wavefronts_per_simd = wavefronts_per_simd; + self + } + pub fn wavefront_size( + mut self, + wavefront_size: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.wavefront_size = wavefront_size; + self + } + pub fn sgprs_per_simd( + mut self, + sgprs_per_simd: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.sgprs_per_simd = sgprs_per_simd; + self + } + pub fn min_sgpr_allocation( + mut self, + min_sgpr_allocation: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.min_sgpr_allocation = min_sgpr_allocation; + self + } + pub fn max_sgpr_allocation( + mut self, + max_sgpr_allocation: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.max_sgpr_allocation = max_sgpr_allocation; + self + } + pub fn sgpr_allocation_granularity( + mut self, + sgpr_allocation_granularity: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity; + self + } + pub fn vgprs_per_simd( + mut self, + vgprs_per_simd: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.vgprs_per_simd = vgprs_per_simd; + self + } + pub fn min_vgpr_allocation( + mut self, + min_vgpr_allocation: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.min_vgpr_allocation = min_vgpr_allocation; + self + } + pub fn max_vgpr_allocation( + mut self, + max_vgpr_allocation: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.max_vgpr_allocation = max_vgpr_allocation; + self + } + pub fn vgpr_allocation_granularity( + mut self, + vgpr_allocation_granularity: u32, + ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity; + self + } + pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineRasterizationConservativeStateCreateInfoEXT { @@ -10861,6 +25586,50 @@ impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInf } } } +impl PipelineRasterizationConservativeStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationConservativeStateCreateInfoEXTBuilder { + inner: PipelineRasterizationConservativeStateCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationConservativeStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationConservativeStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: PipelineRasterizationConservativeStateCreateFlagsEXT, + ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn conservative_rasterization_mode( + mut self, + conservative_rasterization_mode: ConservativeRasterizationModeEXT, + ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + self.inner.conservative_rasterization_mode = conservative_rasterization_mode; + self + } + pub fn extra_primitive_overestimation_size( + mut self, + extra_primitive_overestimation_size: c_float, + ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size; + self + } + pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingFeaturesEXT { @@ -10915,6 +25684,198 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeaturesEXT { } } } +impl PhysicalDeviceDescriptorIndexingFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder { + inner: PhysicalDeviceDescriptorIndexingFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorIndexingFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorIndexingFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + pub fn shader_input_attachment_array_dynamic_indexing( + mut self, + shader_input_attachment_array_dynamic_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.shader_input_attachment_array_dynamic_indexing = + shader_input_attachment_array_dynamic_indexing; + self + } + pub fn shader_uniform_texel_buffer_array_dynamic_indexing( + mut self, + shader_uniform_texel_buffer_array_dynamic_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .shader_uniform_texel_buffer_array_dynamic_indexing = + shader_uniform_texel_buffer_array_dynamic_indexing; + self + } + pub fn shader_storage_texel_buffer_array_dynamic_indexing( + mut self, + shader_storage_texel_buffer_array_dynamic_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .shader_storage_texel_buffer_array_dynamic_indexing = + shader_storage_texel_buffer_array_dynamic_indexing; + self + } + pub fn shader_uniform_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_buffer_array_non_uniform_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.shader_uniform_buffer_array_non_uniform_indexing = + shader_uniform_buffer_array_non_uniform_indexing; + self + } + pub fn shader_sampled_image_array_non_uniform_indexing( + mut self, + shader_sampled_image_array_non_uniform_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.shader_sampled_image_array_non_uniform_indexing = + shader_sampled_image_array_non_uniform_indexing; + self + } + pub fn shader_storage_buffer_array_non_uniform_indexing( + mut self, + shader_storage_buffer_array_non_uniform_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.shader_storage_buffer_array_non_uniform_indexing = + shader_storage_buffer_array_non_uniform_indexing; + self + } + pub fn shader_storage_image_array_non_uniform_indexing( + mut self, + shader_storage_image_array_non_uniform_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.shader_storage_image_array_non_uniform_indexing = + shader_storage_image_array_non_uniform_indexing; + self + } + pub fn shader_input_attachment_array_non_uniform_indexing( + mut self, + shader_input_attachment_array_non_uniform_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .shader_input_attachment_array_non_uniform_indexing = + shader_input_attachment_array_non_uniform_indexing; + self + } + pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .shader_uniform_texel_buffer_array_non_uniform_indexing = + shader_uniform_texel_buffer_array_non_uniform_indexing; + self + } + pub fn shader_storage_texel_buffer_array_non_uniform_indexing( + mut self, + shader_storage_texel_buffer_array_non_uniform_indexing: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .shader_storage_texel_buffer_array_non_uniform_indexing = + shader_storage_texel_buffer_array_non_uniform_indexing; + self + } + pub fn descriptor_binding_uniform_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_buffer_update_after_bind: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .descriptor_binding_uniform_buffer_update_after_bind = + descriptor_binding_uniform_buffer_update_after_bind; + self + } + pub fn descriptor_binding_sampled_image_update_after_bind( + mut self, + descriptor_binding_sampled_image_update_after_bind: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .descriptor_binding_sampled_image_update_after_bind = + descriptor_binding_sampled_image_update_after_bind; + self + } + pub fn descriptor_binding_storage_image_update_after_bind( + mut self, + descriptor_binding_storage_image_update_after_bind: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .descriptor_binding_storage_image_update_after_bind = + descriptor_binding_storage_image_update_after_bind; + self + } + pub fn descriptor_binding_storage_buffer_update_after_bind( + mut self, + descriptor_binding_storage_buffer_update_after_bind: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .descriptor_binding_storage_buffer_update_after_bind = + descriptor_binding_storage_buffer_update_after_bind; + self + } + pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .descriptor_binding_uniform_texel_buffer_update_after_bind = + descriptor_binding_uniform_texel_buffer_update_after_bind; + self + } + pub fn descriptor_binding_storage_texel_buffer_update_after_bind( + mut self, + descriptor_binding_storage_texel_buffer_update_after_bind: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner + .descriptor_binding_storage_texel_buffer_update_after_bind = + descriptor_binding_storage_texel_buffer_update_after_bind; + self + } + pub fn descriptor_binding_update_unused_while_pending( + mut self, + descriptor_binding_update_unused_while_pending: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.descriptor_binding_update_unused_while_pending = + descriptor_binding_update_unused_while_pending; + self + } + pub fn descriptor_binding_partially_bound( + mut self, + descriptor_binding_partially_bound: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound; + self + } + pub fn descriptor_binding_variable_descriptor_count( + mut self, + descriptor_binding_variable_descriptor_count: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.descriptor_binding_variable_descriptor_count = + descriptor_binding_variable_descriptor_count; + self + } + pub fn runtime_descriptor_array( + mut self, + runtime_descriptor_array: Bool32, + ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + self.inner.runtime_descriptor_array = runtime_descriptor_array; + self + } + pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeaturesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceDescriptorIndexingPropertiesEXT { @@ -10975,6 +25936,229 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingPropertiesEXT { } } } +impl PhysicalDeviceDescriptorIndexingPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder { + inner: PhysicalDeviceDescriptorIndexingPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorIndexingPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorIndexingPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + pub fn max_update_after_bind_descriptors_in_all_pools( + mut self, + max_update_after_bind_descriptors_in_all_pools: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner.max_update_after_bind_descriptors_in_all_pools = + max_update_after_bind_descriptors_in_all_pools; + self + } + pub fn shader_uniform_buffer_array_non_uniform_indexing_native( + mut self, + shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .shader_uniform_buffer_array_non_uniform_indexing_native = + shader_uniform_buffer_array_non_uniform_indexing_native; + self + } + pub fn shader_sampled_image_array_non_uniform_indexing_native( + mut self, + shader_sampled_image_array_non_uniform_indexing_native: Bool32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .shader_sampled_image_array_non_uniform_indexing_native = + shader_sampled_image_array_non_uniform_indexing_native; + self + } + pub fn shader_storage_buffer_array_non_uniform_indexing_native( + mut self, + shader_storage_buffer_array_non_uniform_indexing_native: Bool32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .shader_storage_buffer_array_non_uniform_indexing_native = + shader_storage_buffer_array_non_uniform_indexing_native; + self + } + pub fn shader_storage_image_array_non_uniform_indexing_native( + mut self, + shader_storage_image_array_non_uniform_indexing_native: Bool32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .shader_storage_image_array_non_uniform_indexing_native = + shader_storage_image_array_non_uniform_indexing_native; + self + } + pub fn shader_input_attachment_array_non_uniform_indexing_native( + mut self, + shader_input_attachment_array_non_uniform_indexing_native: Bool32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .shader_input_attachment_array_non_uniform_indexing_native = + shader_input_attachment_array_non_uniform_indexing_native; + self + } + pub fn robust_buffer_access_update_after_bind( + mut self, + robust_buffer_access_update_after_bind: Bool32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner.robust_buffer_access_update_after_bind = robust_buffer_access_update_after_bind; + self + } + pub fn quad_divergent_implicit_lod( + mut self, + quad_divergent_implicit_lod: Bool32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod; + self + } + pub fn max_per_stage_descriptor_update_after_bind_samplers( + mut self, + max_per_stage_descriptor_update_after_bind_samplers: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_per_stage_descriptor_update_after_bind_samplers = + max_per_stage_descriptor_update_after_bind_samplers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_per_stage_descriptor_update_after_bind_uniform_buffers = + max_per_stage_descriptor_update_after_bind_uniform_buffers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_buffers = + max_per_stage_descriptor_update_after_bind_storage_buffers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_sampled_images( + mut self, + max_per_stage_descriptor_update_after_bind_sampled_images: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_per_stage_descriptor_update_after_bind_sampled_images = + max_per_stage_descriptor_update_after_bind_sampled_images; + self + } + pub fn max_per_stage_descriptor_update_after_bind_storage_images( + mut self, + max_per_stage_descriptor_update_after_bind_storage_images: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_images = + max_per_stage_descriptor_update_after_bind_storage_images; + self + } + pub fn max_per_stage_descriptor_update_after_bind_input_attachments( + mut self, + max_per_stage_descriptor_update_after_bind_input_attachments: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_per_stage_descriptor_update_after_bind_input_attachments = + max_per_stage_descriptor_update_after_bind_input_attachments; + self + } + pub fn max_per_stage_update_after_bind_resources( + mut self, + max_per_stage_update_after_bind_resources: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner.max_per_stage_update_after_bind_resources = + max_per_stage_update_after_bind_resources; + self + } + pub fn max_descriptor_set_update_after_bind_samplers( + mut self, + max_descriptor_set_update_after_bind_samplers: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner.max_descriptor_set_update_after_bind_samplers = + max_descriptor_set_update_after_bind_samplers; + self + } + pub fn max_descriptor_set_update_after_bind_uniform_buffers( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers = + max_descriptor_set_update_after_bind_uniform_buffers; + self + } + pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers_dynamic = + max_descriptor_set_update_after_bind_uniform_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_storage_buffers( + mut self, + max_descriptor_set_update_after_bind_storage_buffers: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers = + max_descriptor_set_update_after_bind_storage_buffers; + self + } + pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers_dynamic = + max_descriptor_set_update_after_bind_storage_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_sampled_images( + mut self, + max_descriptor_set_update_after_bind_sampled_images: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_sampled_images = + max_descriptor_set_update_after_bind_sampled_images; + self + } + pub fn max_descriptor_set_update_after_bind_storage_images( + mut self, + max_descriptor_set_update_after_bind_storage_images: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_storage_images = + max_descriptor_set_update_after_bind_storage_images; + self + } + pub fn max_descriptor_set_update_after_bind_input_attachments( + mut self, + max_descriptor_set_update_after_bind_input_attachments: u32, + ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_input_attachments = + max_descriptor_set_update_after_bind_input_attachments; + self + } + pub fn build(self) -> PhysicalDeviceDescriptorIndexingPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { @@ -10993,6 +26177,44 @@ impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfoEXT { } } } +impl DescriptorSetLayoutBindingFlagsCreateInfoEXT { + pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { + DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder { + inner: DescriptorSetLayoutBindingFlagsCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { + inner: DescriptorSetLayoutBindingFlagsCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { + type Target = DescriptorSetLayoutBindingFlagsCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { + pub fn binding_count( + mut self, + binding_count: u32, + ) -> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { + self.inner.binding_count = binding_count; + self + } + pub fn binding_flags( + mut self, + binding_flags: &'a [DescriptorBindingFlagsEXT], + ) -> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { + self.inner.binding_count = binding_flags.len() as u32; + self.inner.p_binding_flags = binding_flags.as_ptr(); + self + } + pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { @@ -11011,6 +26233,44 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInf } } } +impl DescriptorSetVariableDescriptorCountAllocateInfoEXT { + pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { + DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder { + inner: DescriptorSetVariableDescriptorCountAllocateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { + inner: DescriptorSetVariableDescriptorCountAllocateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { + type Target = DescriptorSetVariableDescriptorCountAllocateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { + pub fn descriptor_set_count( + mut self, + descriptor_set_count: u32, + ) -> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { + self.inner.descriptor_set_count = descriptor_set_count; + self + } + pub fn descriptor_counts( + mut self, + descriptor_counts: &'a [u32], + ) -> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { + self.inner.descriptor_set_count = descriptor_counts.len() as u32; + self.inner.p_descriptor_counts = descriptor_counts.as_ptr(); + self + } + pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { @@ -11027,12 +26287,73 @@ impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSuppo } } } +impl DescriptorSetVariableDescriptorCountLayoutSupportEXT { + pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { + DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder { + inner: DescriptorSetVariableDescriptorCountLayoutSupportEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { + inner: DescriptorSetVariableDescriptorCountLayoutSupportEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { + type Target = DescriptorSetVariableDescriptorCountLayoutSupportEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { + pub fn max_variable_descriptor_count( + mut self, + max_variable_descriptor_count: u32, + ) -> DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { + self.inner.max_variable_descriptor_count = max_variable_descriptor_count; + self + } + pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupportEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct VertexInputBindingDivisorDescriptionEXT { pub binding: u32, pub divisor: u32, } +impl VertexInputBindingDivisorDescriptionEXT { + pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + VertexInputBindingDivisorDescriptionEXTBuilder { + inner: VertexInputBindingDivisorDescriptionEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + inner: VertexInputBindingDivisorDescriptionEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + type Target = VertexInputBindingDivisorDescriptionEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + pub fn binding(mut self, binding: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + self.inner.binding = binding; + self + } + pub fn divisor(mut self, divisor: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + self.inner.divisor = divisor; + self + } + pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineVertexInputDivisorStateCreateInfoEXT { @@ -11051,6 +26372,44 @@ impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { } } } +impl PipelineVertexInputDivisorStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + PipelineVertexInputDivisorStateCreateInfoEXTBuilder { + inner: PipelineVertexInputDivisorStateCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + inner: PipelineVertexInputDivisorStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + type Target = PipelineVertexInputDivisorStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + pub fn vertex_binding_divisor_count( + mut self, + vertex_binding_divisor_count: u32, + ) -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + self.inner.vertex_binding_divisor_count = vertex_binding_divisor_count; + self + } + pub fn vertex_binding_divisors( + mut self, + vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT], + ) -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as u32; + self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr(); + self + } + pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { @@ -11067,6 +26426,36 @@ impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesE } } } +impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder { + inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + pub fn max_vertex_attrib_divisor( + mut self, + max_vertex_attrib_divisor: u32, + ) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor; + self + } + pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ImportAndroidHardwareBufferInfoANDROID { @@ -11083,6 +26472,36 @@ impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { } } } +impl ImportAndroidHardwareBufferInfoANDROID { + pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + ImportAndroidHardwareBufferInfoANDROIDBuilder { + inner: ImportAndroidHardwareBufferInfoANDROID::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + inner: ImportAndroidHardwareBufferInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + type Target = ImportAndroidHardwareBufferInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + pub fn buffer( + mut self, + buffer: *mut AHardwareBuffer, + ) -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferUsageANDROID { @@ -11099,6 +26518,36 @@ impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { } } } +impl AndroidHardwareBufferUsageANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> { + AndroidHardwareBufferUsageANDROIDBuilder { + inner: AndroidHardwareBufferUsageANDROID::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> { + inner: AndroidHardwareBufferUsageANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferUsageANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> { + pub fn android_hardware_buffer_usage( + mut self, + android_hardware_buffer_usage: u64, + ) -> AndroidHardwareBufferUsageANDROIDBuilder<'a> { + self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage; + self + } + pub fn build(self) -> AndroidHardwareBufferUsageANDROID { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferPropertiesANDROID { @@ -11117,6 +26566,43 @@ impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { } } } +impl AndroidHardwareBufferPropertiesANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + AndroidHardwareBufferPropertiesANDROIDBuilder { + inner: AndroidHardwareBufferPropertiesANDROID::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + inner: AndroidHardwareBufferPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + pub fn allocation_size( + mut self, + allocation_size: DeviceSize, + ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + self.inner.allocation_size = allocation_size; + self + } + pub fn memory_type_bits( + mut self, + memory_type_bits: u32, + ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + self.inner.memory_type_bits = memory_type_bits; + self + } + pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct MemoryGetAndroidHardwareBufferInfoANDROID { @@ -11133,6 +26619,36 @@ impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID { } } } +impl MemoryGetAndroidHardwareBufferInfoANDROID { + pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + MemoryGetAndroidHardwareBufferInfoANDROIDBuilder { + inner: MemoryGetAndroidHardwareBufferInfoANDROID::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + inner: MemoryGetAndroidHardwareBufferInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + type Target = MemoryGetAndroidHardwareBufferInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + pub fn memory( + mut self, + memory: DeviceMemory, + ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + self.inner.memory = memory; + self + } + pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct AndroidHardwareBufferFormatPropertiesANDROID { @@ -11163,6 +26679,85 @@ impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { } } } +impl AndroidHardwareBufferFormatPropertiesANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + AndroidHardwareBufferFormatPropertiesANDROIDBuilder { + inner: AndroidHardwareBufferFormatPropertiesANDROID::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + inner: AndroidHardwareBufferFormatPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferFormatPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + pub fn format( + mut self, + format: Format, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.format = format; + self + } + pub fn external_format( + mut self, + external_format: u64, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.external_format = external_format; + self + } + pub fn format_features( + mut self, + format_features: FormatFeatureFlags, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.format_features = format_features; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range( + mut self, + suggested_ycbcr_range: SamplerYcbcrRange, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset( + mut self, + suggested_x_chroma_offset: ChromaLocation, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset( + mut self, + suggested_y_chroma_offset: ChromaLocation, + ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct ExternalFormatANDROID { @@ -11179,6 +26774,33 @@ impl ::std::default::Default for ExternalFormatANDROID { } } } +impl ExternalFormatANDROID { + pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> { + ExternalFormatANDROIDBuilder { + inner: ExternalFormatANDROID::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ExternalFormatANDROIDBuilder<'a> { + inner: ExternalFormatANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> { + type Target = ExternalFormatANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ExternalFormatANDROIDBuilder<'a> { + pub fn external_format(mut self, external_format: u64) -> ExternalFormatANDROIDBuilder<'a> { + self.inner.external_format = external_format; + self + } + pub fn build(self) -> ExternalFormatANDROID { + self.inner + } +} #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ImageLayout(pub(crate) i32); @@ -13483,12 +29105,12 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: - self.get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: self + .get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: - self.get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: self + .get_physical_device_surface_present_modes_khr, } } } @@ -13637,12 +29259,12 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -13949,10 +29571,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: - self.get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: - self.get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: self + .get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: self + .get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -14235,8 +29857,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: - self.get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: self + .get_physical_device_xlib_presentation_support_khr, } } } @@ -14321,8 +29943,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: - self.get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: self + .get_physical_device_xcb_presentation_support_khr, } } } @@ -14407,8 +30029,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: - self.get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: self + .get_physical_device_wayland_presentation_support_khr, } } } @@ -14490,8 +30112,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: - self.get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: self + .get_physical_device_mir_presentation_support_khr, } } } @@ -14625,8 +30247,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: - self.get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: self + .get_physical_device_win32_presentation_support_khr, } } } @@ -16192,8 +31814,8 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: - self.get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: self + .get_physical_device_external_image_format_properties_nv, } } } @@ -16386,12 +32008,12 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: - self.get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: - self.get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: - self.get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: self + .get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: self + .get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: self + .get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } @@ -17203,8 +32825,8 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17390,8 +33012,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: - self.cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: self + .cmd_push_descriptor_set_with_template_khr, } } } @@ -17505,8 +33127,8 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: - self.get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: self + .get_physical_device_generated_commands_properties_nvx, } } } @@ -17946,8 +33568,8 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: - self.get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: self + .get_physical_device_surface_capabilities2_ext, } } } @@ -19098,8 +34720,8 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: - self.get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: self + .get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } @@ -19230,10 +34852,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: - self.get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: - self.get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: self + .get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: self + .get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } @@ -19869,10 +35491,10 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: - self.get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: - self.get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: self + .get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: self + .get_memory_android_hardware_buffer_android, } } } @@ -20273,8 +35895,8 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: - self.get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: self + .get_physical_device_multisample_properties_ext, } } } @@ -22969,11 +38591,13 @@ fn display_flags( } Ok(()) } -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -22983,46 +38607,11 @@ impl fmt::Display for PointClippingBehavior { } } } -impl fmt::Display for ObjectType { +impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), + Self::VERTEX => Some("VERTEX"), Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -23032,69 +38621,65 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryPipelineStatisticFlags { +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), ]; display_flags(f, KNOWN, self.0) } @@ -23119,431 +38704,25 @@ impl fmt::Display for IndirectCommandsTokenTypeNVX { } } } -impl fmt::Display for DebugReportFlagsEXT { +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { +impl fmt::Display for BufferCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } @@ -23576,1224 +38755,6 @@ impl fmt::Display for SurfaceTransformFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25234,6 +39195,851 @@ impl fmt::Display for StructureType { } } } +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25247,6 +40053,645 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -25290,6 +40735,136 @@ impl fmt::Display for PipelineStageFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25305,31 +40880,112 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PrimitiveTopology { +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -25339,26 +40995,264 @@ impl fmt::Display for PrimitiveTopology { } } } -impl fmt::Display for ImageLayout { +impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), _ => None, }; if let Some(x) = name { @@ -25368,17 +41262,11 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for StencilOp { +impl fmt::Display for SamplerYcbcrRange { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -25388,125 +41276,22 @@ impl fmt::Display for StencilOp { } } } -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for SubgroupFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -25522,166 +41307,3 @@ impl fmt::Display for DisplayPowerStateEXT { } } } -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index f1a359b..32a805f 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1283,6 +1283,153 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt Some(q) } +pub fn derive_setters(_struct: &vkxml::Struct) -> Option { + let name = name_to_tokens(&_struct.name); + let name_builder = name_to_tokens(&(_struct.name.to_string() + "Builder")); + + let members = _struct.elements.iter().filter_map(|elem| match *elem { + vkxml::StructElement::Member(ref field) => Some(field), + _ => None, + }); + + let setters = members.clone().filter_map(|field| { + let param_ident = field.param_ident(); + let param_ty_tokens = field.type_tokens(); + + let param_ident_string = param_ident.to_string(); + if param_ident_string == "s_type" || param_ident_string == "p_next" { + return None; + } + + let mut param_ident_short = param_ident_string.as_str(); + if param_ident_string.starts_with("p_") { + param_ident_short = ¶m_ident_string[2..]; + }; + if param_ident_string.starts_with("pp_") { + param_ident_short = ¶m_ident_string[3..]; + }; + let param_ident_short = Term::intern(¶m_ident_short); + + // TODO: Improve in future when https://github.com/rust-lang/rust/issues/53667 is merged + if param_ident.to_string().starts_with("p_") || param_ident.to_string().starts_with("pp_") { + let param_ty_string = param_ty_tokens.to_string(); + + if param_ty_string == "*const c_char" { + return Some(quote!{ + pub fn #param_ident_short(mut self, #param_ident_short: &'a ::std::ffi::CStr) -> #name_builder<'a> { + self.inner.#param_ident = #param_ident_short.as_ptr(); + self + } + }); + } + + if let Some(ref array_type) = field.array { + if let Some(ref array_size) = field.size { + if !array_size.starts_with("latexmath") { + let length_type; + let array_size_ident = Ident::from(array_size.to_snake_case().as_str()); + if array_size_ident.to_string().contains("_count") { + length_type = Term::intern("u32"); + } else { + length_type = Term::intern("usize"); + } + + if param_ty_string == "*const *const c_char" { + return Some(quote!{ + pub fn #param_ident_short(mut self, #param_ident_short: &'a [*const c_char]) -> #name_builder<'a> { + self.inner.#param_ident = #param_ident_short.as_ptr(); + self.inner.#array_size_ident = #param_ident_short.len() as #length_type; + self + } + }); + } + + let slice_param_ty_tokens; + let ptr_mutability; + if param_ty_string.starts_with("*const ") { + slice_param_ty_tokens = "&'a [".to_string() + ¶m_ty_string[7..] + "]"; + ptr_mutability = ".as_ptr()"; + } else { + // *mut + slice_param_ty_tokens = + "&'a mut [".to_string() + ¶m_ty_string[5..] + "]"; + ptr_mutability = ".as_mut_ptr()"; + } + let slice_param_ty_tokens = Term::intern(&slice_param_ty_tokens); + let ptr_mutability = Term::intern(ptr_mutability); + + + match array_type { + vkxml::ArrayType::Dynamic => { + return Some(quote!{ + pub fn #param_ident_short(mut self, #param_ident_short: #slice_param_ty_tokens) -> #name_builder<'a> { + self.inner.#array_size_ident = #param_ident_short.len() as #length_type; + self.inner.#param_ident = #param_ident_short#ptr_mutability; + self + } + }); + } + _ => {} + } + } + } + } + + if param_ty_string.starts_with("*const ") && param_ty_string.ends_with("Info") { + let slice_param_ty_tokens = "&'a ".to_string() + ¶m_ty_string[7..]; + let slice_param_ty_tokens = Term::intern(&slice_param_ty_tokens); + return Some(quote!{ + pub fn #param_ident_short(mut self, #param_ident_short: #slice_param_ty_tokens) -> #name_builder<'a> { + self.inner.#param_ident = #param_ident_short; + self + } + }); + } + } + + Some(quote!{ + pub fn #param_ident_short(mut self, #param_ident_short: #param_ty_tokens) -> #name_builder<'a> { + self.inner.#param_ident = #param_ident_short; + self + } + }) + }); + + let q = quote!{ + impl #name { + pub fn builder<'a>() -> #name_builder<'a> { + #name_builder { + inner: #name::default(), + marker: ::std::marker::PhantomData, + } + } + } + + pub struct #name_builder<'a> { + inner: #name, + marker: ::std::marker::PhantomData<&'a ()>, + } + + impl<'a> ::std::ops::Deref for #name_builder<'a> { + type Target = #name; + + fn deref(&self) -> &Self::Target { + &self.inner + } + } + + impl<'a> #name_builder<'a> { + #(#setters)* + + pub fn build(self) -> #name { + self.inner + } + } + }; + + Some(q) +} + /// At the moment `Ash` doesn't properly derive all the necessary drives /// like Eq, Hash etc. /// To Address some cases, you can add the name of the struct that you @@ -1308,6 +1455,7 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> let debug_tokens = derive_debug(_struct, union_types); let default_tokens = derive_default(_struct); + let setter_tokens = derive_setters(_struct); let manual_derive_tokens = manual_derives(_struct); let dbg_str = if debug_tokens.is_none() { quote!(Debug,) @@ -1327,6 +1475,7 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> } #debug_tokens #default_tokens + #setter_tokens } } From 358220cb85eac8dc97fec3e30f91a78c20495a5a Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Tue, 23 Oct 2018 23:37:28 +0200 Subject: [PATCH 103/122] Filter out _count members in builder pattern --- ash/src/vk.rs | 4072 ++++++++++++++++++------------------------ generator/src/lib.rs | 17 + 2 files changed, 1722 insertions(+), 2367 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 40db6ef..edbb248 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -5839,10 +5839,6 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> { self.inner.queue_family_index = queue_family_index; self } - pub fn queue_count(mut self, queue_count: u32) -> DeviceQueueCreateInfoBuilder<'a> { - self.inner.queue_count = queue_count; - self - } pub fn queue_priorities( mut self, queue_priorities: &'a [c_float], @@ -5908,13 +5904,6 @@ impl<'a> DeviceCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn queue_create_info_count( - mut self, - queue_create_info_count: u32, - ) -> DeviceCreateInfoBuilder<'a> { - self.inner.queue_create_info_count = queue_create_info_count; - self - } pub fn queue_create_infos( mut self, queue_create_infos: &'a [DeviceQueueCreateInfo], @@ -5923,10 +5912,6 @@ impl<'a> DeviceCreateInfoBuilder<'a> { self.inner.p_queue_create_infos = queue_create_infos.as_ptr(); self } - pub fn enabled_layer_count(mut self, enabled_layer_count: u32) -> DeviceCreateInfoBuilder<'a> { - self.inner.enabled_layer_count = enabled_layer_count; - self - } pub fn enabled_layer_names( mut self, enabled_layer_names: &'a [*const c_char], @@ -5935,13 +5920,6 @@ impl<'a> DeviceCreateInfoBuilder<'a> { self.inner.enabled_layer_count = enabled_layer_names.len() as u32; self } - pub fn enabled_extension_count( - mut self, - enabled_extension_count: u32, - ) -> DeviceCreateInfoBuilder<'a> { - self.inner.enabled_extension_count = enabled_extension_count; - self - } pub fn enabled_extension_names( mut self, enabled_extension_names: &'a [*const c_char], @@ -6017,13 +5995,6 @@ impl<'a> InstanceCreateInfoBuilder<'a> { self.inner.p_application_info = application_info; self } - pub fn enabled_layer_count( - mut self, - enabled_layer_count: u32, - ) -> InstanceCreateInfoBuilder<'a> { - self.inner.enabled_layer_count = enabled_layer_count; - self - } pub fn enabled_layer_names( mut self, enabled_layer_names: &'a [*const c_char], @@ -6032,13 +6003,6 @@ impl<'a> InstanceCreateInfoBuilder<'a> { self.inner.enabled_layer_count = enabled_layer_names.len() as u32; self } - pub fn enabled_extension_count( - mut self, - enabled_extension_count: u32, - ) -> InstanceCreateInfoBuilder<'a> { - self.inner.enabled_extension_count = enabled_extension_count; - self - } pub fn enabled_extension_names( mut self, enabled_extension_names: &'a [*const c_char], @@ -6765,10 +6729,6 @@ impl<'a> WriteDescriptorSetBuilder<'a> { self.inner.dst_array_element = dst_array_element; self } - pub fn descriptor_count(mut self, descriptor_count: u32) -> WriteDescriptorSetBuilder<'a> { - self.inner.descriptor_count = descriptor_count; - self - } pub fn descriptor_type( mut self, descriptor_type: DescriptorType, @@ -6944,13 +6904,6 @@ impl<'a> BufferCreateInfoBuilder<'a> { self.inner.sharing_mode = sharing_mode; self } - pub fn queue_family_index_count( - mut self, - queue_family_index_count: u32, - ) -> BufferCreateInfoBuilder<'a> { - self.inner.queue_family_index_count = queue_family_index_count; - self - } pub fn queue_family_indices( mut self, queue_family_indices: &'a [u32], @@ -7516,13 +7469,6 @@ impl<'a> ImageCreateInfoBuilder<'a> { self.inner.sharing_mode = sharing_mode; self } - pub fn queue_family_index_count( - mut self, - queue_family_index_count: u32, - ) -> ImageCreateInfoBuilder<'a> { - self.inner.queue_family_index_count = queue_family_index_count; - self - } pub fn queue_family_indices( mut self, queue_family_indices: &'a [u32], @@ -7860,10 +7806,6 @@ impl<'a> SparseBufferMemoryBindInfoBuilder<'a> { self.inner.buffer = buffer; self } - pub fn bind_count(mut self, bind_count: u32) -> SparseBufferMemoryBindInfoBuilder<'a> { - self.inner.bind_count = bind_count; - self - } pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> SparseBufferMemoryBindInfoBuilder<'a> { self.inner.bind_count = binds.len() as u32; self.inner.p_binds = binds.as_ptr(); @@ -7912,10 +7854,6 @@ impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> { self.inner.image = image; self } - pub fn bind_count(mut self, bind_count: u32) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { - self.inner.bind_count = bind_count; - self - } pub fn binds( mut self, binds: &'a [SparseMemoryBind], @@ -7967,10 +7905,6 @@ impl<'a> SparseImageMemoryBindInfoBuilder<'a> { self.inner.image = image; self } - pub fn bind_count(mut self, bind_count: u32) -> SparseImageMemoryBindInfoBuilder<'a> { - self.inner.bind_count = bind_count; - self - } pub fn binds( mut self, binds: &'a [SparseImageMemoryBind], @@ -8036,10 +7970,6 @@ impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> { } } impl<'a> BindSparseInfoBuilder<'a> { - pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> BindSparseInfoBuilder<'a> { - self.inner.wait_semaphore_count = wait_semaphore_count; - self - } pub fn wait_semaphores( mut self, wait_semaphores: &'a [Semaphore], @@ -8048,10 +7978,6 @@ impl<'a> BindSparseInfoBuilder<'a> { self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); self } - pub fn buffer_bind_count(mut self, buffer_bind_count: u32) -> BindSparseInfoBuilder<'a> { - self.inner.buffer_bind_count = buffer_bind_count; - self - } pub fn buffer_binds( mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo], @@ -8060,13 +7986,6 @@ impl<'a> BindSparseInfoBuilder<'a> { self.inner.p_buffer_binds = buffer_binds.as_ptr(); self } - pub fn image_opaque_bind_count( - mut self, - image_opaque_bind_count: u32, - ) -> BindSparseInfoBuilder<'a> { - self.inner.image_opaque_bind_count = image_opaque_bind_count; - self - } pub fn image_opaque_binds( mut self, image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo], @@ -8075,10 +7994,6 @@ impl<'a> BindSparseInfoBuilder<'a> { self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr(); self } - pub fn image_bind_count(mut self, image_bind_count: u32) -> BindSparseInfoBuilder<'a> { - self.inner.image_bind_count = image_bind_count; - self - } pub fn image_binds( mut self, image_binds: &'a [SparseImageMemoryBindInfo], @@ -8087,13 +8002,6 @@ impl<'a> BindSparseInfoBuilder<'a> { self.inner.p_image_binds = image_binds.as_ptr(); self } - pub fn signal_semaphore_count( - mut self, - signal_semaphore_count: u32, - ) -> BindSparseInfoBuilder<'a> { - self.inner.signal_semaphore_count = signal_semaphore_count; - self - } pub fn signal_semaphores( mut self, signal_semaphores: &'a [Semaphore], @@ -8450,13 +8358,6 @@ impl<'a> DescriptorSetLayoutBindingBuilder<'a> { self.inner.descriptor_type = descriptor_type; self } - pub fn descriptor_count( - mut self, - descriptor_count: u32, - ) -> DescriptorSetLayoutBindingBuilder<'a> { - self.inner.descriptor_count = descriptor_count; - self - } pub fn stage_flags( mut self, stage_flags: ShaderStageFlags, @@ -8522,10 +8423,6 @@ impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn binding_count(mut self, binding_count: u32) -> DescriptorSetLayoutCreateInfoBuilder<'a> { - self.inner.binding_count = binding_count; - self - } pub fn bindings( mut self, bindings: &'a [DescriptorSetLayoutBinding], @@ -8627,10 +8524,6 @@ impl<'a> DescriptorPoolCreateInfoBuilder<'a> { self.inner.max_sets = max_sets; self } - pub fn pool_size_count(mut self, pool_size_count: u32) -> DescriptorPoolCreateInfoBuilder<'a> { - self.inner.pool_size_count = pool_size_count; - self - } pub fn pool_sizes( mut self, pool_sizes: &'a [DescriptorPoolSize], @@ -8689,13 +8582,6 @@ impl<'a> DescriptorSetAllocateInfoBuilder<'a> { self.inner.descriptor_pool = descriptor_pool; self } - pub fn descriptor_set_count( - mut self, - descriptor_set_count: u32, - ) -> DescriptorSetAllocateInfoBuilder<'a> { - self.inner.descriptor_set_count = descriptor_set_count; - self - } pub fn set_layouts( mut self, set_layouts: &'a [DescriptorSetLayout], @@ -8787,10 +8673,6 @@ impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> { } } impl<'a> SpecializationInfoBuilder<'a> { - pub fn map_entry_count(mut self, map_entry_count: u32) -> SpecializationInfoBuilder<'a> { - self.inner.map_entry_count = map_entry_count; - self - } pub fn map_entries( mut self, map_entries: &'a [SpecializationMapEntry], @@ -9103,13 +8985,6 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn vertex_binding_description_count( - mut self, - vertex_binding_description_count: u32, - ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { - self.inner.vertex_binding_description_count = vertex_binding_description_count; - self - } pub fn vertex_binding_descriptions( mut self, vertex_binding_descriptions: &'a [VertexInputBindingDescription], @@ -9118,13 +8993,6 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr(); self } - pub fn vertex_attribute_description_count( - mut self, - vertex_attribute_description_count: u32, - ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { - self.inner.vertex_attribute_description_count = vertex_attribute_description_count; - self - } pub fn vertex_attribute_descriptions( mut self, vertex_attribute_descriptions: &'a [VertexInputAttributeDescription], @@ -9306,13 +9174,6 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn viewport_count( - mut self, - viewport_count: u32, - ) -> PipelineViewportStateCreateInfoBuilder<'a> { - self.inner.viewport_count = viewport_count; - self - } pub fn viewports( mut self, viewports: &'a [Viewport], @@ -9321,13 +9182,6 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { self.inner.p_viewports = viewports.as_ptr(); self } - pub fn scissor_count( - mut self, - scissor_count: u32, - ) -> PipelineViewportStateCreateInfoBuilder<'a> { - self.inner.scissor_count = scissor_count; - self - } pub fn scissors( mut self, scissors: &'a [Rect2D], @@ -9730,13 +9584,6 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { self.inner.logic_op = logic_op; self } - pub fn attachment_count( - mut self, - attachment_count: u32, - ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { - self.inner.attachment_count = attachment_count; - self - } pub fn attachments( mut self, attachments: &'a [PipelineColorBlendAttachmentState], @@ -9802,13 +9649,6 @@ impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn dynamic_state_count( - mut self, - dynamic_state_count: u32, - ) -> PipelineDynamicStateCreateInfoBuilder<'a> { - self.inner.dynamic_state_count = dynamic_state_count; - self - } pub fn dynamic_states( mut self, dynamic_states: &'a [DynamicState], @@ -10078,10 +9918,6 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn stage_count(mut self, stage_count: u32) -> GraphicsPipelineCreateInfoBuilder<'a> { - self.inner.stage_count = stage_count; - self - } pub fn stages( mut self, stages: &'a [PipelineShaderStageCreateInfo], @@ -10337,13 +10173,6 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn set_layout_count( - mut self, - set_layout_count: u32, - ) -> PipelineLayoutCreateInfoBuilder<'a> { - self.inner.set_layout_count = set_layout_count; - self - } pub fn set_layouts( mut self, set_layouts: &'a [DescriptorSetLayout], @@ -10352,13 +10181,6 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> { self.inner.p_set_layouts = set_layouts.as_ptr(); self } - pub fn push_constant_range_count( - mut self, - push_constant_range_count: u32, - ) -> PipelineLayoutCreateInfoBuilder<'a> { - self.inner.push_constant_range_count = push_constant_range_count; - self - } pub fn push_constant_ranges( mut self, push_constant_ranges: &'a [PushConstantRange], @@ -10837,10 +10659,6 @@ impl<'a> RenderPassBeginInfoBuilder<'a> { self.inner.render_area = render_area; self } - pub fn clear_value_count(mut self, clear_value_count: u32) -> RenderPassBeginInfoBuilder<'a> { - self.inner.clear_value_count = clear_value_count; - self - } pub fn clear_values( mut self, clear_values: &'a [ClearValue], @@ -11142,13 +10960,6 @@ impl<'a> SubpassDescriptionBuilder<'a> { self.inner.pipeline_bind_point = pipeline_bind_point; self } - pub fn input_attachment_count( - mut self, - input_attachment_count: u32, - ) -> SubpassDescriptionBuilder<'a> { - self.inner.input_attachment_count = input_attachment_count; - self - } pub fn input_attachments( mut self, input_attachments: &'a [AttachmentReference], @@ -11157,13 +10968,6 @@ impl<'a> SubpassDescriptionBuilder<'a> { self.inner.p_input_attachments = input_attachments.as_ptr(); self } - pub fn color_attachment_count( - mut self, - color_attachment_count: u32, - ) -> SubpassDescriptionBuilder<'a> { - self.inner.color_attachment_count = color_attachment_count; - self - } pub fn color_attachments( mut self, color_attachments: &'a [AttachmentReference], @@ -11187,13 +10991,6 @@ impl<'a> SubpassDescriptionBuilder<'a> { self.inner.p_depth_stencil_attachment = depth_stencil_attachment; self } - pub fn preserve_attachment_count( - mut self, - preserve_attachment_count: u32, - ) -> SubpassDescriptionBuilder<'a> { - self.inner.preserve_attachment_count = preserve_attachment_count; - self - } pub fn preserve_attachments( mut self, preserve_attachments: &'a [u32], @@ -11328,10 +11125,6 @@ impl<'a> RenderPassCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn attachment_count(mut self, attachment_count: u32) -> RenderPassCreateInfoBuilder<'a> { - self.inner.attachment_count = attachment_count; - self - } pub fn attachments( mut self, attachments: &'a [AttachmentDescription], @@ -11340,10 +11133,6 @@ impl<'a> RenderPassCreateInfoBuilder<'a> { self.inner.p_attachments = attachments.as_ptr(); self } - pub fn subpass_count(mut self, subpass_count: u32) -> RenderPassCreateInfoBuilder<'a> { - self.inner.subpass_count = subpass_count; - self - } pub fn subpasses( mut self, subpasses: &'a [SubpassDescription], @@ -11352,10 +11141,6 @@ impl<'a> RenderPassCreateInfoBuilder<'a> { self.inner.p_subpasses = subpasses.as_ptr(); self } - pub fn dependency_count(mut self, dependency_count: u32) -> RenderPassCreateInfoBuilder<'a> { - self.inner.dependency_count = dependency_count; - self - } pub fn dependencies( mut self, dependencies: &'a [SubpassDependency], @@ -13112,10 +12897,6 @@ impl<'a> FramebufferCreateInfoBuilder<'a> { self.inner.render_pass = render_pass; self } - pub fn attachment_count(mut self, attachment_count: u32) -> FramebufferCreateInfoBuilder<'a> { - self.inner.attachment_count = attachment_count; - self - } pub fn attachments(mut self, attachments: &'a [ImageView]) -> FramebufferCreateInfoBuilder<'a> { self.inner.attachment_count = attachments.len() as u32; self.inner.p_attachments = attachments.as_ptr(); @@ -13325,10 +13106,6 @@ impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> { } } impl<'a> SubmitInfoBuilder<'a> { - pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> SubmitInfoBuilder<'a> { - self.inner.wait_semaphore_count = wait_semaphore_count; - self - } pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> SubmitInfoBuilder<'a> { self.inner.wait_semaphore_count = wait_semaphores.len() as u32; self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); @@ -13342,10 +13119,6 @@ impl<'a> SubmitInfoBuilder<'a> { self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr(); self } - pub fn command_buffer_count(mut self, command_buffer_count: u32) -> SubmitInfoBuilder<'a> { - self.inner.command_buffer_count = command_buffer_count; - self - } pub fn command_buffers( mut self, command_buffers: &'a [CommandBuffer], @@ -13354,10 +13127,6 @@ impl<'a> SubmitInfoBuilder<'a> { self.inner.p_command_buffers = command_buffers.as_ptr(); self } - pub fn signal_semaphore_count(mut self, signal_semaphore_count: u32) -> SubmitInfoBuilder<'a> { - self.inner.signal_semaphore_count = signal_semaphore_count; - self - } pub fn signal_semaphores( mut self, signal_semaphores: &'a [Semaphore], @@ -14540,13 +14309,6 @@ impl<'a> SwapchainCreateInfoKHRBuilder<'a> { self.inner.image_sharing_mode = image_sharing_mode; self } - pub fn queue_family_index_count( - mut self, - queue_family_index_count: u32, - ) -> SwapchainCreateInfoKHRBuilder<'a> { - self.inner.queue_family_index_count = queue_family_index_count; - self - } pub fn queue_family_indices( mut self, queue_family_indices: &'a [u32], @@ -14636,10 +14398,6 @@ impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> { } } impl<'a> PresentInfoKHRBuilder<'a> { - pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> PresentInfoKHRBuilder<'a> { - self.inner.wait_semaphore_count = wait_semaphore_count; - self - } pub fn wait_semaphores( mut self, wait_semaphores: &'a [Semaphore], @@ -14648,10 +14406,6 @@ impl<'a> PresentInfoKHRBuilder<'a> { self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); self } - pub fn swapchain_count(mut self, swapchain_count: u32) -> PresentInfoKHRBuilder<'a> { - self.inner.swapchain_count = swapchain_count; - self - } pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> PresentInfoKHRBuilder<'a> { self.inner.swapchain_count = swapchains.len() as u32; self.inner.p_swapchains = swapchains.as_ptr(); @@ -14783,13 +14537,6 @@ impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> { } } impl<'a> ValidationFlagsEXTBuilder<'a> { - pub fn disabled_validation_check_count( - mut self, - disabled_validation_check_count: u32, - ) -> ValidationFlagsEXTBuilder<'a> { - self.inner.disabled_validation_check_count = disabled_validation_check_count; - self - } pub fn disabled_validation_checks( mut self, disabled_validation_checks: &'a mut [ValidationCheckEXT], @@ -15475,13 +15222,6 @@ impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { } } impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { - pub fn acquire_count( - mut self, - acquire_count: u32, - ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { - self.inner.acquire_count = acquire_count; - self - } pub fn acquire_syncs( mut self, acquire_syncs: &'a [DeviceMemory], @@ -15506,13 +15246,6 @@ impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr(); self } - pub fn release_count( - mut self, - release_count: u32, - ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { - self.inner.release_count = release_count; - self - } pub fn release_syncs( mut self, release_syncs: &'a [DeviceMemory], @@ -15818,13 +15551,6 @@ impl<'a> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { self.inner.flags = flags; self } - pub fn token_count( - mut self, - token_count: u32, - ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { - self.inner.token_count = token_count; - self - } pub fn tokens( mut self, tokens: &'a [IndirectCommandsLayoutTokenNVX], @@ -15904,13 +15630,6 @@ impl<'a> CmdProcessCommandsInfoNVXBuilder<'a> { self.inner.indirect_commands_layout = indirect_commands_layout; self } - pub fn indirect_commands_token_count( - mut self, - indirect_commands_token_count: u32, - ) -> CmdProcessCommandsInfoNVXBuilder<'a> { - self.inner.indirect_commands_token_count = indirect_commands_token_count; - self - } pub fn indirect_commands_tokens( mut self, indirect_commands_tokens: &'a [IndirectCommandsTokenNVX], @@ -16080,10 +15799,6 @@ impl<'a> ::std::ops::Deref for ObjectTableCreateInfoNVXBuilder<'a> { } } impl<'a> ObjectTableCreateInfoNVXBuilder<'a> { - pub fn object_count(mut self, object_count: u32) -> ObjectTableCreateInfoNVXBuilder<'a> { - self.inner.object_count = object_count; - self - } pub fn object_entry_types( mut self, object_entry_types: &'a [ObjectEntryTypeNVX], @@ -16987,10 +16702,6 @@ impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> { } } impl<'a> PresentRegionsKHRBuilder<'a> { - pub fn swapchain_count(mut self, swapchain_count: u32) -> PresentRegionsKHRBuilder<'a> { - self.inner.swapchain_count = swapchain_count; - self - } pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> PresentRegionsKHRBuilder<'a> { self.inner.swapchain_count = regions.len() as u32; self.inner.p_regions = regions.as_ptr(); @@ -17033,10 +16744,6 @@ impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> { } } impl<'a> PresentRegionKHRBuilder<'a> { - pub fn rectangle_count(mut self, rectangle_count: u32) -> PresentRegionKHRBuilder<'a> { - self.inner.rectangle_count = rectangle_count; - self - } pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> PresentRegionKHRBuilder<'a> { self.inner.rectangle_count = rectangles.len() as u32; self.inner.p_rectangles = rectangles.as_ptr(); @@ -18021,13 +17728,6 @@ impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { } } impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { - pub fn acquire_count( - mut self, - acquire_count: u32, - ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { - self.inner.acquire_count = acquire_count; - self - } pub fn acquire_syncs( mut self, acquire_syncs: &'a [DeviceMemory], @@ -18052,13 +17752,6 @@ impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr(); self } - pub fn release_count( - mut self, - release_count: u32, - ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { - self.inner.release_count = release_count; - self - } pub fn release_syncs( mut self, release_syncs: &'a [DeviceMemory], @@ -18410,13 +18103,6 @@ impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> { } } impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { - pub fn wait_semaphore_values_count( - mut self, - wait_semaphore_values_count: u32, - ) -> D3D12FenceSubmitInfoKHRBuilder<'a> { - self.inner.wait_semaphore_values_count = wait_semaphore_values_count; - self - } pub fn wait_semaphore_values( mut self, wait_semaphore_values: &'a [u64], @@ -18425,13 +18111,6 @@ impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); self } - pub fn signal_semaphore_values_count( - mut self, - signal_semaphore_values_count: u32, - ) -> D3D12FenceSubmitInfoKHRBuilder<'a> { - self.inner.signal_semaphore_values_count = signal_semaphore_values_count; - self - } pub fn signal_semaphore_values( mut self, signal_semaphore_values: &'a [u64], @@ -19225,22 +18904,11 @@ impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> { } } impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { - pub fn subpass_count(mut self, subpass_count: u32) -> RenderPassMultiviewCreateInfoBuilder<'a> { - self.inner.subpass_count = subpass_count; - self - } pub fn view_masks(mut self, view_masks: &'a [u32]) -> RenderPassMultiviewCreateInfoBuilder<'a> { self.inner.subpass_count = view_masks.len() as u32; self.inner.p_view_masks = view_masks.as_ptr(); self } - pub fn dependency_count( - mut self, - dependency_count: u32, - ) -> RenderPassMultiviewCreateInfoBuilder<'a> { - self.inner.dependency_count = dependency_count; - self - } pub fn view_offsets( mut self, view_offsets: &'a [i32], @@ -19249,13 +18917,6 @@ impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { self.inner.p_view_offsets = view_offsets.as_ptr(); self } - pub fn correlation_mask_count( - mut self, - correlation_mask_count: u32, - ) -> RenderPassMultiviewCreateInfoBuilder<'a> { - self.inner.correlation_mask_count = correlation_mask_count; - self - } pub fn correlation_masks( mut self, correlation_masks: &'a [u32], @@ -19787,13 +19448,6 @@ impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> { } } impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> { - pub fn device_index_count( - mut self, - device_index_count: u32, - ) -> BindBufferMemoryDeviceGroupInfoBuilder<'a> { - self.inner.device_index_count = device_index_count; - self - } pub fn device_indices( mut self, device_indices: &'a [u32], @@ -19902,13 +19556,6 @@ impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> { } } impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { - pub fn device_index_count( - mut self, - device_index_count: u32, - ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> { - self.inner.device_index_count = device_index_count; - self - } pub fn device_indices( mut self, device_indices: &'a [u32], @@ -19917,13 +19564,6 @@ impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { self.inner.p_device_indices = device_indices.as_ptr(); self } - pub fn split_instance_bind_region_count( - mut self, - split_instance_bind_region_count: u32, - ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> { - self.inner.split_instance_bind_region_count = split_instance_bind_region_count; - self - } pub fn split_instance_bind_regions( mut self, split_instance_bind_regions: &'a [Rect2D], @@ -19979,13 +19619,6 @@ impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> { self.inner.device_mask = device_mask; self } - pub fn device_render_area_count( - mut self, - device_render_area_count: u32, - ) -> DeviceGroupRenderPassBeginInfoBuilder<'a> { - self.inner.device_render_area_count = device_render_area_count; - self - } pub fn device_render_areas( mut self, device_render_areas: &'a [Rect2D], @@ -20086,13 +19719,6 @@ impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> { } } impl<'a> DeviceGroupSubmitInfoBuilder<'a> { - pub fn wait_semaphore_count( - mut self, - wait_semaphore_count: u32, - ) -> DeviceGroupSubmitInfoBuilder<'a> { - self.inner.wait_semaphore_count = wait_semaphore_count; - self - } pub fn wait_semaphore_device_indices( mut self, wait_semaphore_device_indices: &'a [u32], @@ -20101,13 +19727,6 @@ impl<'a> DeviceGroupSubmitInfoBuilder<'a> { self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr(); self } - pub fn command_buffer_count( - mut self, - command_buffer_count: u32, - ) -> DeviceGroupSubmitInfoBuilder<'a> { - self.inner.command_buffer_count = command_buffer_count; - self - } pub fn command_buffer_device_masks( mut self, command_buffer_device_masks: &'a [u32], @@ -20116,13 +19735,6 @@ impl<'a> DeviceGroupSubmitInfoBuilder<'a> { self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr(); self } - pub fn signal_semaphore_count( - mut self, - signal_semaphore_count: u32, - ) -> DeviceGroupSubmitInfoBuilder<'a> { - self.inner.signal_semaphore_count = signal_semaphore_count; - self - } pub fn signal_semaphore_device_indices( mut self, signal_semaphore_device_indices: &'a [u32], @@ -20446,10 +20058,6 @@ impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> { } } impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> { - pub fn swapchain_count(mut self, swapchain_count: u32) -> DeviceGroupPresentInfoKHRBuilder<'a> { - self.inner.swapchain_count = swapchain_count; - self - } pub fn device_masks(mut self, device_masks: &'a [u32]) -> DeviceGroupPresentInfoKHRBuilder<'a> { self.inner.swapchain_count = device_masks.len() as u32; self.inner.p_device_masks = device_masks.as_ptr(); @@ -20503,13 +20111,6 @@ impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> { } } impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> { - pub fn physical_device_count( - mut self, - physical_device_count: u32, - ) -> DeviceGroupDeviceCreateInfoBuilder<'a> { - self.inner.physical_device_count = physical_device_count; - self - } pub fn physical_devices( mut self, physical_devices: &'a [PhysicalDevice], @@ -20690,13 +20291,6 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn descriptor_update_entry_count( - mut self, - descriptor_update_entry_count: u32, - ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { - self.inner.descriptor_update_entry_count = descriptor_update_entry_count; - self - } pub fn descriptor_update_entries( mut self, descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry], @@ -21014,10 +20608,6 @@ impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> { } } impl<'a> PresentTimesInfoGOOGLEBuilder<'a> { - pub fn swapchain_count(mut self, swapchain_count: u32) -> PresentTimesInfoGOOGLEBuilder<'a> { - self.inner.swapchain_count = swapchain_count; - self - } pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> PresentTimesInfoGOOGLEBuilder<'a> { self.inner.swapchain_count = times.len() as u32; self.inner.p_times = times.as_ptr(); @@ -21251,13 +20841,6 @@ impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable; self } - pub fn viewport_count( - mut self, - viewport_count: u32, - ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { - self.inner.viewport_count = viewport_count; - self - } pub fn viewport_w_scalings( mut self, viewport_w_scalings: &'a [ViewportWScalingNV], @@ -21363,13 +20946,6 @@ impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { self.inner.flags = flags; self } - pub fn viewport_count( - mut self, - viewport_count: u32, - ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { - self.inner.viewport_count = viewport_count; - self - } pub fn viewport_swizzles( mut self, viewport_swizzles: &'a [ViewportSwizzleNV], @@ -21483,13 +21059,6 @@ impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { self.inner.discard_rectangle_mode = discard_rectangle_mode; self } - pub fn discard_rectangle_count( - mut self, - discard_rectangle_count: u32, - ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { - self.inner.discard_rectangle_count = discard_rectangle_count; - self - } pub fn discard_rectangles( mut self, discard_rectangles: &'a [Rect2D], @@ -21633,13 +21202,6 @@ impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder< } } impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { - pub fn aspect_reference_count( - mut self, - aspect_reference_count: u32, - ) -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { - self.inner.aspect_reference_count = aspect_reference_count; - self - } pub fn aspect_references( mut self, aspect_references: &'a [InputAttachmentAspectReference], @@ -23457,13 +23019,6 @@ impl<'a> SampleLocationsInfoEXTBuilder<'a> { self.inner.sample_location_grid_size = sample_location_grid_size; self } - pub fn sample_locations_count( - mut self, - sample_locations_count: u32, - ) -> SampleLocationsInfoEXTBuilder<'a> { - self.inner.sample_locations_count = sample_locations_count; - self - } pub fn sample_locations( mut self, sample_locations: &'a [SampleLocationEXT], @@ -23600,14 +23155,6 @@ impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> } } impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { - pub fn attachment_initial_sample_locations_count( - mut self, - attachment_initial_sample_locations_count: u32, - ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { - self.inner.attachment_initial_sample_locations_count = - attachment_initial_sample_locations_count; - self - } pub fn attachment_initial_sample_locations( mut self, attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT], @@ -23618,13 +23165,6 @@ impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { attachment_initial_sample_locations.as_ptr(); self } - pub fn post_subpass_sample_locations_count( - mut self, - post_subpass_sample_locations_count: u32, - ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { - self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations_count; - self - } pub fn post_subpass_sample_locations( mut self, post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT], @@ -24133,13 +23673,6 @@ impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable; self } - pub fn coverage_modulation_table_count( - mut self, - coverage_modulation_table_count: u32, - ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { - self.inner.coverage_modulation_table_count = coverage_modulation_table_count; - self - } pub fn coverage_modulation_table( mut self, coverage_modulation_table: &'a [c_float], @@ -24189,13 +23722,6 @@ impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoKHRBuilder<'a> { } } impl<'a> ImageFormatListCreateInfoKHRBuilder<'a> { - pub fn view_format_count( - mut self, - view_format_count: u32, - ) -> ImageFormatListCreateInfoKHRBuilder<'a> { - self.inner.view_format_count = view_format_count; - self - } pub fn view_formats( mut self, view_formats: &'a [Format], @@ -25084,13 +24610,6 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { self.inner.p_message = message.as_ptr(); self } - pub fn queue_label_count( - mut self, - queue_label_count: u32, - ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { - self.inner.queue_label_count = queue_label_count; - self - } pub fn queue_labels( mut self, queue_labels: &'a mut [DebugUtilsLabelEXT], @@ -25099,13 +24618,6 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { self.inner.p_queue_labels = queue_labels.as_mut_ptr(); self } - pub fn cmd_buf_label_count( - mut self, - cmd_buf_label_count: u32, - ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { - self.inner.cmd_buf_label_count = cmd_buf_label_count; - self - } pub fn cmd_buf_labels( mut self, cmd_buf_labels: &'a mut [DebugUtilsLabelEXT], @@ -25114,13 +24626,6 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { self.inner.p_cmd_buf_labels = cmd_buf_labels.as_mut_ptr(); self } - pub fn object_count( - mut self, - object_count: u32, - ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { - self.inner.object_count = object_count; - self - } pub fn objects( mut self, objects: &'a mut [DebugUtilsObjectNameInfoEXT], @@ -26196,13 +25701,6 @@ impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoEXTBuild } } impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { - pub fn binding_count( - mut self, - binding_count: u32, - ) -> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { - self.inner.binding_count = binding_count; - self - } pub fn binding_flags( mut self, binding_flags: &'a [DescriptorBindingFlagsEXT], @@ -26252,13 +25750,6 @@ impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoE } } impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { - pub fn descriptor_set_count( - mut self, - descriptor_set_count: u32, - ) -> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { - self.inner.descriptor_set_count = descriptor_set_count; - self - } pub fn descriptor_counts( mut self, descriptor_counts: &'a [u32], @@ -26391,13 +25882,6 @@ impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuild } } impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { - pub fn vertex_binding_divisor_count( - mut self, - vertex_binding_divisor_count: u32, - ) -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { - self.inner.vertex_binding_divisor_count = vertex_binding_divisor_count; - self - } pub fn vertex_binding_divisors( mut self, vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT], @@ -38591,6 +38075,349 @@ fn display_flags( } Ok(()) } +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38607,11 +38434,11 @@ impl fmt::Display for SamplerAddressMode { } } } -impl fmt::Display for VertexInputRate { +impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), _ => None, }; if let Some(x) = name { @@ -38621,15 +38448,653 @@ impl fmt::Display for VertexInputRate { } } } -impl fmt::Display for ObjectEntryUsageFlagsNVX { +impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for DescriptorType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38653,6 +39118,164 @@ impl fmt::Display for DescriptorType { } } } +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38673,28 +39296,103 @@ impl fmt::Display for StencilOp { } } } -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), _ => None, }; if let Some(x) = name { @@ -38716,45 +39414,144 @@ impl fmt::Display for SwapchainCreateFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BufferCreateFlags { +impl fmt::Display for SurfaceCounterFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SurfaceTransformFlagsKHR { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39195,50 +39992,6 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for QueryPipelineStatisticFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -39286,898 +40039,22 @@ impl fmt::Display for QueryPipelineStatisticFlags { QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, "COMPUTE_SHADER_INVOCATIONS", ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageUsageFlags { +impl fmt::Display for DeviceEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } impl fmt::Display for ExternalMemoryFeatureFlags { @@ -40199,46 +40076,35 @@ impl fmt::Display for ExternalMemoryFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectType { +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -40296,168 +40162,83 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for QueryControlFlags { +impl fmt::Display for CommandBufferResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageCreateFlags { +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( @@ -40480,209 +40261,84 @@ impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrModelConversion { +impl fmt::Display for ImageType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), _ => None, }; if let Some(x) = name { @@ -40735,40 +40391,11 @@ impl fmt::Display for PipelineStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FrontFace { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -40784,156 +40411,206 @@ impl fmt::Display for SparseMemoryBindFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { +impl fmt::Display for CullModeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DependencyFlags { +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AccessFlags { +impl fmt::Display for SurfaceTransformFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", ), (AccessFlags::INDEX_READ.0, "INDEX_READ"), ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", ), (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", ), (AccessFlags::SHADER_READ.0, "SHADER_READ"), (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ ( AccessFlags::COLOR_ATTACHMENT_WRITE.0, "COLOR_ATTACHMENT_WRITE", @@ -40968,342 +40645,3 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 32a805f..3844e2c 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1292,7 +1292,24 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { _ => None, }); + let count_members: Vec = members.clone().filter_map(|field| { + if field.array.is_some() { + if let Some(ref array_size) = field.size { + if !array_size.starts_with("latexmath") && array_size.ends_with("Count") { + return Some((*array_size).clone()); + } + } + } + None + }).collect(); + let setters = members.clone().filter_map(|field| { + if let Some(name) = field.name.as_ref() { + if count_members.iter().any(|n| *n == *name) { + return None; + } + } + let param_ident = field.param_ident(); let param_ty_tokens = field.type_tokens(); From 4072cc39e86496f70014d8a261f1c598b8c274c4 Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Tue, 23 Oct 2018 23:59:53 +0200 Subject: [PATCH 104/122] Fix filtering of _count member fields --- ash/src/vk.rs | 3449 ++++++++++++++++++++++-------------------- generator/src/lib.rs | 2 +- 2 files changed, 1790 insertions(+), 1661 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index edbb248..26b16d9 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -8681,10 +8681,6 @@ impl<'a> SpecializationInfoBuilder<'a> { self.inner.p_map_entries = map_entries.as_ptr(); self } - pub fn data_size(mut self, data_size: usize) -> SpecializationInfoBuilder<'a> { - self.inner.data_size = data_size; - self - } pub fn data(mut self, data: &'a [c_void]) -> SpecializationInfoBuilder<'a> { self.inner.data_size = data.len() as usize; self.inner.p_data = data.as_ptr(); @@ -10062,13 +10058,6 @@ impl<'a> PipelineCacheCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn initial_data_size( - mut self, - initial_data_size: usize, - ) -> PipelineCacheCreateInfoBuilder<'a> { - self.inner.initial_data_size = initial_data_size; - self - } pub fn initial_data( mut self, initial_data: &'a [c_void], @@ -14714,10 +14703,6 @@ impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { self.inner.tag_name = tag_name; self } - pub fn tag_size(mut self, tag_size: usize) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { - self.inner.tag_size = tag_size; - self - } pub fn tag(mut self, tag: &'a [c_void]) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { self.inner.tag_size = tag.len() as usize; self.inner.p_tag = tag.as_ptr(); @@ -23780,13 +23765,6 @@ impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { self.inner.flags = flags; self } - pub fn initial_data_size( - mut self, - initial_data_size: usize, - ) -> ValidationCacheCreateInfoEXTBuilder<'a> { - self.inner.initial_data_size = initial_data_size; - self - } pub fn initial_data( mut self, initial_data: &'a [c_void], @@ -24369,10 +24347,6 @@ impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { self.inner.tag_name = tag_name; self } - pub fn tag_size(mut self, tag_size: usize) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { - self.inner.tag_size = tag_size; - self - } pub fn tag(mut self, tag: &'a [c_void]) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { self.inner.tag_size = tag.len() as usize; self.inner.p_tag = tag.as_ptr(); @@ -38075,329 +38049,60 @@ fn display_flags( } Ok(()) } -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { +impl fmt::Display for SampleCountFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -38418,13 +38123,14 @@ impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for SystemAllocationScope { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), _ => None, }; if let Some(x) = name { @@ -38434,175 +38140,12 @@ impl fmt::Display for SamplerAddressMode { } } } -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for FormatFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ConservativeRasterizationModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38618,40 +38161,6 @@ impl fmt::Display for ConservativeRasterizationModeEXT { } } } -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -38667,17 +38176,32 @@ impl fmt::Display for ExternalSemaphoreFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompareOp { +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), _ => None, }; if let Some(x) = name { @@ -38687,43 +38211,11 @@ impl fmt::Display for CompareOp { } } } -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SharingMode { +impl fmt::Display for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), _ => None, }; if let Some(x) = name { @@ -38733,32 +38225,39 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for ImageUsageFlags { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationCheckEXT { +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), _ => None, }; if let Some(x) = name { @@ -38768,29 +38267,6 @@ impl fmt::Display for ValidationCheckEXT { } } } -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38830,9 +38306,639 @@ impl fmt::Display for DescriptorPoolCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceQueueCreateFlags { +impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; display_flags(f, KNOWN, self.0) } } @@ -38899,260 +39005,6 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for VendorId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39168,11 +39020,10 @@ impl fmt::Display for VendorId { } } } -impl fmt::Display for ChromaLocation { +impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), + Self::EXECUTABLE => Some("EXECUTABLE"), _ => None, }; if let Some(x) = name { @@ -39182,11 +39033,13 @@ impl fmt::Display for ChromaLocation { } } } -impl fmt::Display for AttachmentStoreOp { +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), _ => None, }; if let Some(x) = name { @@ -39196,144 +39049,43 @@ impl fmt::Display for AttachmentStoreOp { } } } -impl fmt::Display for DependencyFlags { +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BlendOverlapEXT { +impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), _ => None, }; if let Some(x) = name { @@ -39374,6 +39126,137 @@ impl fmt::Display for PolygonMode { } } } +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39402,18 +39285,87 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for SwapchainCreateFlagsKHR { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for SurfaceCounterFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -39429,53 +39381,501 @@ impl fmt::Display for SurfaceCounterFlagsEXT { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for StencilFaceFlags { +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SemaphoreImportFlags { +impl fmt::Display for BorderColor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for ImageAspectFlags { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { @@ -39501,28 +39901,129 @@ impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PeerMemoryFeatureFlags { +impl fmt::Display for ImageAspectFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryAllocateFlags { +impl fmt::Display for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerMipmapMode { +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), _ => None, }; if let Some(x) = name { @@ -39532,17 +40033,248 @@ impl fmt::Display for SamplerMipmapMode { } } } -impl fmt::Display for QueryControlFlags { +impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerMipmapMode { +impl fmt::Display for FrontFace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -39992,527 +40724,6 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for CoverageModulationModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40529,54 +40740,11 @@ impl fmt::Display for CoverageModulationModeNV { } } } -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { +impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), _ => None, }; if let Some(x) = name { @@ -40586,62 +40754,23 @@ impl fmt::Display for FrontFace { } } } -impl fmt::Display for BufferUsageFlags { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; display_flags(f, KNOWN, self.0) } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 3844e2c..8360363 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1295,7 +1295,7 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { let count_members: Vec = members.clone().filter_map(|field| { if field.array.is_some() { if let Some(ref array_size) = field.size { - if !array_size.starts_with("latexmath") && array_size.ends_with("Count") { + if !array_size.starts_with("latexmath") { return Some((*array_size).clone()); } } From 8951ea021f44183a1c2a0d4bb75667c4d01a15f0 Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Wed, 24 Oct 2018 00:20:54 +0200 Subject: [PATCH 105/122] rebase --- ash/src/vk.rs | 3259 ++++++++++++++++++++++++------------------------- 1 file changed, 1625 insertions(+), 1634 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 26b16d9..24ff4e3 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -38049,6 +38049,561 @@ fn display_flags( } Ok(()) } +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -38076,33 +38631,12 @@ impl fmt::Display for ExternalSemaphoreHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -38112,25 +38646,12 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), _ => None, }; if let Some(x) = name { @@ -38140,68 +38661,17 @@ impl fmt::Display for SystemAllocationScope { } } } -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), + Self::KEEP => Some("KEEP"), Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), _ => None, }; if let Some(x) = name { @@ -38211,176 +38681,66 @@ impl fmt::Display for ComponentSwizzle { } } } -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { +impl fmt::Display for ImageUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { +impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -38390,62 +38750,19 @@ impl fmt::Display for DescriptorUpdateTemplateType { } } } -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for SemaphoreImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageTiling { +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -38469,11 +38786,55 @@ impl fmt::Display for PipelineBindPoint { } } } -impl fmt::Display for RasterizationOrderAMD { +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), _ => None, }; if let Some(x) = name { @@ -38483,10 +38844,63 @@ impl fmt::Display for RasterizationOrderAMD { } } } -impl fmt::Display for AttachmentStoreOp { +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STORE => Some("STORE"), + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), Self::DONT_CARE => Some("DONT_CARE"), _ => None, }; @@ -38497,52 +38911,27 @@ impl fmt::Display for AttachmentStoreOp { } } } -impl fmt::Display for SurfaceTransformFlagsKHR { +impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for BufferUsageFlags { +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } @@ -38612,418 +39001,11 @@ impl fmt::Display for SubpassContents { } } } -impl fmt::Display for ImageType { +impl fmt::Display for CommandBufferLevel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), _ => None, }; if let Some(x) = name { @@ -39049,338 +39031,6 @@ impl fmt::Display for QueueGlobalPriorityEXT { } } } -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39648,109 +39298,22 @@ impl fmt::Display for Format { } } } -impl fmt::Display for PipelineCreateFlags { +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Filter { +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::NEAREST => Some("NEAREST"), Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -39760,31 +39323,12 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -39794,48 +39338,41 @@ impl fmt::Display for SamplerReductionModeEXT { } } } -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BorderColor { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), _ => None, }; if let Some(x) = name { @@ -39845,257 +39382,17 @@ impl fmt::Display for BorderColor { } } } -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for FenceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DiscardRectangleModeEXT { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), _ => None, }; if let Some(x) = name { @@ -40105,67 +39402,74 @@ impl fmt::Display for DiscardRectangleModeEXT { } } } -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { +impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), _ => None, }; if let Some(x) = name { @@ -40175,53 +39479,6 @@ impl fmt::Display for DisplayPowerStateEXT { } } } -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DeviceEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40235,46 +39492,53 @@ impl fmt::Display for DeviceEventTypeEXT { } } } -impl fmt::Display for ObjectType { +impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -40724,6 +39988,374 @@ impl fmt::Display for StructureType { } } } +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for CoverageModulationModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40740,11 +40372,11 @@ impl fmt::Display for CoverageModulationModeNV { } } } -impl fmt::Display for IndexType { +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), _ => None, }; if let Some(x) = name { @@ -40754,23 +40386,382 @@ impl fmt::Display for IndexType { } } } -impl fmt::Display for ValidationCheckEXT { +impl fmt::Display for StencilFaceFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; display_flags(f, KNOWN, self.0) } } From 70acea569dcceffac44bce2a2e73c7c1317f7779 Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Wed, 24 Oct 2018 16:00:16 +0200 Subject: [PATCH 106/122] Handle ShaderModuleCreateInfo code properly --- generator/src/lib.rs | 35 +++++++++++++++++++++++++++-------- 1 file changed, 27 insertions(+), 8 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 8360363..57193c4 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1292,7 +1292,8 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { _ => None, }); - let count_members: Vec = members.clone().filter_map(|field| { + let filter_members: Vec = members.clone().filter_map(|field| { + // Associated _count members if field.array.is_some() { if let Some(ref array_size) = field.size { if !array_size.starts_with("latexmath") { @@ -1300,16 +1301,16 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { } } } + + // VkShaderModuleCreateInfo requiers a custom setter + if field.name.as_ref().unwrap() == "codeSize" { + return Some(field.name.clone().unwrap()); + } + None }).collect(); let setters = members.clone().filter_map(|field| { - if let Some(name) = field.name.as_ref() { - if count_members.iter().any(|n| *n == *name) { - return None; - } - } - let param_ident = field.param_ident(); let param_ty_tokens = field.type_tokens(); @@ -1327,8 +1328,26 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { }; let param_ident_short = Term::intern(¶m_ident_short); + if let Some(name) = field.name.as_ref() { + // Fiter + if filter_members.iter().any(|n| *n == *name) { + return None; + } + + // Unique cases + if name == "pCode" { + return Some(quote!{ + pub fn code(mut self, code: &'a [u8]) -> #name_builder<'a> { + self.inner.code_size = code.len(); + self.inner.p_code = code.as_ptr() as *const u32; + self + } + }); + } + } + // TODO: Improve in future when https://github.com/rust-lang/rust/issues/53667 is merged - if param_ident.to_string().starts_with("p_") || param_ident.to_string().starts_with("pp_") { + if param_ident_string.starts_with("p_") || param_ident_string.starts_with("pp_") { let param_ty_string = param_ty_tokens.to_string(); if param_ty_string == "*const c_char" { From deb83f4b2e57f3c435bd0eeee1598a63ed340bda Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Fri, 26 Oct 2018 15:49:12 +0200 Subject: [PATCH 107/122] fix *const in some setters --- ash/src/vk.rs | 3575 +++++++++++++++++++++--------------------- generator/src/lib.rs | 2 +- 2 files changed, 1787 insertions(+), 1790 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 24ff4e3..9268e20 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -5930,7 +5930,7 @@ impl<'a> DeviceCreateInfoBuilder<'a> { } pub fn enabled_features( mut self, - enabled_features: *const PhysicalDeviceFeatures, + enabled_features: &'a PhysicalDeviceFeatures, ) -> DeviceCreateInfoBuilder<'a> { self.inner.p_enabled_features = enabled_features; self @@ -8296,12 +8296,9 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn code_size(mut self, code_size: usize) -> ShaderModuleCreateInfoBuilder<'a> { - self.inner.code_size = code_size; - self - } - pub fn code(mut self, code: *const u32) -> ShaderModuleCreateInfoBuilder<'a> { - self.inner.p_code = code; + pub fn code(mut self, code: &'a [u8]) -> ShaderModuleCreateInfoBuilder<'a> { + self.inner.code_size = code.len(); + self.inner.p_code = code.as_ptr() as *const u32; self } pub fn build(self) -> ShaderModuleCreateInfo { @@ -9403,7 +9400,7 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { } pub fn sample_mask( mut self, - sample_mask: *const SampleMask, + sample_mask: &'a SampleMask, ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { self.inner.p_sample_mask = sample_mask; self @@ -10975,7 +10972,7 @@ impl<'a> SubpassDescriptionBuilder<'a> { } pub fn depth_stencil_attachment( mut self, - depth_stencil_attachment: *const AttachmentReference, + depth_stencil_attachment: &'a AttachmentReference, ) -> SubpassDescriptionBuilder<'a> { self.inner.p_depth_stencil_attachment = depth_stencil_attachment; self @@ -15147,7 +15144,7 @@ impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> { impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> { pub fn attributes( mut self, - attributes: *const SECURITY_ATTRIBUTES, + attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportMemoryWin32HandleInfoNVBuilder<'a> { self.inner.p_attributes = attributes; self @@ -17404,7 +17401,7 @@ impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> { impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> { pub fn attributes( mut self, - attributes: *const SECURITY_ATTRIBUTES, + attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { self.inner.p_attributes = attributes; self @@ -18030,7 +18027,7 @@ impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { pub fn attributes( mut self, - attributes: *const SECURITY_ATTRIBUTES, + attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { self.inner.p_attributes = attributes; self @@ -18543,7 +18540,7 @@ impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> { impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> { pub fn attributes( mut self, - attributes: *const SECURITY_ATTRIBUTES, + attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportFenceWin32HandleInfoKHRBuilder<'a> { self.inner.p_attributes = attributes; self @@ -20683,7 +20680,7 @@ impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.flags = flags; self } - pub fn view(mut self, view: *const c_void) -> IOSSurfaceCreateInfoMVKBuilder<'a> { + pub fn view(mut self, view: &'a c_void) -> IOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.p_view = view; self } @@ -20735,7 +20732,7 @@ impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.flags = flags; self } - pub fn view(mut self, view: *const c_void) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + pub fn view(mut self, view: &'a c_void) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.p_view = view; self } @@ -38049,33 +38046,13 @@ fn display_flags( } Ok(()) } -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { +impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -38085,10 +38062,24 @@ impl fmt::Display for VendorId { } } } -impl fmt::Display for DisplayEventTypeEXT { +impl fmt::Display for ColorSpaceKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), _ => None, }; if let Some(x) = name { @@ -38098,46 +38089,75 @@ impl fmt::Display for DisplayEventTypeEXT { } } } -impl fmt::Display for ObjectType { +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -38147,12 +38167,12 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for SamplerReductionModeEXT { +impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -38162,16 +38182,181 @@ impl fmt::Display for SamplerReductionModeEXT { } } } -impl fmt::Display for SparseMemoryBindFlags { +impl fmt::Display for ImageUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorUpdateTemplateType { +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -38244,573 +38429,57 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for DescriptorBindingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", ), ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", ), ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", ), ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", ), ]; display_flags(f, KNOWN, self.0) @@ -38844,94 +38513,12 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), ]; display_flags(f, KNOWN, self.0) } @@ -38987,333 +38574,40 @@ impl fmt::Display for QueryPipelineStatisticFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassContents { +impl fmt::Display for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CommandBufferLevel { +impl fmt::Display for AttachmentDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { +impl fmt::Display for BufferCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerMipmapMode { +impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), _ => None, }; if let Some(x) = name { @@ -39323,12 +38617,11 @@ impl fmt::Display for SamplerMipmapMode { } } } -impl fmt::Display for ShaderInfoTypeAMD { +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), _ => None, }; if let Some(x) = name { @@ -39338,216 +38631,103 @@ impl fmt::Display for ShaderInfoTypeAMD { } } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { +impl fmt::Display for AttachmentStoreOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39988,28 +39168,54 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for CommandPoolCreateFlags { +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PresentModeKHR { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -40019,46 +39225,936 @@ impl fmt::Display for PresentModeKHR { } } } -impl fmt::Display for ColorSpaceKHR { +impl fmt::Display for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BufferCreateFlags { +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), ]; display_flags(f, KNOWN, self.0) } @@ -40078,6 +40174,307 @@ impl fmt::Display for DebugReportFlagsEXT { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for BlendFactor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40109,11 +40506,15 @@ impl fmt::Display for BlendFactor { } } } -impl fmt::Display for ImageTiling { +impl fmt::Display for PresentModeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), _ => None, }; if let Some(x) = name { @@ -40123,12 +40524,58 @@ impl fmt::Display for ImageTiling { } } } -impl fmt::Display for BlendOverlapEXT { +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -40138,34 +40585,23 @@ impl fmt::Display for BlendOverlapEXT { } } } -impl fmt::Display for ImageAspectFlags { +impl fmt::Display for FenceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubgroupFeatureFlags { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } impl fmt::Display for MemoryPropertyFlags { @@ -40181,17 +40617,26 @@ impl fmt::Display for MemoryPropertyFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { +impl fmt::Display for DescriptorSetLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrRange { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -40201,11 +40646,22 @@ impl fmt::Display for SamplerYcbcrRange { } } } -impl fmt::Display for TessellationDomainOrigin { +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -40215,61 +40671,6 @@ impl fmt::Display for TessellationDomainOrigin { } } } -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40327,441 +40728,37 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { +impl fmt::Display for SurfaceTransformFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalSemaphoreFeatureFlags { +impl fmt::Display for SurfaceCounterFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; display_flags(f, KNOWN, self.0) } } diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 57193c4..4c03705 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1411,7 +1411,7 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { } } - if param_ty_string.starts_with("*const ") && param_ty_string.ends_with("Info") { + if param_ty_string.starts_with("*const ") { let slice_param_ty_tokens = "&'a ".to_string() + ¶m_ty_string[7..]; let slice_param_ty_tokens = Term::intern(&slice_param_ty_tokens); return Some(quote!{ From b0864e5c44e64bbe80ca28cc5203778e78e09956 Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Mon, 29 Oct 2018 13:32:17 +0100 Subject: [PATCH 108/122] Change code function of VkShaderModule to take &[u32] according to spec --- generator/src/lib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 4c03705..f061e6a 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1337,8 +1337,8 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { // Unique cases if name == "pCode" { return Some(quote!{ - pub fn code(mut self, code: &'a [u8]) -> #name_builder<'a> { - self.inner.code_size = code.len(); + pub fn code(mut self, code: &'a [u32]) -> #name_builder<'a> { + self.inner.code_size = code.len() * 4; self.inner.p_code = code.as_ptr() as *const u32; self } From ae3a17e807a3dd2db124135e65e87b57624508b1 Mon Sep 17 00:00:00 2001 From: Matus Talcik Date: Mon, 29 Oct 2018 14:24:46 +0100 Subject: [PATCH 109/122] regenerate vk.rs --- ash/src/vk.rs | 3608 ++++++++++++++++++++++++------------------------- 1 file changed, 1804 insertions(+), 1804 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 9268e20..da47909 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -8296,8 +8296,8 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn code(mut self, code: &'a [u8]) -> ShaderModuleCreateInfoBuilder<'a> { - self.inner.code_size = code.len(); + pub fn code(mut self, code: &'a [u32]) -> ShaderModuleCreateInfoBuilder<'a> { + self.inner.code_size = code.len() * 4; self.inner.p_code = code.as_ptr() as *const u32; self } @@ -38046,13 +38046,23 @@ fn display_flags( } Ok(()) } -impl fmt::Display for PolygonMode { +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -38062,24 +38072,11 @@ impl fmt::Display for PolygonMode { } } } -impl fmt::Display for ColorSpaceKHR { +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), _ => None, }; if let Some(x) = name { @@ -38089,6 +38086,288 @@ impl fmt::Display for ColorSpaceKHR { } } } +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -38112,158 +38391,85 @@ impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { +impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", ), ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SampleCountFlags { +impl fmt::Display for SubgroupFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryAllocateFlags { +impl fmt::Display for DeviceQueueCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for TessellationDomainOrigin { +impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), _ => None, }; if let Some(x) = name { @@ -38273,20 +38479,68 @@ impl fmt::Display for TessellationDomainOrigin { } } } -impl fmt::Display for CommandBufferResetFlags { +impl fmt::Display for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrRange { +impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), _ => None, }; if let Some(x) = name { @@ -38319,6 +38573,672 @@ impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for SystemAllocationScope { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38336,6 +39256,290 @@ impl fmt::Display for SystemAllocationScope { } } } +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38349,14 +39553,11 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), _ => None, }; if let Some(x) = name { @@ -38366,6 +39567,40 @@ impl fmt::Display for PhysicalDeviceType { } } } +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38429,29 +39664,45 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -38466,6 +39717,310 @@ impl fmt::Display for DeviceGroupPresentModeFlagsKHR { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -38485,25 +40040,10 @@ impl fmt::Display for ExternalMemoryFeatureFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for LogicOp { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), _ => None, }; if let Some(x) = name { @@ -38513,90 +40053,6 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38617,11 +40073,12 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for SharingMode { +impl fmt::Display for ImageType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), _ => None, }; if let Some(x) = name { @@ -38631,17 +40088,12 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for CompareOp { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -38651,21 +40103,54 @@ impl fmt::Display for CompareOp { } } } -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for ImageAspectFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for AttachmentStoreOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -38680,54 +40165,6 @@ impl fmt::Display for AttachmentStoreOp { } } } -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39168,591 +40605,32 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", ), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { +impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39802,48 +40680,13 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), ]; display_flags(f, KNOWN, self.0) } @@ -39862,815 +40705,6 @@ impl fmt::Display for CommandBufferLevel { } } } -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40728,37 +40762,3 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} From adf571c95c2ab0431d4b6b9cbb15be54ba874efb Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 3 Nov 2018 23:37:20 +0100 Subject: [PATCH 110/122] Initialize function pointers to a panicking function if it couldn't be loaded --- ash/src/entry.rs | 9 +- ash/src/extensions/android_surface.rs | 8 +- ash/src/extensions/debug_marker.rs | 8 +- ash/src/extensions/debug_report.rs | 8 +- ash/src/extensions/debug_utils.rs | 8 +- ash/src/extensions/display_swapchain.rs | 8 +- ash/src/extensions/ios_surface.rs | 8 +- ash/src/extensions/macos_surface.rs | 8 +- ash/src/extensions/surface.rs | 8 +- ash/src/extensions/swapchain.rs | 8 +- ash/src/extensions/wayland_surface.rs | 8 +- ash/src/extensions/win32_surface.rs | 8 +- ash/src/extensions/xcb_surface.rs | 8 +- ash/src/extensions/xlib_surface.rs | 8 +- ash/src/instance.rs | 2 +- ash/src/version.rs | 58 +- ash/src/vk.rs | 9915 +++++++++++++---------- examples/src/lib.rs | 10 +- generator/src/lib.rs | 37 +- 19 files changed, 5813 insertions(+), 4322 deletions(-) diff --git a/ash/src/entry.rs b/ash/src/entry.rs index 7fdefbe..e75f569 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -37,8 +37,6 @@ pub struct Entry { #[derive(Debug)] pub enum LoadingError { LibraryLoadError(String), - EntryLoadError(Vec<&'static str>), - StaticLoadError(Vec<&'static str>), } #[derive(Debug)] @@ -87,8 +85,7 @@ pub trait EntryV1_0 { return Err(InstanceError::VkError(err_code)); } let instance_fp = - ::InstanceFp::load(&self.static_fn(), instance) - .map_err(InstanceError::LoadError)?; + ::InstanceFp::load(&self.static_fn(), instance); Ok(Instance::from_raw(instance, instance_fp)) } @@ -176,10 +173,10 @@ impl Entry { let static_fn = vk::StaticFn::load(|name| unsafe { lib.symbol(&*name.to_string_lossy()) .unwrap_or(ptr::null_mut()) - }).map_err(LoadingError::StaticLoadError)?; + }); let entry_fn = - unsafe { V::EntryFp::load(&static_fn) }.map_err(LoadingError::EntryLoadError)?; + unsafe { V::EntryFp::load(&static_fn) }; Ok(Entry { static_fn, diff --git a/ash/src/extensions/android_surface.rs b/ash/src/extensions/android_surface.rs index 881a121..5a38e59 100644 --- a/ash/src/extensions/android_surface.rs +++ b/ash/src/extensions/android_surface.rs @@ -16,14 +16,14 @@ impl AndroidSurface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> AndroidSurface { let surface_fn = vk::KhrAndroidSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(AndroidSurface { + }); + AndroidSurface { handle: instance.handle(), android_surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/debug_marker.rs b/ash/src/extensions/debug_marker.rs index 3240bba..13ec427 100644 --- a/ash/src/extensions/debug_marker.rs +++ b/ash/src/extensions/debug_marker.rs @@ -14,13 +14,13 @@ impl DebugMarker { pub fn new( instance: &I, device: &D, - ) -> Result> { + ) -> DebugMarker { let debug_marker_fn = vk::ExtDebugMarkerFn::load(|name| unsafe { mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) - })?; - Ok(DebugMarker { + }); + DebugMarker { debug_marker_fn: debug_marker_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/debug_report.rs b/ash/src/extensions/debug_report.rs index fda418f..b819115 100644 --- a/ash/src/extensions/debug_report.rs +++ b/ash/src/extensions/debug_report.rs @@ -16,14 +16,14 @@ impl DebugReport { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> DebugReport { let debug_report_fn = vk::ExtDebugReportFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(DebugReport { + }); + DebugReport { handle: instance.handle(), debug_report_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/debug_utils.rs b/ash/src/extensions/debug_utils.rs index 836e0fb..bfdc291 100644 --- a/ash/src/extensions/debug_utils.rs +++ b/ash/src/extensions/debug_utils.rs @@ -15,14 +15,14 @@ impl DebugUtils { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> DebugUtils { let debug_utils_fn = vk::ExtDebugUtilsFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(DebugUtils { + }); + DebugUtils { handle: instance.handle(), debug_utils_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/display_swapchain.rs b/ash/src/extensions/display_swapchain.rs index d195e72..ff02aef 100644 --- a/ash/src/extensions/display_swapchain.rs +++ b/ash/src/extensions/display_swapchain.rs @@ -16,14 +16,14 @@ impl DisplaySwapchain { pub fn new( instance: &I, device: &D, - ) -> Result> { + ) -> DisplaySwapchain { let swapchain_fn = vk::KhrDisplaySwapchainFn::load(|name| unsafe { mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) - })?; - Ok(DisplaySwapchain { + }); + DisplaySwapchain { handle: device.handle(), swapchain_fn: swapchain_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/ios_surface.rs b/ash/src/extensions/ios_surface.rs index 2e6715f..97eaad6 100644 --- a/ash/src/extensions/ios_surface.rs +++ b/ash/src/extensions/ios_surface.rs @@ -16,14 +16,14 @@ impl IOSSurface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> IOSSurface{ let surface_fn = vk::MvkIosSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(IOSSurface { + }); + IOSSurface { handle: instance.handle(), ios_surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/macos_surface.rs b/ash/src/extensions/macos_surface.rs index 8248cb8..a7d26ae 100644 --- a/ash/src/extensions/macos_surface.rs +++ b/ash/src/extensions/macos_surface.rs @@ -16,14 +16,14 @@ impl MacOSSurface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> MacOSSurface { let surface_fn = vk::MvkMacosSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(MacOSSurface { + }); + MacOSSurface { handle: instance.handle(), macos_surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/surface.rs b/ash/src/extensions/surface.rs index d7f5765..16b8da4 100644 --- a/ash/src/extensions/surface.rs +++ b/ash/src/extensions/surface.rs @@ -17,14 +17,14 @@ impl Surface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> Surface { let surface_fn = vk::KhrSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(Surface { + }); + Surface { handle: instance.handle(), surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/swapchain.rs b/ash/src/extensions/swapchain.rs index e76902b..aca29f0 100644 --- a/ash/src/extensions/swapchain.rs +++ b/ash/src/extensions/swapchain.rs @@ -17,14 +17,14 @@ impl Swapchain { pub fn new( instance: &I, device: &D, - ) -> Result> { + ) -> Swapchain { let swapchain_fn = vk::KhrSwapchainFn::load(|name| unsafe { mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) - })?; - Ok(Swapchain { + }); + Swapchain { handle: device.handle(), swapchain_fn: swapchain_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/wayland_surface.rs b/ash/src/extensions/wayland_surface.rs index e98e173..482f27d 100644 --- a/ash/src/extensions/wayland_surface.rs +++ b/ash/src/extensions/wayland_surface.rs @@ -16,14 +16,14 @@ impl WaylandSurface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> WaylandSurface { let surface_fn = vk::KhrWaylandSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(WaylandSurface { + }); + WaylandSurface { handle: instance.handle(), wayland_surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/win32_surface.rs b/ash/src/extensions/win32_surface.rs index 365326d..5576e50 100644 --- a/ash/src/extensions/win32_surface.rs +++ b/ash/src/extensions/win32_surface.rs @@ -16,14 +16,14 @@ impl Win32Surface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> Win32Surface { let surface_fn = vk::KhrWin32SurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(Win32Surface { + }); + Win32Surface { handle: instance.handle(), win32_surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/xcb_surface.rs b/ash/src/extensions/xcb_surface.rs index 2ff3f76..2c45c36 100644 --- a/ash/src/extensions/xcb_surface.rs +++ b/ash/src/extensions/xcb_surface.rs @@ -16,14 +16,14 @@ impl XcbSurface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> XcbSurface { let surface_fn = vk::KhrXcbSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(XcbSurface { + }); + XcbSurface { handle: instance.handle(), xcb_surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/extensions/xlib_surface.rs b/ash/src/extensions/xlib_surface.rs index 1f89c1a..34293d2 100644 --- a/ash/src/extensions/xlib_surface.rs +++ b/ash/src/extensions/xlib_surface.rs @@ -16,14 +16,14 @@ impl XlibSurface { pub fn new( entry: &E, instance: &I, - ) -> Result> { + ) -> XlibSurface { let surface_fn = vk::KhrXlibSurfaceFn::load(|name| unsafe { mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) - })?; - Ok(XlibSurface { + }); + XlibSurface { handle: instance.handle(), xlib_surface_fn: surface_fn, - }) + } } pub fn name() -> &'static CStr { diff --git a/ash/src/instance.rs b/ash/src/instance.rs index a7cfdc9..10d60c2 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -279,7 +279,7 @@ pub trait InstanceV1_0 { let device_fn = <::Fp as FunctionPointers>::DeviceFp::load( self.fp_v1_0(), device, - ).map_err(|err| DeviceError::LoadError(err))?; + ); Ok(Device::from_raw(device, device_fn)) } diff --git a/ash/src/version.rs b/ash/src/version.rs index 710c5ee..4d86da3 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -37,17 +37,17 @@ impl EntryLoader for EntryFpV1_0 { fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { &self.entry_fn } - unsafe fn load(static_fn: &vk::StaticFn) -> Result> { + unsafe fn load(static_fn: &vk::StaticFn) -> Self { let entry_fn = vk::EntryFnV1_0::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) - })?; - Ok(EntryFpV1_0 { entry_fn: entry_fn }) + }); + EntryFpV1_0 { entry_fn: entry_fn } } } pub trait EntryLoader: Sized { fn fp_v1_0(&self) -> &vk::EntryFnV1_0; - unsafe fn load(static_fn: &vk::StaticFn) -> Result>; + unsafe fn load(static_fn: &vk::StaticFn) -> Self; } #[allow(non_camel_case_types)] @@ -61,18 +61,18 @@ impl EntryLoader for EntryFpV1_1 { fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { &self.entry_fn_1_0 } - unsafe fn load(static_fn: &vk::StaticFn) -> Result> { + unsafe fn load(static_fn: &vk::StaticFn) -> Self { let entry_fn_1_0 = vk::EntryFnV1_0::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) - })?; + }); let entry_fn_1_1 = vk::EntryFnV1_1::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) - })?; + }); - Ok(EntryFpV1_1 { + EntryFpV1_1 { entry_fn_1_0, entry_fn_1_1, - }) + } } } @@ -80,7 +80,7 @@ pub trait InstanceLoader: Sized { unsafe fn load( static_fn: &vk::StaticFn, instance: vk::Instance, - ) -> Result>; + ) -> Self; } #[allow(non_camel_case_types)] @@ -93,13 +93,13 @@ impl InstanceLoader for InstanceFpV1_0 { unsafe fn load( static_fn: &vk::StaticFn, instance: vk::Instance, - ) -> Result> { + ) -> Self { let instance_fn = vk::InstanceFnV1_0::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) - })?; - Ok(InstanceFpV1_0 { + }); + InstanceFpV1_0 { instance_fn: instance_fn, - }) + } } } @@ -114,18 +114,18 @@ impl InstanceLoader for InstanceFpV1_1 { unsafe fn load( static_fn: &vk::StaticFn, instance: vk::Instance, - ) -> Result> { + ) -> Self { let instance_fn_1_0 = vk::InstanceFnV1_0::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) - })?; + }); let instance_fn_1_1 = vk::InstanceFnV1_1::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) - })?; + }); - Ok(InstanceFpV1_1 { + InstanceFpV1_1 { instance_fn_1_0, instance_fn_1_1, - }) + } } } @@ -133,7 +133,7 @@ pub trait DeviceLoader: Sized { unsafe fn load( instance_fn: &vk::InstanceFnV1_0, device: vk::Device, - ) -> Result>; + ) -> Self; } #[allow(non_camel_case_types)] @@ -146,13 +146,13 @@ impl DeviceLoader for DeviceFpV1_0 { unsafe fn load( instance_fn: &vk::InstanceFnV1_0, device: vk::Device, - ) -> Result> { + ) -> Self { let device_fn = vk::DeviceFnV1_0::load(|name| { mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) - })?; - Ok(DeviceFpV1_0 { + }); + DeviceFpV1_0 { device_fn: device_fn, - }) + } } } @@ -167,16 +167,16 @@ impl DeviceLoader for DeviceFpV1_1 { unsafe fn load( instance_fn: &vk::InstanceFnV1_0, device: vk::Device, - ) -> Result> { + ) -> Self { let device_fn_1_0 = vk::DeviceFnV1_0::load(|name| { mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) - })?; + }); let device_fn_1_1 = vk::DeviceFnV1_1::load(|name| { mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) - })?; - Ok(DeviceFpV1_1 { + }); + DeviceFpV1_1 { device_fn_1_0, device_fn_1_1, - }) + } } } diff --git a/ash/src/vk.rs b/ash/src/vk.rs index da47909..fea626e 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -257,26 +257,27 @@ impl ::std::clone::Clone for StaticFn { } } impl StaticFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = StaticFn { + StaticFn { get_instance_proc_addr: unsafe { + extern "system" fn get_instance_proc_addr( + _instance: Instance, + _p_name: *const c_char, + ) -> PFN_vkVoidFunction { + panic!("Unable to load {}", stringify!(get_instance_proc_addr)) + } let raw_name = stringify!(vkGetInstanceProcAddr); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_instance_proc_addr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_instance_proc_addr( @@ -315,44 +316,67 @@ impl ::std::clone::Clone for EntryFnV1_0 { } } impl EntryFnV1_0 { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = EntryFnV1_0 { + EntryFnV1_0 { create_instance: unsafe { + extern "system" fn create_instance( + _p_create_info: *const InstanceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_instance: *mut Instance, + ) -> Result { + panic!("Unable to load {}", stringify!(create_instance)) + } let raw_name = stringify!(vkCreateInstance); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_instance + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, enumerate_instance_extension_properties: unsafe { + extern "system" fn enumerate_instance_extension_properties( + _p_layer_name: *const c_char, + _p_property_count: *mut u32, + _p_properties: *mut ExtensionProperties, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(enumerate_instance_extension_properties) + ) + } let raw_name = stringify!(vkEnumerateInstanceExtensionProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + enumerate_instance_extension_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, enumerate_instance_layer_properties: unsafe { + extern "system" fn enumerate_instance_layer_properties( + _p_property_count: *mut u32, + _p_properties: *mut LayerProperties, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(enumerate_instance_layer_properties) + ) + } let raw_name = stringify!(vkEnumerateInstanceLayerProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + enumerate_instance_layer_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_instance( @@ -463,150 +487,281 @@ impl ::std::clone::Clone for InstanceFnV1_0 { enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, - get_physical_device_image_format_properties: self - .get_physical_device_image_format_properties, + get_physical_device_image_format_properties: + self.get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, - get_physical_device_queue_family_properties: self - .get_physical_device_queue_family_properties, + get_physical_device_queue_family_properties: + self.get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, - get_physical_device_sparse_image_format_properties: self - .get_physical_device_sparse_image_format_properties, + get_physical_device_sparse_image_format_properties: + self.get_physical_device_sparse_image_format_properties, } } } impl InstanceFnV1_0 { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = InstanceFnV1_0 { + InstanceFnV1_0 { destroy_instance: unsafe { + extern "system" fn destroy_instance( + _instance: Instance, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_instance)) + } let raw_name = stringify!(vkDestroyInstance); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_instance + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, enumerate_physical_devices: unsafe { + extern "system" fn enumerate_physical_devices( + _instance: Instance, + _p_physical_device_count: *mut u32, + _p_physical_devices: *mut PhysicalDevice, + ) -> Result { + panic!("Unable to load {}", stringify!(enumerate_physical_devices)) + } let raw_name = stringify!(vkEnumeratePhysicalDevices); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + enumerate_physical_devices + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_features: unsafe { + extern "system" fn get_physical_device_features( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_features) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceFeatures); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_features + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_format_properties: unsafe { + extern "system" fn get_physical_device_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_format_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_format_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_image_format_properties: unsafe { + extern "system" fn get_physical_device_image_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _tiling: ImageTiling, + _usage: ImageUsageFlags, + _flags: ImageCreateFlags, + _p_image_format_properties: *mut ImageFormatProperties, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_image_format_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_image_format_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_properties: unsafe { + extern "system" fn get_physical_device_properties( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_queue_family_properties: unsafe { + extern "system" fn get_physical_device_queue_family_properties( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_queue_family_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_queue_family_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_memory_properties: unsafe { + extern "system" fn get_physical_device_memory_properties( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_memory_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_memory_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_proc_addr: unsafe { + extern "system" fn get_device_proc_addr( + _device: Device, + _p_name: *const c_char, + ) -> PFN_vkVoidFunction { + panic!("Unable to load {}", stringify!(get_device_proc_addr)) + } let raw_name = stringify!(vkGetDeviceProcAddr); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_proc_addr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_device: unsafe { + extern "system" fn create_device( + _physical_device: PhysicalDevice, + _p_create_info: *const DeviceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_device: *mut Device, + ) -> Result { + panic!("Unable to load {}", stringify!(create_device)) + } let raw_name = stringify!(vkCreateDevice); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_device + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, enumerate_device_extension_properties: unsafe { + extern "system" fn enumerate_device_extension_properties( + _physical_device: PhysicalDevice, + _p_layer_name: *const c_char, + _p_property_count: *mut u32, + _p_properties: *mut ExtensionProperties, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(enumerate_device_extension_properties) + ) + } let raw_name = stringify!(vkEnumerateDeviceExtensionProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + enumerate_device_extension_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, enumerate_device_layer_properties: unsafe { + extern "system" fn enumerate_device_layer_properties( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut LayerProperties, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(enumerate_device_layer_properties) + ) + } let raw_name = stringify!(vkEnumerateDeviceLayerProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + enumerate_device_layer_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_sparse_image_format_properties: unsafe { + extern "system" fn get_physical_device_sparse_image_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _samples: SampleCountFlags, + _usage: ImageUsageFlags, + _tiling: ImageTiling, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_sparse_image_format_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_sparse_image_format_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn destroy_instance( @@ -1539,1097 +1694,2166 @@ impl ::std::clone::Clone for DeviceFnV1_0 { } } impl DeviceFnV1_0 { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = DeviceFnV1_0 { + DeviceFnV1_0 { destroy_device: unsafe { + extern "system" fn destroy_device( + _device: Device, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_device)) + } let raw_name = stringify!(vkDestroyDevice); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_device + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_queue: unsafe { + extern "system" fn get_device_queue( + _device: Device, + _queue_family_index: u32, + _queue_index: u32, + _p_queue: *mut Queue, + ) -> c_void { + panic!("Unable to load {}", stringify!(get_device_queue)) + } let raw_name = stringify!(vkGetDeviceQueue); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_queue + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_submit: unsafe { + extern "system" fn queue_submit( + _queue: Queue, + _submit_count: u32, + _p_submits: *const SubmitInfo, + _fence: Fence, + ) -> Result { + panic!("Unable to load {}", stringify!(queue_submit)) + } let raw_name = stringify!(vkQueueSubmit); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_submit + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_wait_idle: unsafe { + extern "system" fn queue_wait_idle(_queue: Queue) -> Result { + panic!("Unable to load {}", stringify!(queue_wait_idle)) + } let raw_name = stringify!(vkQueueWaitIdle); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_wait_idle + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, device_wait_idle: unsafe { + extern "system" fn device_wait_idle(_device: Device) -> Result { + panic!("Unable to load {}", stringify!(device_wait_idle)) + } let raw_name = stringify!(vkDeviceWaitIdle); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + device_wait_idle + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, allocate_memory: unsafe { + extern "system" fn allocate_memory( + _device: Device, + _p_allocate_info: *const MemoryAllocateInfo, + _p_allocator: *const AllocationCallbacks, + _p_memory: *mut DeviceMemory, + ) -> Result { + panic!("Unable to load {}", stringify!(allocate_memory)) + } let raw_name = stringify!(vkAllocateMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + allocate_memory + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, free_memory: unsafe { + extern "system" fn free_memory( + _device: Device, + _memory: DeviceMemory, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(free_memory)) + } let raw_name = stringify!(vkFreeMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + free_memory + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, map_memory: unsafe { + extern "system" fn map_memory( + _device: Device, + _memory: DeviceMemory, + _offset: DeviceSize, + _size: DeviceSize, + _flags: MemoryMapFlags, + _pp_data: *mut *mut c_void, + ) -> Result { + panic!("Unable to load {}", stringify!(map_memory)) + } let raw_name = stringify!(vkMapMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + map_memory + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, unmap_memory: unsafe { + extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) -> c_void { + panic!("Unable to load {}", stringify!(unmap_memory)) + } let raw_name = stringify!(vkUnmapMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + unmap_memory + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, flush_mapped_memory_ranges: unsafe { + extern "system" fn flush_mapped_memory_ranges( + _device: Device, + _memory_range_count: u32, + _p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + panic!("Unable to load {}", stringify!(flush_mapped_memory_ranges)) + } let raw_name = stringify!(vkFlushMappedMemoryRanges); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + flush_mapped_memory_ranges + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, invalidate_mapped_memory_ranges: unsafe { + extern "system" fn invalidate_mapped_memory_ranges( + _device: Device, + _memory_range_count: u32, + _p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(invalidate_mapped_memory_ranges) + ) + } let raw_name = stringify!(vkInvalidateMappedMemoryRanges); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + invalidate_mapped_memory_ranges + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_memory_commitment: unsafe { + extern "system" fn get_device_memory_commitment( + _device: Device, + _memory: DeviceMemory, + _p_committed_memory_in_bytes: *mut DeviceSize, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_device_memory_commitment) + ) + } let raw_name = stringify!(vkGetDeviceMemoryCommitment); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_memory_commitment + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, bind_buffer_memory: unsafe { + extern "system" fn bind_buffer_memory( + _device: Device, + _buffer: Buffer, + _memory: DeviceMemory, + _memory_offset: DeviceSize, + ) -> Result { + panic!("Unable to load {}", stringify!(bind_buffer_memory)) + } let raw_name = stringify!(vkBindBufferMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + bind_buffer_memory + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, bind_image_memory: unsafe { + extern "system" fn bind_image_memory( + _device: Device, + _image: Image, + _memory: DeviceMemory, + _memory_offset: DeviceSize, + ) -> Result { + panic!("Unable to load {}", stringify!(bind_image_memory)) + } let raw_name = stringify!(vkBindImageMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + bind_image_memory + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_buffer_memory_requirements: unsafe { + extern "system" fn get_buffer_memory_requirements( + _device: Device, + _buffer: Buffer, + _p_memory_requirements: *mut MemoryRequirements, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_buffer_memory_requirements) + ) + } let raw_name = stringify!(vkGetBufferMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_buffer_memory_requirements + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_image_memory_requirements: unsafe { + extern "system" fn get_image_memory_requirements( + _device: Device, + _image: Image, + _p_memory_requirements: *mut MemoryRequirements, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_image_memory_requirements) + ) + } let raw_name = stringify!(vkGetImageMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_image_memory_requirements + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_image_sparse_memory_requirements: unsafe { + extern "system" fn get_image_sparse_memory_requirements( + _device: Device, + _image: Image, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_image_sparse_memory_requirements) + ) + } let raw_name = stringify!(vkGetImageSparseMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_image_sparse_memory_requirements + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_bind_sparse: unsafe { + extern "system" fn queue_bind_sparse( + _queue: Queue, + _bind_info_count: u32, + _p_bind_info: *const BindSparseInfo, + _fence: Fence, + ) -> Result { + panic!("Unable to load {}", stringify!(queue_bind_sparse)) + } let raw_name = stringify!(vkQueueBindSparse); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_bind_sparse + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_fence: unsafe { + extern "system" fn create_fence( + _device: Device, + _p_create_info: *const FenceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!("Unable to load {}", stringify!(create_fence)) + } let raw_name = stringify!(vkCreateFence); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_fence + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_fence: unsafe { + extern "system" fn destroy_fence( + _device: Device, + _fence: Fence, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_fence)) + } let raw_name = stringify!(vkDestroyFence); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_fence + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, reset_fences: unsafe { + extern "system" fn reset_fences( + _device: Device, + _fence_count: u32, + _p_fences: *const Fence, + ) -> Result { + panic!("Unable to load {}", stringify!(reset_fences)) + } let raw_name = stringify!(vkResetFences); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + reset_fences + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_fence_status: unsafe { + extern "system" fn get_fence_status(_device: Device, _fence: Fence) -> Result { + panic!("Unable to load {}", stringify!(get_fence_status)) + } let raw_name = stringify!(vkGetFenceStatus); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_fence_status + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, wait_for_fences: unsafe { + extern "system" fn wait_for_fences( + _device: Device, + _fence_count: u32, + _p_fences: *const Fence, + _wait_all: Bool32, + _timeout: u64, + ) -> Result { + panic!("Unable to load {}", stringify!(wait_for_fences)) + } let raw_name = stringify!(vkWaitForFences); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + wait_for_fences + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_semaphore: unsafe { + extern "system" fn create_semaphore( + _device: Device, + _p_create_info: *const SemaphoreCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_semaphore: *mut Semaphore, + ) -> Result { + panic!("Unable to load {}", stringify!(create_semaphore)) + } let raw_name = stringify!(vkCreateSemaphore); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_semaphore + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_semaphore: unsafe { + extern "system" fn destroy_semaphore( + _device: Device, + _semaphore: Semaphore, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_semaphore)) + } let raw_name = stringify!(vkDestroySemaphore); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_semaphore + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_event: unsafe { + extern "system" fn create_event( + _device: Device, + _p_create_info: *const EventCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_event: *mut Event, + ) -> Result { + panic!("Unable to load {}", stringify!(create_event)) + } let raw_name = stringify!(vkCreateEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_event + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_event: unsafe { + extern "system" fn destroy_event( + _device: Device, + _event: Event, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_event)) + } let raw_name = stringify!(vkDestroyEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_event + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_event_status: unsafe { + extern "system" fn get_event_status(_device: Device, _event: Event) -> Result { + panic!("Unable to load {}", stringify!(get_event_status)) + } let raw_name = stringify!(vkGetEventStatus); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_event_status + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, set_event: unsafe { + extern "system" fn set_event(_device: Device, _event: Event) -> Result { + panic!("Unable to load {}", stringify!(set_event)) + } let raw_name = stringify!(vkSetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + set_event + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, reset_event: unsafe { + extern "system" fn reset_event(_device: Device, _event: Event) -> Result { + panic!("Unable to load {}", stringify!(reset_event)) + } let raw_name = stringify!(vkResetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + reset_event + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_query_pool: unsafe { + extern "system" fn create_query_pool( + _device: Device, + _p_create_info: *const QueryPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_query_pool: *mut QueryPool, + ) -> Result { + panic!("Unable to load {}", stringify!(create_query_pool)) + } let raw_name = stringify!(vkCreateQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_query_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_query_pool: unsafe { + extern "system" fn destroy_query_pool( + _device: Device, + _query_pool: QueryPool, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_query_pool)) + } let raw_name = stringify!(vkDestroyQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_query_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_query_pool_results: unsafe { + extern "system" fn get_query_pool_results( + _device: Device, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + _data_size: usize, + _p_data: *mut c_void, + _stride: DeviceSize, + _flags: QueryResultFlags, + ) -> Result { + panic!("Unable to load {}", stringify!(get_query_pool_results)) + } let raw_name = stringify!(vkGetQueryPoolResults); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_query_pool_results + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_buffer: unsafe { + extern "system" fn create_buffer( + _device: Device, + _p_create_info: *const BufferCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_buffer: *mut Buffer, + ) -> Result { + panic!("Unable to load {}", stringify!(create_buffer)) + } let raw_name = stringify!(vkCreateBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_buffer: unsafe { + extern "system" fn destroy_buffer( + _device: Device, + _buffer: Buffer, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_buffer)) + } let raw_name = stringify!(vkDestroyBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_buffer_view: unsafe { + extern "system" fn create_buffer_view( + _device: Device, + _p_create_info: *const BufferViewCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_view: *mut BufferView, + ) -> Result { + panic!("Unable to load {}", stringify!(create_buffer_view)) + } let raw_name = stringify!(vkCreateBufferView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_buffer_view + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_buffer_view: unsafe { + extern "system" fn destroy_buffer_view( + _device: Device, + _buffer_view: BufferView, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_buffer_view)) + } let raw_name = stringify!(vkDestroyBufferView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_buffer_view + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_image: unsafe { + extern "system" fn create_image( + _device: Device, + _p_create_info: *const ImageCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_image: *mut Image, + ) -> Result { + panic!("Unable to load {}", stringify!(create_image)) + } let raw_name = stringify!(vkCreateImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_image: unsafe { + extern "system" fn destroy_image( + _device: Device, + _image: Image, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_image)) + } let raw_name = stringify!(vkDestroyImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_image_subresource_layout: unsafe { + extern "system" fn get_image_subresource_layout( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource, + _p_layout: *mut SubresourceLayout, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_image_subresource_layout) + ) + } let raw_name = stringify!(vkGetImageSubresourceLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_image_subresource_layout + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_image_view: unsafe { + extern "system" fn create_image_view( + _device: Device, + _p_create_info: *const ImageViewCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_view: *mut ImageView, + ) -> Result { + panic!("Unable to load {}", stringify!(create_image_view)) + } let raw_name = stringify!(vkCreateImageView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_image_view + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_image_view: unsafe { + extern "system" fn destroy_image_view( + _device: Device, + _image_view: ImageView, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_image_view)) + } let raw_name = stringify!(vkDestroyImageView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_image_view + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_shader_module: unsafe { + extern "system" fn create_shader_module( + _device: Device, + _p_create_info: *const ShaderModuleCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_shader_module: *mut ShaderModule, + ) -> Result { + panic!("Unable to load {}", stringify!(create_shader_module)) + } let raw_name = stringify!(vkCreateShaderModule); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_shader_module + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_shader_module: unsafe { + extern "system" fn destroy_shader_module( + _device: Device, + _shader_module: ShaderModule, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_shader_module)) + } let raw_name = stringify!(vkDestroyShaderModule); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_shader_module + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_pipeline_cache: unsafe { + extern "system" fn create_pipeline_cache( + _device: Device, + _p_create_info: *const PipelineCacheCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipeline_cache: *mut PipelineCache, + ) -> Result { + panic!("Unable to load {}", stringify!(create_pipeline_cache)) + } let raw_name = stringify!(vkCreatePipelineCache); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_pipeline_cache + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_pipeline_cache: unsafe { + extern "system" fn destroy_pipeline_cache( + _device: Device, + _pipeline_cache: PipelineCache, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_pipeline_cache)) + } let raw_name = stringify!(vkDestroyPipelineCache); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_pipeline_cache + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_pipeline_cache_data: unsafe { + extern "system" fn get_pipeline_cache_data( + _device: Device, + _pipeline_cache: PipelineCache, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!("Unable to load {}", stringify!(get_pipeline_cache_data)) + } let raw_name = stringify!(vkGetPipelineCacheData); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_pipeline_cache_data + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, merge_pipeline_caches: unsafe { + extern "system" fn merge_pipeline_caches( + _device: Device, + _dst_cache: PipelineCache, + _src_cache_count: u32, + _p_src_caches: *const PipelineCache, + ) -> Result { + panic!("Unable to load {}", stringify!(merge_pipeline_caches)) + } let raw_name = stringify!(vkMergePipelineCaches); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + merge_pipeline_caches + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_graphics_pipelines: unsafe { + extern "system" fn create_graphics_pipelines( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const GraphicsPipelineCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!("Unable to load {}", stringify!(create_graphics_pipelines)) + } let raw_name = stringify!(vkCreateGraphicsPipelines); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_graphics_pipelines + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_compute_pipelines: unsafe { + extern "system" fn create_compute_pipelines( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const ComputePipelineCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!("Unable to load {}", stringify!(create_compute_pipelines)) + } let raw_name = stringify!(vkCreateComputePipelines); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_compute_pipelines + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_pipeline: unsafe { + extern "system" fn destroy_pipeline( + _device: Device, + _pipeline: Pipeline, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_pipeline)) + } let raw_name = stringify!(vkDestroyPipeline); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_pipeline + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_pipeline_layout: unsafe { + extern "system" fn create_pipeline_layout( + _device: Device, + _p_create_info: *const PipelineLayoutCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipeline_layout: *mut PipelineLayout, + ) -> Result { + panic!("Unable to load {}", stringify!(create_pipeline_layout)) + } let raw_name = stringify!(vkCreatePipelineLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_pipeline_layout + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_pipeline_layout: unsafe { + extern "system" fn destroy_pipeline_layout( + _device: Device, + _pipeline_layout: PipelineLayout, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_pipeline_layout)) + } let raw_name = stringify!(vkDestroyPipelineLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_pipeline_layout + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_sampler: unsafe { + extern "system" fn create_sampler( + _device: Device, + _p_create_info: *const SamplerCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_sampler: *mut Sampler, + ) -> Result { + panic!("Unable to load {}", stringify!(create_sampler)) + } let raw_name = stringify!(vkCreateSampler); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_sampler + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_sampler: unsafe { + extern "system" fn destroy_sampler( + _device: Device, + _sampler: Sampler, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_sampler)) + } let raw_name = stringify!(vkDestroySampler); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_sampler + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_descriptor_set_layout: unsafe { + extern "system" fn create_descriptor_set_layout( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_set_layout: *mut DescriptorSetLayout, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_descriptor_set_layout) + ) + } let raw_name = stringify!(vkCreateDescriptorSetLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_descriptor_set_layout + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_descriptor_set_layout: unsafe { + extern "system" fn destroy_descriptor_set_layout( + _device: Device, + _descriptor_set_layout: DescriptorSetLayout, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(destroy_descriptor_set_layout) + ) + } let raw_name = stringify!(vkDestroyDescriptorSetLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_descriptor_set_layout + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_descriptor_pool: unsafe { + extern "system" fn create_descriptor_pool( + _device: Device, + _p_create_info: *const DescriptorPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_pool: *mut DescriptorPool, + ) -> Result { + panic!("Unable to load {}", stringify!(create_descriptor_pool)) + } let raw_name = stringify!(vkCreateDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_descriptor_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_descriptor_pool: unsafe { + extern "system" fn destroy_descriptor_pool( + _device: Device, + _descriptor_pool: DescriptorPool, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_descriptor_pool)) + } let raw_name = stringify!(vkDestroyDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_descriptor_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, reset_descriptor_pool: unsafe { + extern "system" fn reset_descriptor_pool( + _device: Device, + _descriptor_pool: DescriptorPool, + _flags: DescriptorPoolResetFlags, + ) -> Result { + panic!("Unable to load {}", stringify!(reset_descriptor_pool)) + } let raw_name = stringify!(vkResetDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + reset_descriptor_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, allocate_descriptor_sets: unsafe { + extern "system" fn allocate_descriptor_sets( + _device: Device, + _p_allocate_info: *const DescriptorSetAllocateInfo, + _p_descriptor_sets: *mut DescriptorSet, + ) -> Result { + panic!("Unable to load {}", stringify!(allocate_descriptor_sets)) + } let raw_name = stringify!(vkAllocateDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + allocate_descriptor_sets + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, free_descriptor_sets: unsafe { + extern "system" fn free_descriptor_sets( + _device: Device, + _descriptor_pool: DescriptorPool, + _descriptor_set_count: u32, + _p_descriptor_sets: *const DescriptorSet, + ) -> Result { + panic!("Unable to load {}", stringify!(free_descriptor_sets)) + } let raw_name = stringify!(vkFreeDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + free_descriptor_sets + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, update_descriptor_sets: unsafe { + extern "system" fn update_descriptor_sets( + _device: Device, + _descriptor_write_count: u32, + _p_descriptor_writes: *const WriteDescriptorSet, + _descriptor_copy_count: u32, + _p_descriptor_copies: *const CopyDescriptorSet, + ) -> c_void { + panic!("Unable to load {}", stringify!(update_descriptor_sets)) + } let raw_name = stringify!(vkUpdateDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + update_descriptor_sets + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_framebuffer: unsafe { + extern "system" fn create_framebuffer( + _device: Device, + _p_create_info: *const FramebufferCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_framebuffer: *mut Framebuffer, + ) -> Result { + panic!("Unable to load {}", stringify!(create_framebuffer)) + } let raw_name = stringify!(vkCreateFramebuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_framebuffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_framebuffer: unsafe { + extern "system" fn destroy_framebuffer( + _device: Device, + _framebuffer: Framebuffer, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_framebuffer)) + } let raw_name = stringify!(vkDestroyFramebuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_framebuffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_render_pass: unsafe { + extern "system" fn create_render_pass( + _device: Device, + _p_create_info: *const RenderPassCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_render_pass: *mut RenderPass, + ) -> Result { + panic!("Unable to load {}", stringify!(create_render_pass)) + } let raw_name = stringify!(vkCreateRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_render_pass + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_render_pass: unsafe { + extern "system" fn destroy_render_pass( + _device: Device, + _render_pass: RenderPass, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_render_pass)) + } let raw_name = stringify!(vkDestroyRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_render_pass + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_render_area_granularity: unsafe { + extern "system" fn get_render_area_granularity( + _device: Device, + _render_pass: RenderPass, + _p_granularity: *mut Extent2D, + ) -> c_void { + panic!("Unable to load {}", stringify!(get_render_area_granularity)) + } let raw_name = stringify!(vkGetRenderAreaGranularity); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_render_area_granularity + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_command_pool: unsafe { + extern "system" fn create_command_pool( + _device: Device, + _p_create_info: *const CommandPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_command_pool: *mut CommandPool, + ) -> Result { + panic!("Unable to load {}", stringify!(create_command_pool)) + } let raw_name = stringify!(vkCreateCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_command_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_command_pool: unsafe { + extern "system" fn destroy_command_pool( + _device: Device, + _command_pool: CommandPool, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_command_pool)) + } let raw_name = stringify!(vkDestroyCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_command_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, reset_command_pool: unsafe { + extern "system" fn reset_command_pool( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolResetFlags, + ) -> Result { + panic!("Unable to load {}", stringify!(reset_command_pool)) + } let raw_name = stringify!(vkResetCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + reset_command_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, allocate_command_buffers: unsafe { + extern "system" fn allocate_command_buffers( + _device: Device, + _p_allocate_info: *const CommandBufferAllocateInfo, + _p_command_buffers: *mut CommandBuffer, + ) -> Result { + panic!("Unable to load {}", stringify!(allocate_command_buffers)) + } let raw_name = stringify!(vkAllocateCommandBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + allocate_command_buffers + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, free_command_buffers: unsafe { + extern "system" fn free_command_buffers( + _device: Device, + _command_pool: CommandPool, + _command_buffer_count: u32, + _p_command_buffers: *const CommandBuffer, + ) -> c_void { + panic!("Unable to load {}", stringify!(free_command_buffers)) + } let raw_name = stringify!(vkFreeCommandBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + free_command_buffers + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, begin_command_buffer: unsafe { + extern "system" fn begin_command_buffer( + _command_buffer: CommandBuffer, + _p_begin_info: *const CommandBufferBeginInfo, + ) -> Result { + panic!("Unable to load {}", stringify!(begin_command_buffer)) + } let raw_name = stringify!(vkBeginCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + begin_command_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, end_command_buffer: unsafe { + extern "system" fn end_command_buffer(_command_buffer: CommandBuffer) -> Result { + panic!("Unable to load {}", stringify!(end_command_buffer)) + } let raw_name = stringify!(vkEndCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + end_command_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, reset_command_buffer: unsafe { + extern "system" fn reset_command_buffer( + _command_buffer: CommandBuffer, + _flags: CommandBufferResetFlags, + ) -> Result { + panic!("Unable to load {}", stringify!(reset_command_buffer)) + } let raw_name = stringify!(vkResetCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + reset_command_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_bind_pipeline: unsafe { + extern "system" fn cmd_bind_pipeline( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _pipeline: Pipeline, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_bind_pipeline)) + } let raw_name = stringify!(vkCmdBindPipeline); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_bind_pipeline + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_viewport: unsafe { + extern "system" fn cmd_set_viewport( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_viewport)) + } let raw_name = stringify!(vkCmdSetViewport); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_viewport + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_scissor: unsafe { + extern "system" fn cmd_set_scissor( + _command_buffer: CommandBuffer, + _first_scissor: u32, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_scissor)) + } let raw_name = stringify!(vkCmdSetScissor); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_scissor + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_line_width: unsafe { + extern "system" fn cmd_set_line_width( + _command_buffer: CommandBuffer, + _line_width: c_float, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_line_width)) + } let raw_name = stringify!(vkCmdSetLineWidth); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_line_width + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_depth_bias: unsafe { + extern "system" fn cmd_set_depth_bias( + _command_buffer: CommandBuffer, + _depth_bias_constant_factor: c_float, + _depth_bias_clamp: c_float, + _depth_bias_slope_factor: c_float, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_depth_bias)) + } let raw_name = stringify!(vkCmdSetDepthBias); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_depth_bias + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_blend_constants: unsafe { + extern "system" fn cmd_set_blend_constants( + _command_buffer: CommandBuffer, + _blend_constants: [c_float; 4], + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_blend_constants)) + } let raw_name = stringify!(vkCmdSetBlendConstants); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_blend_constants + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_depth_bounds: unsafe { + extern "system" fn cmd_set_depth_bounds( + _command_buffer: CommandBuffer, + _min_depth_bounds: c_float, + _max_depth_bounds: c_float, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_depth_bounds)) + } let raw_name = stringify!(vkCmdSetDepthBounds); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_depth_bounds + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_stencil_compare_mask: unsafe { + extern "system" fn cmd_set_stencil_compare_mask( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _compare_mask: u32, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_set_stencil_compare_mask) + ) + } let raw_name = stringify!(vkCmdSetStencilCompareMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_stencil_compare_mask + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_stencil_write_mask: unsafe { + extern "system" fn cmd_set_stencil_write_mask( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _write_mask: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_stencil_write_mask)) + } let raw_name = stringify!(vkCmdSetStencilWriteMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_stencil_write_mask + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_stencil_reference: unsafe { + extern "system" fn cmd_set_stencil_reference( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _reference: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_stencil_reference)) + } let raw_name = stringify!(vkCmdSetStencilReference); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_stencil_reference + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_bind_descriptor_sets: unsafe { + extern "system" fn cmd_bind_descriptor_sets( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _first_set: u32, + _descriptor_set_count: u32, + _p_descriptor_sets: *const DescriptorSet, + _dynamic_offset_count: u32, + _p_dynamic_offsets: *const u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_bind_descriptor_sets)) + } let raw_name = stringify!(vkCmdBindDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_bind_descriptor_sets + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_bind_index_buffer: unsafe { + extern "system" fn cmd_bind_index_buffer( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _index_type: IndexType, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_bind_index_buffer)) + } let raw_name = stringify!(vkCmdBindIndexBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_bind_index_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_bind_vertex_buffers: unsafe { + extern "system" fn cmd_bind_vertex_buffers( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_bind_vertex_buffers)) + } let raw_name = stringify!(vkCmdBindVertexBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_bind_vertex_buffers + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw: unsafe { + extern "system" fn cmd_draw( + _command_buffer: CommandBuffer, + _vertex_count: u32, + _instance_count: u32, + _first_vertex: u32, + _first_instance: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_draw)) + } let raw_name = stringify!(vkCmdDraw); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw_indexed: unsafe { + extern "system" fn cmd_draw_indexed( + _command_buffer: CommandBuffer, + _index_count: u32, + _instance_count: u32, + _first_index: u32, + _vertex_offset: i32, + _first_instance: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_draw_indexed)) + } let raw_name = stringify!(vkCmdDrawIndexed); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indexed + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw_indirect: unsafe { + extern "system" fn cmd_draw_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_draw_indirect)) + } let raw_name = stringify!(vkCmdDrawIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indirect + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw_indexed_indirect: unsafe { + extern "system" fn cmd_draw_indexed_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_draw_indexed_indirect)) + } let raw_name = stringify!(vkCmdDrawIndexedIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indexed_indirect + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_dispatch: unsafe { + extern "system" fn cmd_dispatch( + _command_buffer: CommandBuffer, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_dispatch)) + } let raw_name = stringify!(vkCmdDispatch); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_dispatch + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_dispatch_indirect: unsafe { + extern "system" fn cmd_dispatch_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_dispatch_indirect)) + } let raw_name = stringify!(vkCmdDispatchIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_dispatch_indirect + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_copy_buffer: unsafe { + extern "system" fn cmd_copy_buffer( + _command_buffer: CommandBuffer, + _src_buffer: Buffer, + _dst_buffer: Buffer, + _region_count: u32, + _p_regions: *const BufferCopy, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_copy_buffer)) + } let raw_name = stringify!(vkCmdCopyBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_copy_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_copy_image: unsafe { + extern "system" fn cmd_copy_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageCopy, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_copy_image)) + } let raw_name = stringify!(vkCmdCopyImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_copy_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_blit_image: unsafe { + extern "system" fn cmd_blit_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageBlit, + _filter: Filter, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_blit_image)) + } let raw_name = stringify!(vkCmdBlitImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_blit_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_copy_buffer_to_image: unsafe { + extern "system" fn cmd_copy_buffer_to_image( + _command_buffer: CommandBuffer, + _src_buffer: Buffer, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const BufferImageCopy, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_copy_buffer_to_image)) + } let raw_name = stringify!(vkCmdCopyBufferToImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_copy_buffer_to_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_copy_image_to_buffer: unsafe { + extern "system" fn cmd_copy_image_to_buffer( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_buffer: Buffer, + _region_count: u32, + _p_regions: *const BufferImageCopy, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_copy_image_to_buffer)) + } let raw_name = stringify!(vkCmdCopyImageToBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_copy_image_to_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_update_buffer: unsafe { + extern "system" fn cmd_update_buffer( + _command_buffer: CommandBuffer, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _data_size: DeviceSize, + _p_data: *const c_void, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_update_buffer)) + } let raw_name = stringify!(vkCmdUpdateBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_update_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_fill_buffer: unsafe { + extern "system" fn cmd_fill_buffer( + _command_buffer: CommandBuffer, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _size: DeviceSize, + _data: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_fill_buffer)) + } let raw_name = stringify!(vkCmdFillBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_fill_buffer + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_clear_color_image: unsafe { + extern "system" fn cmd_clear_color_image( + _command_buffer: CommandBuffer, + _image: Image, + _image_layout: ImageLayout, + _p_color: *const ClearColorValue, + _range_count: u32, + _p_ranges: *const ImageSubresourceRange, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_clear_color_image)) + } let raw_name = stringify!(vkCmdClearColorImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_clear_color_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_clear_depth_stencil_image: unsafe { + extern "system" fn cmd_clear_depth_stencil_image( + _command_buffer: CommandBuffer, + _image: Image, + _image_layout: ImageLayout, + _p_depth_stencil: *const ClearDepthStencilValue, + _range_count: u32, + _p_ranges: *const ImageSubresourceRange, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_clear_depth_stencil_image) + ) + } let raw_name = stringify!(vkCmdClearDepthStencilImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_clear_depth_stencil_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_clear_attachments: unsafe { + extern "system" fn cmd_clear_attachments( + _command_buffer: CommandBuffer, + _attachment_count: u32, + _p_attachments: *const ClearAttachment, + _rect_count: u32, + _p_rects: *const ClearRect, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_clear_attachments)) + } let raw_name = stringify!(vkCmdClearAttachments); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_clear_attachments + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_resolve_image: unsafe { + extern "system" fn cmd_resolve_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageResolve, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_resolve_image)) + } let raw_name = stringify!(vkCmdResolveImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_resolve_image + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_event: unsafe { + extern "system" fn cmd_set_event( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_event)) + } let raw_name = stringify!(vkCmdSetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_event + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_reset_event: unsafe { + extern "system" fn cmd_reset_event( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_reset_event)) + } let raw_name = stringify!(vkCmdResetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_reset_event + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_wait_events: unsafe { + extern "system" fn cmd_wait_events( + _command_buffer: CommandBuffer, + _event_count: u32, + _p_events: *const Event, + _src_stage_mask: PipelineStageFlags, + _dst_stage_mask: PipelineStageFlags, + _memory_barrier_count: u32, + _p_memory_barriers: *const MemoryBarrier, + _buffer_memory_barrier_count: u32, + _p_buffer_memory_barriers: *const BufferMemoryBarrier, + _image_memory_barrier_count: u32, + _p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_wait_events)) + } let raw_name = stringify!(vkCmdWaitEvents); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_wait_events + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_pipeline_barrier: unsafe { + extern "system" fn cmd_pipeline_barrier( + _command_buffer: CommandBuffer, + _src_stage_mask: PipelineStageFlags, + _dst_stage_mask: PipelineStageFlags, + _dependency_flags: DependencyFlags, + _memory_barrier_count: u32, + _p_memory_barriers: *const MemoryBarrier, + _buffer_memory_barrier_count: u32, + _p_buffer_memory_barriers: *const BufferMemoryBarrier, + _image_memory_barrier_count: u32, + _p_image_memory_barriers: *const ImageMemoryBarrier, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_pipeline_barrier)) + } let raw_name = stringify!(vkCmdPipelineBarrier); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_pipeline_barrier + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_begin_query: unsafe { + extern "system" fn cmd_begin_query( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + _flags: QueryControlFlags, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_begin_query)) + } let raw_name = stringify!(vkCmdBeginQuery); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_begin_query + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_end_query: unsafe { + extern "system" fn cmd_end_query( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_end_query)) + } let raw_name = stringify!(vkCmdEndQuery); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_end_query + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_reset_query_pool: unsafe { + extern "system" fn cmd_reset_query_pool( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_reset_query_pool)) + } let raw_name = stringify!(vkCmdResetQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_reset_query_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_write_timestamp: unsafe { + extern "system" fn cmd_write_timestamp( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _query_pool: QueryPool, + _query: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_write_timestamp)) + } let raw_name = stringify!(vkCmdWriteTimestamp); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_write_timestamp + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_copy_query_pool_results: unsafe { + extern "system" fn cmd_copy_query_pool_results( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _stride: DeviceSize, + _flags: QueryResultFlags, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_copy_query_pool_results)) + } let raw_name = stringify!(vkCmdCopyQueryPoolResults); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_copy_query_pool_results + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_push_constants: unsafe { + extern "system" fn cmd_push_constants( + _command_buffer: CommandBuffer, + _layout: PipelineLayout, + _stage_flags: ShaderStageFlags, + _offset: u32, + _size: u32, + _p_values: *const c_void, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_push_constants)) + } let raw_name = stringify!(vkCmdPushConstants); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_push_constants + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_begin_render_pass: unsafe { + extern "system" fn cmd_begin_render_pass( + _command_buffer: CommandBuffer, + _p_render_pass_begin: *const RenderPassBeginInfo, + _contents: SubpassContents, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_begin_render_pass)) + } let raw_name = stringify!(vkCmdBeginRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_begin_render_pass + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_next_subpass: unsafe { + extern "system" fn cmd_next_subpass( + _command_buffer: CommandBuffer, + _contents: SubpassContents, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_next_subpass)) + } let raw_name = stringify!(vkCmdNextSubpass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_next_subpass + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_end_render_pass: unsafe { + extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) -> c_void { + panic!("Unable to load {}", stringify!(cmd_end_render_pass)) + } let raw_name = stringify!(vkCmdEndRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_end_render_pass + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_execute_commands: unsafe { + extern "system" fn cmd_execute_commands( + _command_buffer: CommandBuffer, + _command_buffer_count: u32, + _p_command_buffers: *const CommandBuffer, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_execute_commands)) + } let raw_name = stringify!(vkCmdExecuteCommands); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_execute_commands + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn destroy_device( @@ -3856,26 +5080,24 @@ impl ::std::clone::Clone for EntryFnV1_1 { } } impl EntryFnV1_1 { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = EntryFnV1_1 { + EntryFnV1_1 { enumerate_instance_version: unsafe { + extern "system" fn enumerate_instance_version(_p_api_version: *mut u32) -> Result { + panic!("Unable to load {}", stringify!(enumerate_instance_version)) + } let raw_name = stringify!(vkEnumerateInstanceVersion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + enumerate_instance_version + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut u32) -> Result { @@ -3956,133 +5178,246 @@ impl ::std::clone::Clone for InstanceFnV1_1 { get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, - get_physical_device_image_format_properties2: self - .get_physical_device_image_format_properties2, - get_physical_device_queue_family_properties2: self - .get_physical_device_queue_family_properties2, + get_physical_device_image_format_properties2: + self.get_physical_device_image_format_properties2, + get_physical_device_queue_family_properties2: + self.get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, - get_physical_device_sparse_image_format_properties2: self - .get_physical_device_sparse_image_format_properties2, - get_physical_device_external_buffer_properties: self - .get_physical_device_external_buffer_properties, - get_physical_device_external_fence_properties: self - .get_physical_device_external_fence_properties, - get_physical_device_external_semaphore_properties: self - .get_physical_device_external_semaphore_properties, + get_physical_device_sparse_image_format_properties2: + self.get_physical_device_sparse_image_format_properties2, + get_physical_device_external_buffer_properties: + self.get_physical_device_external_buffer_properties, + get_physical_device_external_fence_properties: + self.get_physical_device_external_fence_properties, + get_physical_device_external_semaphore_properties: + self.get_physical_device_external_semaphore_properties, } } } impl InstanceFnV1_1 { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = InstanceFnV1_1 { + InstanceFnV1_1 { enumerate_physical_device_groups: unsafe { + extern "system" fn enumerate_physical_device_groups( + _instance: Instance, + _p_physical_device_group_count: *mut u32, + _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(enumerate_physical_device_groups) + ) + } let raw_name = stringify!(vkEnumeratePhysicalDeviceGroups); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + enumerate_physical_device_groups + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_features2: unsafe { + extern "system" fn get_physical_device_features2( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_features2) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceFeatures2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_features2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_properties2: unsafe { + extern "system" fn get_physical_device_properties2( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_properties2) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_properties2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_format_properties2: unsafe { + extern "system" fn get_physical_device_format_properties2( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_format_properties2) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_format_properties2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_image_format_properties2: unsafe { + extern "system" fn get_physical_device_image_format_properties2( + _physical_device: PhysicalDevice, + _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + _p_image_format_properties: *mut ImageFormatProperties2, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_image_format_properties2) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_image_format_properties2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_queue_family_properties2: unsafe { + extern "system" fn get_physical_device_queue_family_properties2( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_queue_family_properties2) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_queue_family_properties2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_memory_properties2: unsafe { + extern "system" fn get_physical_device_memory_properties2( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_memory_properties2) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_memory_properties2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_sparse_image_format_properties2: unsafe { + extern "system" fn get_physical_device_sparse_image_format_properties2( + _physical_device: PhysicalDevice, + _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_sparse_image_format_properties2) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_sparse_image_format_properties2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_external_buffer_properties: unsafe { + extern "system" fn get_physical_device_external_buffer_properties( + _physical_device: PhysicalDevice, + _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + _p_external_buffer_properties: *mut ExternalBufferProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_external_buffer_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceExternalBufferProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_external_buffer_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_external_fence_properties: unsafe { + extern "system" fn get_physical_device_external_fence_properties( + _physical_device: PhysicalDevice, + _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + _p_external_fence_properties: *mut ExternalFenceProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_external_fence_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceExternalFenceProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_external_fence_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_external_semaphore_properties: unsafe { + extern "system" fn get_physical_device_external_semaphore_properties( + _physical_device: PhysicalDevice, + _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_external_semaphore_properties) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceExternalSemaphoreProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_external_semaphore_properties + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn enumerate_physical_device_groups( @@ -4322,161 +5657,322 @@ impl ::std::clone::Clone for DeviceFnV1_1 { } } impl DeviceFnV1_1 { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = DeviceFnV1_1 { + DeviceFnV1_1 { bind_buffer_memory2: unsafe { + extern "system" fn bind_buffer_memory2( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindBufferMemoryInfo, + ) -> Result { + panic!("Unable to load {}", stringify!(bind_buffer_memory2)) + } let raw_name = stringify!(vkBindBufferMemory2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + bind_buffer_memory2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, bind_image_memory2: unsafe { + extern "system" fn bind_image_memory2( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindImageMemoryInfo, + ) -> Result { + panic!("Unable to load {}", stringify!(bind_image_memory2)) + } let raw_name = stringify!(vkBindImageMemory2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + bind_image_memory2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_group_peer_memory_features: unsafe { + extern "system" fn get_device_group_peer_memory_features( + _device: Device, + _heap_index: u32, + _local_device_index: u32, + _remote_device_index: u32, + _p_peer_memory_features: *mut PeerMemoryFeatureFlags, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_device_group_peer_memory_features) + ) + } let raw_name = stringify!(vkGetDeviceGroupPeerMemoryFeatures); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_peer_memory_features + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_set_device_mask: unsafe { + extern "system" fn cmd_set_device_mask( + _command_buffer: CommandBuffer, + _device_mask: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_set_device_mask)) + } let raw_name = stringify!(vkCmdSetDeviceMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_device_mask + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_dispatch_base: unsafe { + extern "system" fn cmd_dispatch_base( + _command_buffer: CommandBuffer, + _base_group_x: u32, + _base_group_y: u32, + _base_group_z: u32, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_dispatch_base)) + } let raw_name = stringify!(vkCmdDispatchBase); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_dispatch_base + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_image_memory_requirements2: unsafe { + extern "system" fn get_image_memory_requirements2( + _device: Device, + _p_info: *const ImageMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_image_memory_requirements2) + ) + } let raw_name = stringify!(vkGetImageMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_image_memory_requirements2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_buffer_memory_requirements2: unsafe { + extern "system" fn get_buffer_memory_requirements2( + _device: Device, + _p_info: *const BufferMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_buffer_memory_requirements2) + ) + } let raw_name = stringify!(vkGetBufferMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_buffer_memory_requirements2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_image_sparse_memory_requirements2: unsafe { + extern "system" fn get_image_sparse_memory_requirements2( + _device: Device, + _p_info: *const ImageSparseMemoryRequirementsInfo2, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_image_sparse_memory_requirements2) + ) + } let raw_name = stringify!(vkGetImageSparseMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_image_sparse_memory_requirements2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, trim_command_pool: unsafe { + extern "system" fn trim_command_pool( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolTrimFlags, + ) -> c_void { + panic!("Unable to load {}", stringify!(trim_command_pool)) + } let raw_name = stringify!(vkTrimCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + trim_command_pool + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_queue2: unsafe { + extern "system" fn get_device_queue2( + _device: Device, + _p_queue_info: *const DeviceQueueInfo2, + _p_queue: *mut Queue, + ) -> c_void { + panic!("Unable to load {}", stringify!(get_device_queue2)) + } let raw_name = stringify!(vkGetDeviceQueue2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_queue2 + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_sampler_ycbcr_conversion: unsafe { + extern "system" fn create_sampler_ycbcr_conversion( + _device: Device, + _p_create_info: *const SamplerYcbcrConversionCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_ycbcr_conversion: *mut SamplerYcbcrConversion, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_sampler_ycbcr_conversion) + ) + } let raw_name = stringify!(vkCreateSamplerYcbcrConversion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_sampler_ycbcr_conversion + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_sampler_ycbcr_conversion: unsafe { + extern "system" fn destroy_sampler_ycbcr_conversion( + _device: Device, + _ycbcr_conversion: SamplerYcbcrConversion, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(destroy_sampler_ycbcr_conversion) + ) + } let raw_name = stringify!(vkDestroySamplerYcbcrConversion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_sampler_ycbcr_conversion + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_descriptor_update_template: unsafe { + extern "system" fn create_descriptor_update_template( + _device: Device, + _p_create_info: *const DescriptorUpdateTemplateCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_update_template: *mut DescriptorUpdateTemplate, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_descriptor_update_template) + ) + } let raw_name = stringify!(vkCreateDescriptorUpdateTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_descriptor_update_template + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_descriptor_update_template: unsafe { + extern "system" fn destroy_descriptor_update_template( + _device: Device, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(destroy_descriptor_update_template) + ) + } let raw_name = stringify!(vkDestroyDescriptorUpdateTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_descriptor_update_template + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, update_descriptor_set_with_template: unsafe { + extern "system" fn update_descriptor_set_with_template( + _device: Device, + _descriptor_set: DescriptorSet, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_data: *const c_void, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(update_descriptor_set_with_template) + ) + } let raw_name = stringify!(vkUpdateDescriptorSetWithTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + update_descriptor_set_with_template + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_descriptor_set_layout_support: unsafe { + extern "system" fn get_descriptor_set_layout_support( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_support: *mut DescriptorSetLayoutSupport, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_descriptor_set_layout_support) + ) + } let raw_name = stringify!(vkGetDescriptorSetLayoutSupport); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_descriptor_set_layout_support + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn bind_buffer_memory2( @@ -5381,8 +6877,7 @@ impl fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }) - .field("pipeline_cache_uuid", &self.pipeline_cache_uuid) + }).field("pipeline_cache_uuid", &self.pipeline_cache_uuid) .field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() @@ -5485,8 +6980,7 @@ impl fmt::Debug for ExtensionProperties { fmt.debug_struct("ExtensionProperties") .field("extension_name", &unsafe { ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .finish() } } @@ -5545,13 +7039,11 @@ impl fmt::Debug for LayerProperties { fmt.debug_struct("LayerProperties") .field("layer_name", &unsafe { ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const i8) - }) - .field("spec_version", &self.spec_version) + }).field("spec_version", &self.spec_version) .field("implementation_version", &self.implementation_version) .field("description", &unsafe { ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const i8) - }) - .finish() + }).finish() } } impl ::std::default::Default for LayerProperties { @@ -5699,21 +7191,17 @@ impl fmt::Debug for AllocationCallbacks { .field( "pfn_allocation", &(self.pfn_allocation.map(|x| x as *const ())), - ) - .field( + ).field( "pfn_reallocation", &(self.pfn_reallocation.map(|x| x as *const ())), - ) - .field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) + ).field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) .field( "pfn_internal_allocation", &(self.pfn_internal_allocation.map(|x| x as *const ())), - ) - .field( + ).field( "pfn_internal_free", &(self.pfn_internal_free.map(|x| x as *const ())), - ) - .finish() + ).finish() } } impl ::std::default::Default for AllocationCallbacks { @@ -24424,8 +25912,7 @@ impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { .field( "pfn_user_callback", &(self.pfn_user_callback.map(|x| x as *const ())), - ) - .field("p_user_data", &self.p_user_data) + ).field("p_user_data", &self.p_user_data) .finish() } } @@ -28560,72 +30047,121 @@ pub mod extensions { destroy_surface_khr: self.destroy_surface_khr, get_physical_device_surface_support_khr: self .get_physical_device_surface_support_khr, - get_physical_device_surface_capabilities_khr: self - .get_physical_device_surface_capabilities_khr, + get_physical_device_surface_capabilities_khr: + self.get_physical_device_surface_capabilities_khr, get_physical_device_surface_formats_khr: self .get_physical_device_surface_formats_khr, - get_physical_device_surface_present_modes_khr: self - .get_physical_device_surface_present_modes_khr, + get_physical_device_surface_present_modes_khr: + self.get_physical_device_surface_present_modes_khr, } } } impl KhrSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSurfaceFn { + KhrSurfaceFn { destroy_surface_khr: unsafe { + extern "system" fn destroy_surface_khr( + _instance: Instance, + _surface: SurfaceKHR, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_surface_khr)) + } let raw_name = stringify!(vkDestroySurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_support_khr: unsafe { + extern "system" fn get_physical_device_surface_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _surface: SurfaceKHR, + _p_supported: *mut Bool32, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_surface_support_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_capabilities_khr: unsafe { + extern "system" fn get_physical_device_surface_capabilities_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilitiesKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_surface_capabilities_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_formats_khr: unsafe { + extern "system" fn get_physical_device_surface_formats_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormatKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_surface_formats_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_formats_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_present_modes_khr: unsafe { + extern "system" fn get_physical_device_surface_present_modes_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_present_mode_count: *mut u32, + _p_present_modes: *mut PresentModeKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_surface_present_modes_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_present_modes_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn destroy_surface_khr( @@ -28714,109 +30250,184 @@ pub mod extensions { get_swapchain_images_khr: self.get_swapchain_images_khr, acquire_next_image_khr: self.acquire_next_image_khr, queue_present_khr: self.queue_present_khr, - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } } impl KhrSwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSwapchainFn { + KhrSwapchainFn { create_swapchain_khr: unsafe { + extern "system" fn create_swapchain_khr( + _device: Device, + _p_create_info: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchain: *mut SwapchainKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_swapchain_khr)) + } let raw_name = stringify!(vkCreateSwapchainKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_swapchain_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_swapchain_khr: unsafe { + extern "system" fn destroy_swapchain_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_swapchain_khr)) + } let raw_name = stringify!(vkDestroySwapchainKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_swapchain_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_swapchain_images_khr: unsafe { + extern "system" fn get_swapchain_images_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_swapchain_image_count: *mut u32, + _p_swapchain_images: *mut Image, + ) -> Result { + panic!("Unable to load {}", stringify!(get_swapchain_images_khr)) + } let raw_name = stringify!(vkGetSwapchainImagesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_images_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_next_image_khr: unsafe { + extern "system" fn acquire_next_image_khr( + _device: Device, + _swapchain: SwapchainKHR, + _timeout: u64, + _semaphore: Semaphore, + _fence: Fence, + _p_image_index: *mut u32, + ) -> Result { + panic!("Unable to load {}", stringify!(acquire_next_image_khr)) + } let raw_name = stringify!(vkAcquireNextImageKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_next_image_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_present_khr: unsafe { + extern "system" fn queue_present_khr( + _queue: Queue, + _p_present_info: *const PresentInfoKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(queue_present_khr)) + } let raw_name = stringify!(vkQueuePresentKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_present_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - get_device_group_present_capabilities_khr: unsafe { + get_device_group_present_capabilities_khr: unsafe {extern "system" fn get_device_group_present_capabilities_khr ( _device : Device , _p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result{ + panic!( + "Unable to load {}", + stringify!(get_device_group_present_capabilities_khr) + ) + } let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_group_surface_present_modes_khr: unsafe { + extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_device_group_surface_present_modes_khr) + ) + } let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_present_rectangles_khr: unsafe { + extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_present_rectangles_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_next_image2_khr: unsafe { + extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!("Unable to load {}", stringify!(acquire_next_image2_khr)) + } let raw_name = stringify!(vkAcquireNextImage2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_swapchain_khr( @@ -29026,10 +30637,10 @@ pub mod extensions { impl ::std::clone::Clone for KhrDisplayFn { fn clone(&self) -> Self { KhrDisplayFn { - get_physical_device_display_properties_khr: self - .get_physical_device_display_properties_khr, - get_physical_device_display_plane_properties_khr: self - .get_physical_device_display_plane_properties_khr, + get_physical_device_display_properties_khr: + self.get_physical_device_display_properties_khr, + get_physical_device_display_plane_properties_khr: + self.get_physical_device_display_plane_properties_khr, get_display_plane_supported_displays_khr: self .get_display_plane_supported_displays_khr, get_display_mode_properties_khr: self.get_display_mode_properties_khr, @@ -29040,80 +30651,154 @@ pub mod extensions { } } impl KhrDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDisplayFn { + KhrDisplayFn { get_physical_device_display_properties_khr: unsafe { + extern "system" fn get_physical_device_display_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPropertiesKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_display_properties_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_display_plane_properties_khr: unsafe { + extern "system" fn get_physical_device_display_plane_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlanePropertiesKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_display_plane_properties_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_plane_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_plane_supported_displays_khr: unsafe { + extern "system" fn get_display_plane_supported_displays_khr( + _physical_device: PhysicalDevice, + _plane_index: u32, + _p_display_count: *mut u32, + _p_displays: *mut DisplayKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_display_plane_supported_displays_khr) + ) + } let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_plane_supported_displays_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_mode_properties_khr: unsafe { + extern "system" fn get_display_mode_properties_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModePropertiesKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_display_mode_properties_khr) + ) + } let raw_name = stringify!(vkGetDisplayModePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_mode_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_display_mode_khr: unsafe { + extern "system" fn create_display_mode_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_create_info: *const DisplayModeCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_mode: *mut DisplayModeKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_display_mode_khr)) + } let raw_name = stringify!(vkCreateDisplayModeKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_display_mode_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_plane_capabilities_khr: unsafe { + extern "system" fn get_display_plane_capabilities_khr( + _physical_device: PhysicalDevice, + _mode: DisplayModeKHR, + _plane_index: u32, + _p_capabilities: *mut DisplayPlaneCapabilitiesKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_display_plane_capabilities_khr) + ) + } let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_plane_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_display_plane_surface_khr: unsafe { + extern "system" fn create_display_plane_surface_khr( + _instance: Instance, + _p_create_info: *const DisplaySurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_display_plane_surface_khr) + ) + } let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_display_plane_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_display_properties_khr( @@ -29244,26 +30929,33 @@ pub mod extensions { } } impl KhrDisplaySwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDisplaySwapchainFn { + KhrDisplaySwapchainFn { create_shared_swapchains_khr: unsafe { + extern "system" fn create_shared_swapchains_khr( + _device: Device, + _swapchain_count: u32, + _p_create_infos: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchains: *mut SwapchainKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_shared_swapchains_khr) + ) + } let raw_name = stringify!(vkCreateSharedSwapchainsKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_shared_swapchains_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_shared_swapchains_khr( @@ -29312,41 +31004,56 @@ pub mod extensions { fn clone(&self) -> Self { KhrXlibSurfaceFn { create_xlib_surface_khr: self.create_xlib_surface_khr, - get_physical_device_xlib_presentation_support_khr: self - .get_physical_device_xlib_presentation_support_khr, + get_physical_device_xlib_presentation_support_khr: + self.get_physical_device_xlib_presentation_support_khr, } } } impl KhrXlibSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrXlibSurfaceFn { + KhrXlibSurfaceFn { create_xlib_surface_khr: unsafe { + extern "system" fn create_xlib_surface_khr( + _instance: Instance, + _p_create_info: *const XlibSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_xlib_surface_khr)) + } let raw_name = stringify!(vkCreateXlibSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_xlib_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_xlib_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_xlib_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _dpy: *mut Display, + _visual_id: VisualID, + ) -> Bool32 { + panic!( + "Unable to load {}", + stringify!(get_physical_device_xlib_presentation_support_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_xlib_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_xlib_surface_khr( @@ -29398,41 +31105,56 @@ pub mod extensions { fn clone(&self) -> Self { KhrXcbSurfaceFn { create_xcb_surface_khr: self.create_xcb_surface_khr, - get_physical_device_xcb_presentation_support_khr: self - .get_physical_device_xcb_presentation_support_khr, + get_physical_device_xcb_presentation_support_khr: + self.get_physical_device_xcb_presentation_support_khr, } } } impl KhrXcbSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrXcbSurfaceFn { + KhrXcbSurfaceFn { create_xcb_surface_khr: unsafe { + extern "system" fn create_xcb_surface_khr( + _instance: Instance, + _p_create_info: *const XcbSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_xcb_surface_khr)) + } let raw_name = stringify!(vkCreateXcbSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_xcb_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_xcb_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_xcb_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _connection: *mut xcb_connection_t, + _visual_id: xcb_visualid_t, + ) -> Bool32 { + panic!( + "Unable to load {}", + stringify!(get_physical_device_xcb_presentation_support_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_xcb_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_xcb_surface_khr( @@ -29484,41 +31206,55 @@ pub mod extensions { fn clone(&self) -> Self { KhrWaylandSurfaceFn { create_wayland_surface_khr: self.create_wayland_surface_khr, - get_physical_device_wayland_presentation_support_khr: self - .get_physical_device_wayland_presentation_support_khr, + get_physical_device_wayland_presentation_support_khr: + self.get_physical_device_wayland_presentation_support_khr, } } } impl KhrWaylandSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrWaylandSurfaceFn { + KhrWaylandSurfaceFn { create_wayland_surface_khr: unsafe { + extern "system" fn create_wayland_surface_khr( + _instance: Instance, + _p_create_info: *const WaylandSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_wayland_surface_khr)) + } let raw_name = stringify!(vkCreateWaylandSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_wayland_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_wayland_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_wayland_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _display: *mut wl_display, + ) -> Bool32 { + panic!( + "Unable to load {}", + stringify!(get_physical_device_wayland_presentation_support_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_wayland_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_wayland_surface_khr( @@ -29567,41 +31303,55 @@ pub mod extensions { fn clone(&self) -> Self { KhrMirSurfaceFn { create_mir_surface_khr: self.create_mir_surface_khr, - get_physical_device_mir_presentation_support_khr: self - .get_physical_device_mir_presentation_support_khr, + get_physical_device_mir_presentation_support_khr: + self.get_physical_device_mir_presentation_support_khr, } } } impl KhrMirSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMirSurfaceFn { + KhrMirSurfaceFn { create_mir_surface_khr: unsafe { + extern "system" fn create_mir_surface_khr( + _instance: Instance, + _p_create_info: *const MirSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_mir_surface_khr)) + } let raw_name = stringify!(vkCreateMirSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_mir_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_mir_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_mir_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _connection: *mut MirConnection, + ) -> Bool32 { + panic!( + "Unable to load {}", + stringify!(get_physical_device_mir_presentation_support_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_mir_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_mir_surface_khr( @@ -29649,26 +31399,29 @@ pub mod extensions { } } impl KhrAndroidSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrAndroidSurfaceFn { + KhrAndroidSurfaceFn { create_android_surface_khr: unsafe { + extern "system" fn create_android_surface_khr( + _instance: Instance, + _p_create_info: *const AndroidSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_android_surface_khr)) + } let raw_name = stringify!(vkCreateAndroidSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_android_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_android_surface_khr( @@ -29702,41 +31455,54 @@ pub mod extensions { fn clone(&self) -> Self { KhrWin32SurfaceFn { create_win32_surface_khr: self.create_win32_surface_khr, - get_physical_device_win32_presentation_support_khr: self - .get_physical_device_win32_presentation_support_khr, + get_physical_device_win32_presentation_support_khr: + self.get_physical_device_win32_presentation_support_khr, } } } impl KhrWin32SurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrWin32SurfaceFn { + KhrWin32SurfaceFn { create_win32_surface_khr: unsafe { + extern "system" fn create_win32_surface_khr( + _instance: Instance, + _p_create_info: *const Win32SurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_win32_surface_khr)) + } let raw_name = stringify!(vkCreateWin32SurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_win32_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_win32_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_win32_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + ) -> Bool32 { + panic!( + "Unable to load {}", + stringify!(get_physical_device_win32_presentation_support_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_win32_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_win32_surface_khr( @@ -29797,44 +31563,73 @@ pub mod extensions { } } impl AndroidNativeBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AndroidNativeBufferFn { + AndroidNativeBufferFn { get_swapchain_gralloc_usage_android: unsafe { + extern "system" fn get_swapchain_gralloc_usage_android( + _device: Device, + _format: Format, + _image_usage: ImageUsageFlags, + _gralloc_usage: *mut c_int, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_swapchain_gralloc_usage_android) + ) + } let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_gralloc_usage_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_image_android: unsafe { + extern "system" fn acquire_image_android( + _device: Device, + _image: Image, + _native_fence_fd: c_int, + _semaphore: Semaphore, + _fence: Fence, + ) -> Result { + panic!("Unable to load {}", stringify!(acquire_image_android)) + } let raw_name = stringify!(vkAcquireImageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_image_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_signal_release_image_android: unsafe { + extern "system" fn queue_signal_release_image_android( + _queue: Queue, + _wait_semaphore_count: u32, + _p_wait_semaphores: *const Semaphore, + _image: Image, + _p_native_fence_fd: *mut c_int, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(queue_signal_release_image_android) + ) + } let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_signal_release_image_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_swapchain_gralloc_usage_android( @@ -29914,44 +31709,74 @@ pub mod extensions { } } impl ExtDebugReportFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDebugReportFn { + ExtDebugReportFn { create_debug_report_callback_ext: unsafe { + extern "system" fn create_debug_report_callback_ext( + _instance: Instance, + _p_create_info: *const DebugReportCallbackCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_callback: *mut DebugReportCallbackEXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_debug_report_callback_ext) + ) + } let raw_name = stringify!(vkCreateDebugReportCallbackEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_debug_report_callback_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_debug_report_callback_ext: unsafe { + extern "system" fn destroy_debug_report_callback_ext( + _instance: Instance, + _callback: DebugReportCallbackEXT, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(destroy_debug_report_callback_ext) + ) + } let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_debug_report_callback_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, debug_report_message_ext: unsafe { + extern "system" fn debug_report_message_ext( + _instance: Instance, + _flags: DebugReportFlagsEXT, + _object_type: DebugReportObjectTypeEXT, + _object: u64, + _location: usize, + _message_code: i32, + _p_layer_prefix: *const c_char, + _p_message: *const c_char, + ) -> c_void { + panic!("Unable to load {}", stringify!(debug_report_message_ext)) + } let raw_name = stringify!(vkDebugReportMessageEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + debug_report_message_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_debug_report_callback_ext( @@ -30028,17 +31853,11 @@ pub mod extensions { } } impl NvGlslShaderFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvGlslShaderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvGlslShaderFn {} } } #[doc = "Generated from \'VK_NV_glsl_shader\'"] @@ -30054,17 +31873,11 @@ pub mod extensions { } } impl ExtDepthRangeUnrestrictedFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDepthRangeUnrestrictedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtDepthRangeUnrestrictedFn {} } } pub struct KhrSamplerMirrorClampToEdgeFn {} @@ -30076,17 +31889,11 @@ pub mod extensions { } } impl KhrSamplerMirrorClampToEdgeFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSamplerMirrorClampToEdgeFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrSamplerMirrorClampToEdgeFn {} } } pub struct ImgFilterCubicFn {} @@ -30098,17 +31905,11 @@ pub mod extensions { } } impl ImgFilterCubicFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgFilterCubicFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgFilterCubicFn {} } } #[doc = "Generated from \'VK_IMG_filter_cubic\'"] @@ -30128,17 +31929,11 @@ pub mod extensions { } } impl AmdExtension17Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension17Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension17Fn {} } } pub struct AmdExtension18Fn {} @@ -30150,17 +31945,11 @@ pub mod extensions { } } impl AmdExtension18Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension18Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension18Fn {} } } pub struct AmdRasterizationOrderFn {} @@ -30172,17 +31961,11 @@ pub mod extensions { } } impl AmdRasterizationOrderFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdRasterizationOrderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdRasterizationOrderFn {} } } #[doc = "Generated from \'VK_AMD_rasterization_order\'"] @@ -30199,17 +31982,11 @@ pub mod extensions { } } impl AmdExtension20Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension20Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension20Fn {} } } pub struct AmdShaderTrinaryMinmaxFn {} @@ -30221,17 +31998,11 @@ pub mod extensions { } } impl AmdShaderTrinaryMinmaxFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderTrinaryMinmaxFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderTrinaryMinmaxFn {} } } pub struct AmdShaderExplicitVertexParameterFn {} @@ -30243,17 +32014,11 @@ pub mod extensions { } } impl AmdShaderExplicitVertexParameterFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderExplicitVertexParameterFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderExplicitVertexParameterFn {} } } pub struct ExtDebugMarkerFn { @@ -30289,62 +32054,96 @@ pub mod extensions { } } impl ExtDebugMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDebugMarkerFn { + ExtDebugMarkerFn { debug_marker_set_object_tag_ext: unsafe { + extern "system" fn debug_marker_set_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugMarkerObjectTagInfoEXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(debug_marker_set_object_tag_ext) + ) + } let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + debug_marker_set_object_tag_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, debug_marker_set_object_name_ext: unsafe { + extern "system" fn debug_marker_set_object_name_ext( + _device: Device, + _p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(debug_marker_set_object_name_ext) + ) + } let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + debug_marker_set_object_name_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_debug_marker_begin_ext: unsafe { + extern "system" fn cmd_debug_marker_begin_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_debug_marker_begin_ext)) + } let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_debug_marker_begin_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_debug_marker_end_ext: unsafe { + extern "system" fn cmd_debug_marker_end_ext( + _command_buffer: CommandBuffer, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_debug_marker_end_ext)) + } let raw_name = stringify!(vkCmdDebugMarkerEndEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_debug_marker_end_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_debug_marker_insert_ext: unsafe { + extern "system" fn cmd_debug_marker_insert_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_debug_marker_insert_ext)) + } let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_debug_marker_insert_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn debug_marker_set_object_tag_ext( @@ -30400,17 +32199,11 @@ pub mod extensions { } } impl AmdExtension24Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension24Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension24Fn {} } } pub struct AmdExtension25Fn {} @@ -30422,17 +32215,11 @@ pub mod extensions { } } impl AmdExtension25Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension25Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension25Fn {} } } pub struct AmdGcnShaderFn {} @@ -30444,17 +32231,11 @@ pub mod extensions { } } impl AmdGcnShaderFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdGcnShaderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdGcnShaderFn {} } } pub struct NvDedicatedAllocationFn {} @@ -30466,17 +32247,11 @@ pub mod extensions { } } impl NvDedicatedAllocationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvDedicatedAllocationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvDedicatedAllocationFn {} } } #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] @@ -30500,17 +32275,11 @@ pub mod extensions { } } impl ExtExtension28Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension28Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension28Fn {} } } pub struct NvxExtension29Fn {} @@ -30522,17 +32291,11 @@ pub mod extensions { } } impl NvxExtension29Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension29Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension29Fn {} } } pub struct NvxExtension30Fn {} @@ -30544,17 +32307,11 @@ pub mod extensions { } } impl NvxExtension30Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension30Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension30Fn {} } } pub struct NvxExtension31Fn {} @@ -30566,17 +32323,11 @@ pub mod extensions { } } impl NvxExtension31Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension31Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension31Fn {} } } pub struct AmdExtension32Fn {} @@ -30588,17 +32339,11 @@ pub mod extensions { } } impl AmdExtension32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension32Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension32Fn {} } } pub struct AmdExtension33Fn {} @@ -30610,17 +32355,11 @@ pub mod extensions { } } impl AmdExtension33Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension33Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension33Fn {} } } pub struct AmdDrawIndirectCountFn { @@ -30654,35 +32393,56 @@ pub mod extensions { } } impl AmdDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdDrawIndirectCountFn { + AmdDrawIndirectCountFn { cmd_draw_indirect_count_amd: unsafe { + extern "system" fn cmd_draw_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_draw_indirect_count_amd)) + } let raw_name = stringify!(vkCmdDrawIndirectCountAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indirect_count_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw_indexed_indirect_count_amd: unsafe { + extern "system" fn cmd_draw_indexed_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_draw_indexed_indirect_count_amd) + ) + } let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indexed_indirect_count_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_draw_indirect_count_amd( @@ -30735,17 +32495,11 @@ pub mod extensions { } } impl AmdExtension35Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension35Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension35Fn {} } } pub struct AmdNegativeViewportHeightFn {} @@ -30757,17 +32511,11 @@ pub mod extensions { } } impl AmdNegativeViewportHeightFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdNegativeViewportHeightFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdNegativeViewportHeightFn {} } } pub struct AmdGpuShaderHalfFloatFn {} @@ -30779,17 +32527,11 @@ pub mod extensions { } } impl AmdGpuShaderHalfFloatFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdGpuShaderHalfFloatFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdGpuShaderHalfFloatFn {} } } pub struct AmdShaderBallotFn {} @@ -30801,17 +32543,11 @@ pub mod extensions { } } impl AmdShaderBallotFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderBallotFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderBallotFn {} } } pub struct AmdExtension39Fn {} @@ -30823,17 +32559,11 @@ pub mod extensions { } } impl AmdExtension39Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension39Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension39Fn {} } } pub struct AmdExtension40Fn {} @@ -30845,17 +32575,11 @@ pub mod extensions { } } impl AmdExtension40Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension40Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension40Fn {} } } pub struct AmdExtension41Fn {} @@ -30867,17 +32591,11 @@ pub mod extensions { } } impl AmdExtension41Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension41Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension41Fn {} } } pub struct AmdTextureGatherBiasLodFn {} @@ -30889,17 +32607,11 @@ pub mod extensions { } } impl AmdTextureGatherBiasLodFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdTextureGatherBiasLodFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdTextureGatherBiasLodFn {} } } #[doc = "Generated from \'VK_AMD_texture_gather_bias_lod\'"] @@ -30926,26 +32638,31 @@ pub mod extensions { } } impl AmdShaderInfoFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderInfoFn { + AmdShaderInfoFn { get_shader_info_amd: unsafe { + extern "system" fn get_shader_info_amd( + _device: Device, + _pipeline: Pipeline, + _shader_stage: ShaderStageFlags, + _info_type: ShaderInfoTypeAMD, + _p_info_size: *mut usize, + _p_info: *mut c_void, + ) -> Result { + panic!("Unable to load {}", stringify!(get_shader_info_amd)) + } let raw_name = stringify!(vkGetShaderInfoAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_shader_info_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_shader_info_amd( @@ -30976,17 +32693,11 @@ pub mod extensions { } } impl AmdExtension44Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension44Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension44Fn {} } } pub struct AmdExtension45Fn {} @@ -30998,17 +32709,11 @@ pub mod extensions { } } impl AmdExtension45Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension45Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension45Fn {} } } pub struct AmdExtension46Fn {} @@ -31020,17 +32725,11 @@ pub mod extensions { } } impl AmdExtension46Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension46Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension46Fn {} } } pub struct AmdShaderImageLoadStoreLodFn {} @@ -31042,17 +32741,11 @@ pub mod extensions { } } impl AmdShaderImageLoadStoreLodFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderImageLoadStoreLodFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderImageLoadStoreLodFn {} } } pub struct NvxExtension48Fn {} @@ -31064,17 +32757,11 @@ pub mod extensions { } } impl NvxExtension48Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension48Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension48Fn {} } } pub struct GoogleExtension49Fn {} @@ -31086,17 +32773,11 @@ pub mod extensions { } } impl GoogleExtension49Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension49Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension49Fn {} } } pub struct GoogleExtension50Fn {} @@ -31108,17 +32789,11 @@ pub mod extensions { } } impl GoogleExtension50Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension50Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension50Fn {} } } pub struct NvxExtension51Fn {} @@ -31130,17 +32805,11 @@ pub mod extensions { } } impl NvxExtension51Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension51Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension51Fn {} } } pub struct NvxExtension52Fn {} @@ -31152,17 +32821,11 @@ pub mod extensions { } } impl NvxExtension52Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension52Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension52Fn {} } } pub struct NvExtension53Fn {} @@ -31174,17 +32837,11 @@ pub mod extensions { } } impl NvExtension53Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension53Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension53Fn {} } } pub struct KhrMultiviewFn {} @@ -31196,17 +32853,11 @@ pub mod extensions { } } impl KhrMultiviewFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMultiviewFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMultiviewFn {} } } pub struct ImgFormatPvrtcFn {} @@ -31218,17 +32869,11 @@ pub mod extensions { } } impl ImgFormatPvrtcFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgFormatPvrtcFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgFormatPvrtcFn {} } } #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] @@ -31269,32 +32914,42 @@ pub mod extensions { impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { fn clone(&self) -> Self { NvExternalMemoryCapabilitiesFn { - get_physical_device_external_image_format_properties_nv: self - .get_physical_device_external_image_format_properties_nv, + get_physical_device_external_image_format_properties_nv: + self.get_physical_device_external_image_format_properties_nv, } } } impl NvExternalMemoryCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryCapabilitiesFn { + NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv: unsafe { + extern "system" fn get_physical_device_external_image_format_properties_nv( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _tiling: ImageTiling, + _usage: ImageUsageFlags, + _flags: ImageCreateFlags, + _external_handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_external_image_format_properties_nv) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_external_image_format_properties_nv + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_external_image_format_properties_nv( @@ -31329,17 +32984,11 @@ pub mod extensions { } } impl NvExternalMemoryFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExternalMemoryFn {} } } #[doc = "Generated from \'VK_NV_external_memory\'"] @@ -31369,26 +33018,29 @@ pub mod extensions { } } impl NvExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryWin32Fn { + NvExternalMemoryWin32Fn { get_memory_win32_handle_nv: unsafe { + extern "system" fn get_memory_win32_handle_nv( + _device: Device, + _memory: DeviceMemory, + _handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_handle: *mut HANDLE, + ) -> Result { + panic!("Unable to load {}", stringify!(get_memory_win32_handle_nv)) + } let raw_name = stringify!(vkGetMemoryWin32HandleNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_win32_handle_nv + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_win32_handle_nv( @@ -31418,17 +33070,11 @@ pub mod extensions { } } impl NvWin32KeyedMutexFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvWin32KeyedMutexFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvWin32KeyedMutexFn {} } } #[doc = "Generated from \'VK_NV_win32_keyed_mutex\'"] @@ -31444,17 +33090,11 @@ pub mod extensions { } } impl KhrGetPhysicalDeviceProperties2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetPhysicalDeviceProperties2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrGetPhysicalDeviceProperties2Fn {} } } pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } @@ -31463,64 +33103,95 @@ pub mod extensions { impl ::std::clone::Clone for KhrDeviceGroupFn { fn clone(&self) -> Self { KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: self - .get_device_group_present_capabilities_khr, - get_device_group_surface_present_modes_khr: self - .get_device_group_surface_present_modes_khr, - get_physical_device_present_rectangles_khr: self - .get_physical_device_present_rectangles_khr, + get_device_group_present_capabilities_khr: + self.get_device_group_present_capabilities_khr, + get_device_group_surface_present_modes_khr: + self.get_device_group_surface_present_modes_khr, + get_physical_device_present_rectangles_khr: + self.get_physical_device_present_rectangles_khr, acquire_next_image2_khr: self.acquire_next_image2_khr, } } } impl KhrDeviceGroupFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDeviceGroupFn { - get_device_group_present_capabilities_khr: unsafe { + KhrDeviceGroupFn { + get_device_group_present_capabilities_khr: unsafe {extern "system" fn get_device_group_present_capabilities_khr ( _device : Device , _p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result{ + panic!( + "Unable to load {}", + stringify!(get_device_group_present_capabilities_khr) + ) + } let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_group_surface_present_modes_khr: unsafe { + extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_device_group_surface_present_modes_khr) + ) + } let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_present_rectangles_khr: unsafe { + extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_present_rectangles_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_next_image2_khr: unsafe { + extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!("Unable to load {}", stringify!(acquire_next_image2_khr)) + } let raw_name = stringify!(vkAcquireNextImage2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_device_group_present_capabilities_khr( @@ -31573,17 +33244,11 @@ pub mod extensions { } } impl ExtValidationFlagsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtValidationFlagsFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtValidationFlagsFn {} } } #[doc = "Generated from \'VK_EXT_validation_flags\'"] @@ -31608,26 +33273,29 @@ pub mod extensions { } } impl NnViSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NnViSurfaceFn { + NnViSurfaceFn { create_vi_surface_nn: unsafe { + extern "system" fn create_vi_surface_nn( + _instance: Instance, + _p_create_info: *const ViSurfaceCreateInfoNN, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_vi_surface_nn)) + } let raw_name = stringify!(vkCreateViSurfaceNN); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_vi_surface_nn + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_vi_surface_nn( @@ -31653,17 +33321,11 @@ pub mod extensions { } } impl KhrShaderDrawParametersFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrShaderDrawParametersFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrShaderDrawParametersFn {} } } pub struct ExtShaderSubgroupBallotFn {} @@ -31675,17 +33337,11 @@ pub mod extensions { } } impl ExtShaderSubgroupBallotFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderSubgroupBallotFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderSubgroupBallotFn {} } } pub struct ExtShaderSubgroupVoteFn {} @@ -31697,17 +33353,11 @@ pub mod extensions { } } impl ExtShaderSubgroupVoteFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderSubgroupVoteFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderSubgroupVoteFn {} } } pub struct ArmExtension01Fn {} @@ -31719,17 +33369,11 @@ pub mod extensions { } } impl ArmExtension01Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ArmExtension01Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ArmExtension01Fn {} } } pub struct ArmExtension02Fn {} @@ -31741,17 +33385,11 @@ pub mod extensions { } } impl ArmExtension02Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ArmExtension02Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ArmExtension02Fn {} } } pub struct ImgExtension69Fn {} @@ -31763,17 +33401,11 @@ pub mod extensions { } } impl ImgExtension69Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension69Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension69Fn {} } } pub struct KhrMaintenance1Fn {} @@ -31785,17 +33417,11 @@ pub mod extensions { } } impl KhrMaintenance1Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMaintenance1Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMaintenance1Fn {} } } pub struct KhrDeviceGroupCreationFn {} @@ -31807,17 +33433,11 @@ pub mod extensions { } } impl KhrDeviceGroupCreationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDeviceGroupCreationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrDeviceGroupCreationFn {} } } pub struct KhrExternalMemoryCapabilitiesFn {} @@ -31829,17 +33449,11 @@ pub mod extensions { } } impl KhrExternalMemoryCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalMemoryCapabilitiesFn {} } } pub struct KhrExternalMemoryFn {} @@ -31851,17 +33465,11 @@ pub mod extensions { } } impl KhrExternalMemoryFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalMemoryFn {} } } pub struct KhrExternalMemoryWin32Fn { get_memory_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const MemoryGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , get_memory_win32_handle_properties_khr : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , handle : HANDLE , p_memory_win32_handle_properties : *mut MemoryWin32HandlePropertiesKHR , ) -> Result , } @@ -31876,35 +33484,49 @@ pub mod extensions { } } impl KhrExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryWin32Fn { + KhrExternalMemoryWin32Fn { get_memory_win32_handle_khr: unsafe { + extern "system" fn get_memory_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!("Unable to load {}", stringify!(get_memory_win32_handle_khr)) + } let raw_name = stringify!(vkGetMemoryWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_memory_win32_handle_properties_khr: unsafe { + extern "system" fn get_memory_win32_handle_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _handle: HANDLE, + _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_memory_win32_handle_properties_khr) + ) + } let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_win32_handle_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_win32_handle_khr( @@ -31971,35 +33593,49 @@ pub mod extensions { } } impl KhrExternalMemoryFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryFdFn { + KhrExternalMemoryFdFn { get_memory_fd_khr: unsafe { + extern "system" fn get_memory_fd_khr( + _device: Device, + _p_get_fd_info: *const MemoryGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!("Unable to load {}", stringify!(get_memory_fd_khr)) + } let raw_name = stringify!(vkGetMemoryFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_memory_fd_properties_khr: unsafe { + extern "system" fn get_memory_fd_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _fd: c_int, + _p_memory_fd_properties: *mut MemoryFdPropertiesKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_memory_fd_properties_khr) + ) + } let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_fd_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_fd_khr( @@ -32041,17 +33677,11 @@ pub mod extensions { } } impl KhrWin32KeyedMutexFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrWin32KeyedMutexFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrWin32KeyedMutexFn {} } } #[doc = "Generated from \'VK_KHR_win32_keyed_mutex\'"] @@ -32067,17 +33697,11 @@ pub mod extensions { } } impl KhrExternalSemaphoreCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalSemaphoreCapabilitiesFn {} } } pub struct KhrExternalSemaphoreFn {} @@ -32089,17 +33713,11 @@ pub mod extensions { } } impl KhrExternalSemaphoreFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalSemaphoreFn {} } } pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } @@ -32114,35 +33732,46 @@ pub mod extensions { } } impl KhrExternalSemaphoreWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreWin32Fn { - import_semaphore_win32_handle_khr: unsafe { + KhrExternalSemaphoreWin32Fn { + import_semaphore_win32_handle_khr: unsafe {extern "system" fn import_semaphore_win32_handle_khr ( _device : Device , _p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result{ + panic!( + "Unable to load {}", + stringify!(import_semaphore_win32_handle_khr) + ) + } let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_semaphore_win32_handle_khr: unsafe { + extern "system" fn get_semaphore_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_semaphore_win32_handle_khr) + ) + } let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_semaphore_win32_handle_khr( @@ -32200,35 +33829,44 @@ pub mod extensions { } } impl KhrExternalSemaphoreFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreFdFn { + KhrExternalSemaphoreFdFn { import_semaphore_fd_khr: unsafe { + extern "system" fn import_semaphore_fd_khr( + _device: Device, + _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(import_semaphore_fd_khr)) + } let raw_name = stringify!(vkImportSemaphoreFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_semaphore_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_semaphore_fd_khr: unsafe { + extern "system" fn get_semaphore_fd_khr( + _device: Device, + _p_get_fd_info: *const SemaphoreGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!("Unable to load {}", stringify!(get_semaphore_fd_khr)) + } let raw_name = stringify!(vkGetSemaphoreFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_semaphore_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_semaphore_fd_khr( @@ -32280,41 +33918,59 @@ pub mod extensions { fn clone(&self) -> Self { KhrPushDescriptorFn { cmd_push_descriptor_set_khr: self.cmd_push_descriptor_set_khr, - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } impl KhrPushDescriptorFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrPushDescriptorFn { + KhrPushDescriptorFn { cmd_push_descriptor_set_khr: unsafe { + extern "system" fn cmd_push_descriptor_set_khr( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + _descriptor_write_count: u32, + _p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_push_descriptor_set_khr)) + } let raw_name = stringify!(vkCmdPushDescriptorSetKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_push_descriptor_set_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_push_descriptor_set_with_template_khr: unsafe { + extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_push_descriptor_set_with_template_khr) + ) + } let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_push_descriptor_set_khr( @@ -32369,17 +34025,11 @@ pub mod extensions { } } impl ExtExtension82Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension82Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension82Fn {} } } pub struct KhrExtension83Fn {} @@ -32391,17 +34041,11 @@ pub mod extensions { } } impl KhrExtension83Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension83Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension83Fn {} } } pub struct Khr16bitStorageFn {} @@ -32413,17 +34057,11 @@ pub mod extensions { } } impl Khr16bitStorageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = Khr16bitStorageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + Khr16bitStorageFn {} } } pub struct KhrIncrementalPresentFn {} @@ -32435,17 +34073,11 @@ pub mod extensions { } } impl KhrIncrementalPresentFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrIncrementalPresentFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrIncrementalPresentFn {} } } #[doc = "Generated from \'VK_KHR_incremental_present\'"] @@ -32467,32 +34099,39 @@ pub mod extensions { impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { fn clone(&self) -> Self { KhrDescriptorUpdateTemplateFn { - cmd_push_descriptor_set_with_template_khr: self - .cmd_push_descriptor_set_with_template_khr, + cmd_push_descriptor_set_with_template_khr: + self.cmd_push_descriptor_set_with_template_khr, } } } impl KhrDescriptorUpdateTemplateFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDescriptorUpdateTemplateFn { + KhrDescriptorUpdateTemplateFn { cmd_push_descriptor_set_with_template_khr: unsafe { + extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_push_descriptor_set_with_template_khr) + ) + } let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_push_descriptor_set_with_template_khr( @@ -32582,104 +34221,186 @@ pub mod extensions { destroy_object_table_nvx: self.destroy_object_table_nvx, register_objects_nvx: self.register_objects_nvx, unregister_objects_nvx: self.unregister_objects_nvx, - get_physical_device_generated_commands_properties_nvx: self - .get_physical_device_generated_commands_properties_nvx, + get_physical_device_generated_commands_properties_nvx: + self.get_physical_device_generated_commands_properties_nvx, } } } impl NvxDeviceGeneratedCommandsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxDeviceGeneratedCommandsFn { + NvxDeviceGeneratedCommandsFn { cmd_process_commands_nvx: unsafe { + extern "system" fn cmd_process_commands_nvx( + _command_buffer: CommandBuffer, + _p_process_commands_info: *const CmdProcessCommandsInfoNVX, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_process_commands_nvx)) + } let raw_name = stringify!(vkCmdProcessCommandsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_process_commands_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_reserve_space_for_commands_nvx: unsafe { + extern "system" fn cmd_reserve_space_for_commands_nvx( + _command_buffer: CommandBuffer, + _p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_reserve_space_for_commands_nvx) + ) + } let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_reserve_space_for_commands_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_indirect_commands_layout_nvx: unsafe { + extern "system" fn create_indirect_commands_layout_nvx( + _device: Device, + _p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_indirect_commands_layout_nvx) + ) + } let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_indirect_commands_layout_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_indirect_commands_layout_nvx: unsafe { + extern "system" fn destroy_indirect_commands_layout_nvx( + _device: Device, + _indirect_commands_layout: IndirectCommandsLayoutNVX, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(destroy_indirect_commands_layout_nvx) + ) + } let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_indirect_commands_layout_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_object_table_nvx: unsafe { + extern "system" fn create_object_table_nvx( + _device: Device, + _p_create_info: *const ObjectTableCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_object_table: *mut ObjectTableNVX, + ) -> Result { + panic!("Unable to load {}", stringify!(create_object_table_nvx)) + } let raw_name = stringify!(vkCreateObjectTableNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_object_table_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_object_table_nvx: unsafe { + extern "system" fn destroy_object_table_nvx( + _device: Device, + _object_table: ObjectTableNVX, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!("Unable to load {}", stringify!(destroy_object_table_nvx)) + } let raw_name = stringify!(vkDestroyObjectTableNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_object_table_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, register_objects_nvx: unsafe { + extern "system" fn register_objects_nvx( + _device: Device, + _object_table: ObjectTableNVX, + _object_count: u32, + _pp_object_table_entries: *const *const ObjectTableEntryNVX, + _p_object_indices: *const u32, + ) -> Result { + panic!("Unable to load {}", stringify!(register_objects_nvx)) + } let raw_name = stringify!(vkRegisterObjectsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + register_objects_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, unregister_objects_nvx: unsafe { + extern "system" fn unregister_objects_nvx( + _device: Device, + _object_table: ObjectTableNVX, + _object_count: u32, + _p_object_entry_types: *const ObjectEntryTypeNVX, + _p_object_indices: *const u32, + ) -> Result { + panic!("Unable to load {}", stringify!(unregister_objects_nvx)) + } let raw_name = stringify!(vkUnregisterObjectsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + unregister_objects_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_generated_commands_properties_nvx: unsafe { + extern "system" fn get_physical_device_generated_commands_properties_nvx( + _physical_device: PhysicalDevice, + _p_features: *mut DeviceGeneratedCommandsFeaturesNVX, + _p_limits: *mut DeviceGeneratedCommandsLimitsNVX, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_generated_commands_properties_nvx) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_generated_commands_properties_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_process_commands_nvx( @@ -32847,26 +34568,32 @@ pub mod extensions { } } impl NvClipSpaceWScalingFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvClipSpaceWScalingFn { + NvClipSpaceWScalingFn { cmd_set_viewport_w_scaling_nv: unsafe { + extern "system" fn cmd_set_viewport_w_scaling_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_w_scalings: *const ViewportWScalingNV, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_set_viewport_w_scaling_nv) + ) + } let raw_name = stringify!(vkCmdSetViewportWScalingNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_viewport_w_scaling_nv + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_set_viewport_w_scaling_nv( @@ -32907,26 +34634,27 @@ pub mod extensions { } } impl ExtDirectModeDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDirectModeDisplayFn { + ExtDirectModeDisplayFn { release_display_ext: unsafe { + extern "system" fn release_display_ext( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(release_display_ext)) + } let raw_name = stringify!(vkReleaseDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + release_display_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn release_display_ext( @@ -32961,35 +34689,49 @@ pub mod extensions { } } impl ExtAcquireXlibDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtAcquireXlibDisplayFn { + ExtAcquireXlibDisplayFn { acquire_xlib_display_ext: unsafe { + extern "system" fn acquire_xlib_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _display: DisplayKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(acquire_xlib_display_ext)) + } let raw_name = stringify!(vkAcquireXlibDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_xlib_display_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_rand_r_output_display_ext: unsafe { + extern "system" fn get_rand_r_output_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _rr_output: RROutput, + _p_display: *mut DisplayKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_rand_r_output_display_ext) + ) + } let raw_name = stringify!(vkGetRandROutputDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_rand_r_output_display_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn acquire_xlib_display_ext( @@ -33023,32 +34765,37 @@ pub mod extensions { impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { fn clone(&self) -> Self { ExtDisplaySurfaceCounterFn { - get_physical_device_surface_capabilities2_ext: self - .get_physical_device_surface_capabilities2_ext, + get_physical_device_surface_capabilities2_ext: + self.get_physical_device_surface_capabilities2_ext, } } } impl ExtDisplaySurfaceCounterFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDisplaySurfaceCounterFn { + ExtDisplaySurfaceCounterFn { get_physical_device_surface_capabilities2_ext: unsafe { + extern "system" fn get_physical_device_surface_capabilities2_ext( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilities2EXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_surface_capabilities2_ext) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_capabilities2_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_surface_capabilities2_ext( @@ -33110,53 +34857,83 @@ pub mod extensions { } } impl ExtDisplayControlFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDisplayControlFn { + ExtDisplayControlFn { display_power_control_ext: unsafe { + extern "system" fn display_power_control_ext( + _device: Device, + _display: DisplayKHR, + _p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result { + panic!("Unable to load {}", stringify!(display_power_control_ext)) + } let raw_name = stringify!(vkDisplayPowerControlEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + display_power_control_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, register_device_event_ext: unsafe { + extern "system" fn register_device_event_ext( + _device: Device, + _p_device_event_info: *const DeviceEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!("Unable to load {}", stringify!(register_device_event_ext)) + } let raw_name = stringify!(vkRegisterDeviceEventEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + register_device_event_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, register_display_event_ext: unsafe { + extern "system" fn register_display_event_ext( + _device: Device, + _display: DisplayKHR, + _p_display_event_info: *const DisplayEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!("Unable to load {}", stringify!(register_display_event_ext)) + } let raw_name = stringify!(vkRegisterDisplayEventEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + register_display_event_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_swapchain_counter_ext: unsafe { + extern "system" fn get_swapchain_counter_ext( + _device: Device, + _swapchain: SwapchainKHR, + _counter: SurfaceCounterFlagsEXT, + _p_counter_value: *mut u64, + ) -> Result { + panic!("Unable to load {}", stringify!(get_swapchain_counter_ext)) + } let raw_name = stringify!(vkGetSwapchainCounterEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_counter_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn display_power_control_ext( @@ -33244,35 +35021,52 @@ pub mod extensions { } } impl GoogleDisplayTimingFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleDisplayTimingFn { + GoogleDisplayTimingFn { get_refresh_cycle_duration_google: unsafe { + extern "system" fn get_refresh_cycle_duration_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_refresh_cycle_duration_google) + ) + } let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_refresh_cycle_duration_google + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_past_presentation_timing_google: unsafe { + extern "system" fn get_past_presentation_timing_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_presentation_timing_count: *mut u32, + _p_presentation_timings: *mut PastPresentationTimingGOOGLE, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_past_presentation_timing_google) + ) + } let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_past_presentation_timing_google + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_refresh_cycle_duration_google( @@ -33311,17 +35105,11 @@ pub mod extensions { } } impl NvSampleMaskOverrideCoverageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvSampleMaskOverrideCoverageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvSampleMaskOverrideCoverageFn {} } } pub struct NvGeometryShaderPassthroughFn {} @@ -33333,17 +35121,11 @@ pub mod extensions { } } impl NvGeometryShaderPassthroughFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvGeometryShaderPassthroughFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvGeometryShaderPassthroughFn {} } } pub struct NvViewportArray2Fn {} @@ -33355,17 +35137,11 @@ pub mod extensions { } } impl NvViewportArray2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvViewportArray2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvViewportArray2Fn {} } } pub struct NvxMultiviewPerViewAttributesFn {} @@ -33377,17 +35153,11 @@ pub mod extensions { } } impl NvxMultiviewPerViewAttributesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxMultiviewPerViewAttributesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxMultiviewPerViewAttributesFn {} } } #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] @@ -33412,17 +35182,11 @@ pub mod extensions { } } impl NvViewportSwizzleFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvViewportSwizzleFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvViewportSwizzleFn {} } } #[doc = "Generated from \'VK_NV_viewport_swizzle\'"] @@ -33447,26 +35211,32 @@ pub mod extensions { } } impl ExtDiscardRectanglesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDiscardRectanglesFn { + ExtDiscardRectanglesFn { cmd_set_discard_rectangle_ext: unsafe { + extern "system" fn cmd_set_discard_rectangle_ext( + _command_buffer: CommandBuffer, + _first_discard_rectangle: u32, + _discard_rectangle_count: u32, + _p_discard_rectangles: *const Rect2D, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_set_discard_rectangle_ext) + ) + } let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_discard_rectangle_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_set_discard_rectangle_ext( @@ -33507,17 +35277,11 @@ pub mod extensions { } } impl NvExtension101Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension101Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension101Fn {} } } pub struct ExtConservativeRasterizationFn {} @@ -33529,17 +35293,11 @@ pub mod extensions { } } impl ExtConservativeRasterizationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtConservativeRasterizationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtConservativeRasterizationFn {} } } #[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] @@ -33561,17 +35319,11 @@ pub mod extensions { } } impl NvExtension103Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension103Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension103Fn {} } } pub struct NvExtension104Fn {} @@ -33583,17 +35335,11 @@ pub mod extensions { } } impl NvExtension104Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension104Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension104Fn {} } } pub struct ExtSwapchainColorspaceFn {} @@ -33605,17 +35351,11 @@ pub mod extensions { } } impl ExtSwapchainColorspaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtSwapchainColorspaceFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtSwapchainColorspaceFn {} } } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] @@ -33692,26 +35432,29 @@ pub mod extensions { } } impl ExtHdrMetadataFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtHdrMetadataFn { + ExtHdrMetadataFn { set_hdr_metadata_ext: unsafe { + extern "system" fn set_hdr_metadata_ext( + _device: Device, + _swapchain_count: u32, + _p_swapchains: *const SwapchainKHR, + _p_metadata: *const HdrMetadataEXT, + ) -> c_void { + panic!("Unable to load {}", stringify!(set_hdr_metadata_ext)) + } let raw_name = stringify!(vkSetHdrMetadataEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + set_hdr_metadata_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn set_hdr_metadata_ext( @@ -33737,17 +35480,11 @@ pub mod extensions { } } impl ImgExtension107Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension107Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension107Fn {} } } pub struct ImgExtension108Fn {} @@ -33759,17 +35496,11 @@ pub mod extensions { } } impl ImgExtension108Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension108Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension108Fn {} } } pub struct ImgExtension109Fn {} @@ -33781,17 +35512,11 @@ pub mod extensions { } } impl ImgExtension109Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension109Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension109Fn {} } } pub struct ImgExtension110Fn {} @@ -33803,17 +35528,11 @@ pub mod extensions { } } impl ImgExtension110Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension110Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension110Fn {} } } pub struct ImgExtension111Fn {} @@ -33825,17 +35544,11 @@ pub mod extensions { } } impl ImgExtension111Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension111Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension111Fn {} } } pub struct KhrSharedPresentableImageFn { @@ -33852,26 +35565,27 @@ pub mod extensions { } } impl KhrSharedPresentableImageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSharedPresentableImageFn { + KhrSharedPresentableImageFn { get_swapchain_status_khr: unsafe { + extern "system" fn get_swapchain_status_khr( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(get_swapchain_status_khr)) + } let raw_name = stringify!(vkGetSwapchainStatusKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_status_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_swapchain_status_khr( @@ -33907,17 +35621,11 @@ pub mod extensions { } } impl KhrExternalFenceCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalFenceCapabilitiesFn {} } } pub struct KhrExternalFenceFn {} @@ -33929,17 +35637,11 @@ pub mod extensions { } } impl KhrExternalFenceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalFenceFn {} } } pub struct KhrExternalFenceWin32Fn { import_fence_win32_handle_khr : extern "system" fn ( device : Device , p_import_fence_win32_handle_info : *const ImportFenceWin32HandleInfoKHR , ) -> Result , get_fence_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const FenceGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } @@ -33954,35 +35656,47 @@ pub mod extensions { } } impl KhrExternalFenceWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceWin32Fn { + KhrExternalFenceWin32Fn { import_fence_win32_handle_khr: unsafe { + extern "system" fn import_fence_win32_handle_khr( + _device: Device, + _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(import_fence_win32_handle_khr) + ) + } let raw_name = stringify!(vkImportFenceWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_fence_win32_handle_khr: unsafe { + extern "system" fn get_fence_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!("Unable to load {}", stringify!(get_fence_win32_handle_khr)) + } let raw_name = stringify!(vkGetFenceWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_fence_win32_handle_khr( @@ -34034,35 +35748,44 @@ pub mod extensions { } } impl KhrExternalFenceFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceFdFn { + KhrExternalFenceFdFn { import_fence_fd_khr: unsafe { + extern "system" fn import_fence_fd_khr( + _device: Device, + _p_import_fence_fd_info: *const ImportFenceFdInfoKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(import_fence_fd_khr)) + } let raw_name = stringify!(vkImportFenceFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_fence_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_fence_fd_khr: unsafe { + extern "system" fn get_fence_fd_khr( + _device: Device, + _p_get_fd_info: *const FenceGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!("Unable to load {}", stringify!(get_fence_fd_khr)) + } let raw_name = stringify!(vkGetFenceFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_fence_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_fence_fd_khr( @@ -34098,17 +35821,11 @@ pub mod extensions { } } impl KhrExtension117Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension117Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension117Fn {} } } pub struct KhrMaintenance2Fn {} @@ -34120,17 +35837,11 @@ pub mod extensions { } } impl KhrMaintenance2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMaintenance2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMaintenance2Fn {} } } pub struct KhrExtension119Fn {} @@ -34142,17 +35853,11 @@ pub mod extensions { } } impl KhrExtension119Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension119Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension119Fn {} } } pub struct KhrGetSurfaceCapabilities2Fn { @@ -34175,43 +35880,60 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { fn clone(&self) -> Self { KhrGetSurfaceCapabilities2Fn { - get_physical_device_surface_capabilities2_khr: self - .get_physical_device_surface_capabilities2_khr, + get_physical_device_surface_capabilities2_khr: + self.get_physical_device_surface_capabilities2_khr, get_physical_device_surface_formats2_khr: self .get_physical_device_surface_formats2_khr, } } } impl KhrGetSurfaceCapabilities2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetSurfaceCapabilities2Fn { + KhrGetSurfaceCapabilities2Fn { get_physical_device_surface_capabilities2_khr: unsafe { + extern "system" fn get_physical_device_surface_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_capabilities: *mut SurfaceCapabilities2KHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_surface_capabilities2_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_capabilities2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_formats2_khr: unsafe { + extern "system" fn get_physical_device_surface_formats2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormat2KHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_surface_formats2_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_formats2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_surface_capabilities2_khr( @@ -34262,17 +35984,11 @@ pub mod extensions { } } impl KhrVariablePointersFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrVariablePointersFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrVariablePointersFn {} } } pub struct KhrGetDisplayProperties2Fn { @@ -34307,63 +36023,102 @@ pub mod extensions { impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { fn clone(&self) -> Self { KhrGetDisplayProperties2Fn { - get_physical_device_display_properties2_khr: self - .get_physical_device_display_properties2_khr, - get_physical_device_display_plane_properties2_khr: self - .get_physical_device_display_plane_properties2_khr, + get_physical_device_display_properties2_khr: + self.get_physical_device_display_properties2_khr, + get_physical_device_display_plane_properties2_khr: + self.get_physical_device_display_plane_properties2_khr, get_display_mode_properties2_khr: self.get_display_mode_properties2_khr, get_display_plane_capabilities2_khr: self.get_display_plane_capabilities2_khr, } } } impl KhrGetDisplayProperties2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetDisplayProperties2Fn { + KhrGetDisplayProperties2Fn { get_physical_device_display_properties2_khr: unsafe { + extern "system" fn get_physical_device_display_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayProperties2KHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_display_properties2_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_properties2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_display_plane_properties2_khr: unsafe { + extern "system" fn get_physical_device_display_plane_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlaneProperties2KHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_physical_device_display_plane_properties2_khr) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_plane_properties2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_mode_properties2_khr: unsafe { + extern "system" fn get_display_mode_properties2_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModeProperties2KHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_display_mode_properties2_khr) + ) + } let raw_name = stringify!(vkGetDisplayModeProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_mode_properties2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_plane_capabilities2_khr: unsafe { + extern "system" fn get_display_plane_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_display_plane_info: *const DisplayPlaneInfo2KHR, + _p_capabilities: *mut DisplayPlaneCapabilities2KHR, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_display_plane_capabilities2_khr) + ) + } let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_plane_capabilities2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_display_properties2_khr( @@ -34455,26 +36210,29 @@ pub mod extensions { } } impl MvkIosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = MvkIosSurfaceFn { + MvkIosSurfaceFn { create_ios_surface_mvk: unsafe { + extern "system" fn create_ios_surface_mvk( + _instance: Instance, + _p_create_info: *const IOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_ios_surface_mvk)) + } let raw_name = stringify!(vkCreateIOSSurfaceMVK); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_ios_surface_mvk + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_ios_surface_mvk( @@ -34510,26 +36268,29 @@ pub mod extensions { } } impl MvkMacosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = MvkMacosSurfaceFn { + MvkMacosSurfaceFn { create_mac_os_surface_mvk: unsafe { + extern "system" fn create_mac_os_surface_mvk( + _instance: Instance, + _p_create_info: *const MacOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!("Unable to load {}", stringify!(create_mac_os_surface_mvk)) + } let raw_name = stringify!(vkCreateMacOSSurfaceMVK); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_mac_os_surface_mvk + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_mac_os_surface_mvk( @@ -34555,17 +36316,11 @@ pub mod extensions { } } impl MvkMoltenvkFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = MvkMoltenvkFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + MvkMoltenvkFn {} } } pub struct ExtExternalMemoryDmaBufFn {} @@ -34577,17 +36332,11 @@ pub mod extensions { } } impl ExtExternalMemoryDmaBufFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExternalMemoryDmaBufFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExternalMemoryDmaBufFn {} } } #[doc = "Generated from \'VK_EXT_external_memory_dma_buf\'"] @@ -34604,17 +36353,11 @@ pub mod extensions { } } impl ExtQueueFamilyForeignFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtQueueFamilyForeignFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtQueueFamilyForeignFn {} } } pub struct KhrDedicatedAllocationFn {} @@ -34626,17 +36369,11 @@ pub mod extensions { } } impl KhrDedicatedAllocationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDedicatedAllocationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrDedicatedAllocationFn {} } } pub struct ExtDebugUtilsFn { @@ -34703,116 +36440,221 @@ pub mod extensions { } } impl ExtDebugUtilsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDebugUtilsFn { + ExtDebugUtilsFn { set_debug_utils_object_name_ext: unsafe { + extern "system" fn set_debug_utils_object_name_ext( + _device: Device, + _p_name_info: *const DebugUtilsObjectNameInfoEXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(set_debug_utils_object_name_ext) + ) + } let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + set_debug_utils_object_name_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, set_debug_utils_object_tag_ext: unsafe { + extern "system" fn set_debug_utils_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugUtilsObjectTagInfoEXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(set_debug_utils_object_tag_ext) + ) + } let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + set_debug_utils_object_tag_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_begin_debug_utils_label_ext: unsafe { + extern "system" fn queue_begin_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(queue_begin_debug_utils_label_ext) + ) + } let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_end_debug_utils_label_ext: unsafe { + extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) -> c_void { + panic!( + "Unable to load {}", + stringify!(queue_end_debug_utils_label_ext) + ) + } let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_insert_debug_utils_label_ext: unsafe { + extern "system" fn queue_insert_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(queue_insert_debug_utils_label_ext) + ) + } let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_begin_debug_utils_label_ext: unsafe { + extern "system" fn cmd_begin_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_begin_debug_utils_label_ext) + ) + } let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_end_debug_utils_label_ext: unsafe { + extern "system" fn cmd_end_debug_utils_label_ext( + _command_buffer: CommandBuffer, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_end_debug_utils_label_ext) + ) + } let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_insert_debug_utils_label_ext: unsafe { + extern "system" fn cmd_insert_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_insert_debug_utils_label_ext) + ) + } let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_debug_utils_messenger_ext: unsafe { + extern "system" fn create_debug_utils_messenger_ext( + _instance: Instance, + _p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_messenger: *mut DebugUtilsMessengerEXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(create_debug_utils_messenger_ext) + ) + } let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_debug_utils_messenger_ext: unsafe { + extern "system" fn destroy_debug_utils_messenger_ext( + _instance: Instance, + _messenger: DebugUtilsMessengerEXT, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(destroy_debug_utils_messenger_ext) + ) + } let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, submit_debug_utils_message_ext: unsafe { + extern "system" fn submit_debug_utils_message_ext( + _instance: Instance, + _message_severity: DebugUtilsMessageSeverityFlagsEXT, + _message_types: DebugUtilsMessageTypeFlagsEXT, + _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(submit_debug_utils_message_ext) + ) + } let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + submit_debug_utils_message_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn set_debug_utils_object_name_ext( @@ -34946,43 +36788,59 @@ pub mod extensions { impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { fn clone(&self) -> Self { AndroidExternalMemoryAndroidHardwareBufferFn { - get_android_hardware_buffer_properties_android: self - .get_android_hardware_buffer_properties_android, - get_memory_android_hardware_buffer_android: self - .get_memory_android_hardware_buffer_android, + get_android_hardware_buffer_properties_android: + self.get_android_hardware_buffer_properties_android, + get_memory_android_hardware_buffer_android: + self.get_memory_android_hardware_buffer_android, } } } impl AndroidExternalMemoryAndroidHardwareBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AndroidExternalMemoryAndroidHardwareBufferFn { + AndroidExternalMemoryAndroidHardwareBufferFn { get_android_hardware_buffer_properties_android: unsafe { + extern "system" fn get_android_hardware_buffer_properties_android( + _device: Device, + _buffer: *const AHardwareBuffer, + _p_properties: *mut AndroidHardwareBufferPropertiesANDROID, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_android_hardware_buffer_properties_android) + ) + } let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_android_hardware_buffer_properties_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_memory_android_hardware_buffer_android: unsafe { + extern "system" fn get_memory_android_hardware_buffer_android( + _device: Device, + _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + _p_buffer: *mut *mut AHardwareBuffer, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_memory_android_hardware_buffer_android) + ) + } let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_android_hardware_buffer_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_android_hardware_buffer_properties_android( @@ -35041,17 +36899,11 @@ pub mod extensions { } } impl ExtSamplerFilterMinmaxFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtSamplerFilterMinmaxFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtSamplerFilterMinmaxFn {} } } #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] @@ -35076,17 +36928,11 @@ pub mod extensions { } } impl KhrStorageBufferStorageClassFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrStorageBufferStorageClassFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrStorageBufferStorageClassFn {} } } pub struct AmdGpuShaderInt16Fn {} @@ -35098,17 +36944,11 @@ pub mod extensions { } } impl AmdGpuShaderInt16Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdGpuShaderInt16Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdGpuShaderInt16Fn {} } } pub struct AmdExtension134Fn {} @@ -35120,17 +36960,11 @@ pub mod extensions { } } impl AmdExtension134Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension134Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension134Fn {} } } pub struct AmdExtension135Fn {} @@ -35142,17 +36976,11 @@ pub mod extensions { } } impl AmdExtension135Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension135Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension135Fn {} } } pub struct AmdExtension136Fn {} @@ -35164,17 +36992,11 @@ pub mod extensions { } } impl AmdExtension136Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension136Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension136Fn {} } } pub struct AmdMixedAttachmentSamplesFn {} @@ -35186,17 +37008,11 @@ pub mod extensions { } } impl AmdMixedAttachmentSamplesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdMixedAttachmentSamplesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdMixedAttachmentSamplesFn {} } } pub struct AmdShaderFragmentMaskFn {} @@ -35208,17 +37024,11 @@ pub mod extensions { } } impl AmdShaderFragmentMaskFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderFragmentMaskFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderFragmentMaskFn {} } } pub struct AmdExtension139Fn {} @@ -35230,17 +37040,11 @@ pub mod extensions { } } impl AmdExtension139Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension139Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension139Fn {} } } pub struct AmdExtension140Fn {} @@ -35252,17 +37056,11 @@ pub mod extensions { } } impl AmdExtension140Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension140Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension140Fn {} } } pub struct ExtShaderStencilExportFn {} @@ -35274,17 +37072,11 @@ pub mod extensions { } } impl ExtShaderStencilExportFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderStencilExportFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderStencilExportFn {} } } pub struct AmdExtension142Fn {} @@ -35296,17 +37088,11 @@ pub mod extensions { } } impl AmdExtension142Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension142Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension142Fn {} } } pub struct AmdExtension143Fn {} @@ -35318,17 +37104,11 @@ pub mod extensions { } } impl AmdExtension143Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension143Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension143Fn {} } } pub struct ExtSampleLocationsFn { @@ -35350,41 +37130,56 @@ pub mod extensions { fn clone(&self) -> Self { ExtSampleLocationsFn { cmd_set_sample_locations_ext: self.cmd_set_sample_locations_ext, - get_physical_device_multisample_properties_ext: self - .get_physical_device_multisample_properties_ext, + get_physical_device_multisample_properties_ext: + self.get_physical_device_multisample_properties_ext, } } } impl ExtSampleLocationsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtSampleLocationsFn { + ExtSampleLocationsFn { cmd_set_sample_locations_ext: unsafe { + extern "system" fn cmd_set_sample_locations_ext( + _command_buffer: CommandBuffer, + _p_sample_locations_info: *const SampleLocationsInfoEXT, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_set_sample_locations_ext) + ) + } let raw_name = stringify!(vkCmdSetSampleLocationsEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_sample_locations_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_multisample_properties_ext: unsafe { + extern "system" fn get_physical_device_multisample_properties_ext( + _physical_device: PhysicalDevice, + _samples: SampleCountFlags, + _p_multisample_properties: *mut MultisamplePropertiesEXT, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(get_physical_device_multisample_properties_ext) + ) + } let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_multisample_properties_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_set_sample_locations_ext( @@ -35444,17 +37239,11 @@ pub mod extensions { } } impl KhrRelaxedBlockLayoutFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrRelaxedBlockLayoutFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrRelaxedBlockLayoutFn {} } } pub struct KhrGetMemoryRequirements2Fn {} @@ -35466,17 +37255,11 @@ pub mod extensions { } } impl KhrGetMemoryRequirements2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetMemoryRequirements2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrGetMemoryRequirements2Fn {} } } pub struct KhrImageFormatListFn {} @@ -35488,17 +37271,11 @@ pub mod extensions { } } impl KhrImageFormatListFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrImageFormatListFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrImageFormatListFn {} } } #[doc = "Generated from \'VK_KHR_image_format_list\'"] @@ -35514,17 +37291,11 @@ pub mod extensions { } } impl ExtBlendOperationAdvancedFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtBlendOperationAdvancedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtBlendOperationAdvancedFn {} } } #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] @@ -35739,17 +37510,11 @@ pub mod extensions { } } impl NvFragmentCoverageToColorFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvFragmentCoverageToColorFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvFragmentCoverageToColorFn {} } } #[doc = "Generated from \'VK_NV_fragment_coverage_to_color\'"] @@ -35765,17 +37530,11 @@ pub mod extensions { } } impl NvExtension151Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension151Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension151Fn {} } } pub struct NvExtension152Fn {} @@ -35787,17 +37546,11 @@ pub mod extensions { } } impl NvExtension152Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension152Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension152Fn {} } } pub struct NvFramebufferMixedSamplesFn {} @@ -35809,17 +37562,11 @@ pub mod extensions { } } impl NvFramebufferMixedSamplesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvFramebufferMixedSamplesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvFramebufferMixedSamplesFn {} } } #[doc = "Generated from \'VK_NV_framebuffer_mixed_samples\'"] @@ -35836,17 +37583,11 @@ pub mod extensions { } } impl NvFillRectangleFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvFillRectangleFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvFillRectangleFn {} } } #[doc = "Generated from \'VK_NV_fill_rectangle\'"] @@ -35862,17 +37603,11 @@ pub mod extensions { } } impl NvExtension155Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension155Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension155Fn {} } } pub struct ExtPostDepthCoverageFn {} @@ -35884,17 +37619,11 @@ pub mod extensions { } } impl ExtPostDepthCoverageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtPostDepthCoverageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtPostDepthCoverageFn {} } } pub struct KhrSamplerYcbcrConversionFn {} @@ -35906,17 +37635,11 @@ pub mod extensions { } } impl KhrSamplerYcbcrConversionFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSamplerYcbcrConversionFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrSamplerYcbcrConversionFn {} } } pub struct KhrBindMemory2Fn {} @@ -35928,17 +37651,11 @@ pub mod extensions { } } impl KhrBindMemory2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrBindMemory2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrBindMemory2Fn {} } } pub struct ExtExtension159Fn {} @@ -35950,17 +37667,11 @@ pub mod extensions { } } impl ExtExtension159Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension159Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension159Fn {} } } pub struct ExtExtension160Fn {} @@ -35972,17 +37683,11 @@ pub mod extensions { } } impl ExtExtension160Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension160Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension160Fn {} } } pub struct ExtValidationCacheFn { @@ -36024,53 +37729,88 @@ pub mod extensions { } } impl ExtValidationCacheFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtValidationCacheFn { + ExtValidationCacheFn { create_validation_cache_ext: unsafe { + extern "system" fn create_validation_cache_ext( + _device: Device, + _p_create_info: *const ValidationCacheCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_validation_cache: *mut ValidationCacheEXT, + ) -> Result { + panic!("Unable to load {}", stringify!(create_validation_cache_ext)) + } let raw_name = stringify!(vkCreateValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_validation_cache_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_validation_cache_ext: unsafe { + extern "system" fn destroy_validation_cache_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(destroy_validation_cache_ext) + ) + } let raw_name = stringify!(vkDestroyValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_validation_cache_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, merge_validation_caches_ext: unsafe { + extern "system" fn merge_validation_caches_ext( + _device: Device, + _dst_cache: ValidationCacheEXT, + _src_cache_count: u32, + _p_src_caches: *const ValidationCacheEXT, + ) -> Result { + panic!("Unable to load {}", stringify!(merge_validation_caches_ext)) + } let raw_name = stringify!(vkMergeValidationCachesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + merge_validation_caches_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_validation_cache_data_ext: unsafe { + extern "system" fn get_validation_cache_data_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_validation_cache_data_ext) + ) + } let raw_name = stringify!(vkGetValidationCacheDataEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_validation_cache_data_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_validation_cache_ext( @@ -36135,17 +37875,11 @@ pub mod extensions { } } impl ExtDescriptorIndexingFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDescriptorIndexingFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtDescriptorIndexingFn {} } } #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] @@ -36194,17 +37928,11 @@ pub mod extensions { } } impl ExtShaderViewportIndexLayerFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderViewportIndexLayerFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderViewportIndexLayerFn {} } } pub struct NvExtension164Fn {} @@ -36216,17 +37944,11 @@ pub mod extensions { } } impl NvExtension164Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension164Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension164Fn {} } } pub struct NvExtension165Fn {} @@ -36238,17 +37960,11 @@ pub mod extensions { } } impl NvExtension165Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension165Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension165Fn {} } } pub struct NvExtension166Fn {} @@ -36260,17 +37976,11 @@ pub mod extensions { } } impl NvExtension166Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension166Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension166Fn {} } } pub struct NvExtension167Fn {} @@ -36282,17 +37992,11 @@ pub mod extensions { } } impl NvExtension167Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension167Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension167Fn {} } } pub struct NvExtension168Fn {} @@ -36304,17 +38008,11 @@ pub mod extensions { } } impl NvExtension168Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension168Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension168Fn {} } } pub struct KhrMaintenance3Fn {} @@ -36326,17 +38024,11 @@ pub mod extensions { } } impl KhrMaintenance3Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMaintenance3Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMaintenance3Fn {} } } pub struct KhrDrawIndirectCountFn { @@ -36370,35 +38062,56 @@ pub mod extensions { } } impl KhrDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDrawIndirectCountFn { + KhrDrawIndirectCountFn { cmd_draw_indirect_count_khr: unsafe { + extern "system" fn cmd_draw_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_draw_indirect_count_khr)) + } let raw_name = stringify!(vkCmdDrawIndirectCountKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indirect_count_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw_indexed_indirect_count_khr: unsafe { + extern "system" fn cmd_draw_indexed_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!( + "Unable to load {}", + stringify!(cmd_draw_indexed_indirect_count_khr) + ) + } let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indexed_indirect_count_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_draw_indirect_count_khr( @@ -36451,17 +38164,11 @@ pub mod extensions { } } impl QcomExtension171Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension171Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension171Fn {} } } pub struct QcomExtension172Fn {} @@ -36473,17 +38180,11 @@ pub mod extensions { } } impl QcomExtension172Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension172Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension172Fn {} } } pub struct QcomExtension173Fn {} @@ -36495,17 +38196,11 @@ pub mod extensions { } } impl QcomExtension173Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension173Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension173Fn {} } } pub struct QcomExtension174Fn {} @@ -36517,17 +38212,11 @@ pub mod extensions { } } impl QcomExtension174Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension174Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension174Fn {} } } pub struct ExtGlobalPriorityFn {} @@ -36539,17 +38228,11 @@ pub mod extensions { } } impl ExtGlobalPriorityFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtGlobalPriorityFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtGlobalPriorityFn {} } } #[doc = "Generated from \'VK_EXT_global_priority\'"] @@ -36569,17 +38252,11 @@ pub mod extensions { } } impl ExtExtension176Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension176Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension176Fn {} } } pub struct ExtExtension177Fn {} @@ -36591,17 +38268,11 @@ pub mod extensions { } } impl ExtExtension177Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension177Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension177Fn {} } } pub struct ExtExtension178Fn {} @@ -36613,17 +38284,11 @@ pub mod extensions { } } impl ExtExtension178Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension178Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension178Fn {} } } pub struct ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext : extern "system" fn ( device : Device , handle_type : ExternalMemoryHandleTypeFlags , p_host_pointer : *const c_void , p_memory_host_pointer_properties : *mut MemoryHostPointerPropertiesEXT , ) -> Result , } @@ -36637,26 +38302,32 @@ pub mod extensions { } } impl ExtExternalMemoryHostFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExternalMemoryHostFn { + ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext: unsafe { + extern "system" fn get_memory_host_pointer_properties_ext( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _p_host_pointer: *const c_void, + _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result { + panic!( + "Unable to load {}", + stringify!(get_memory_host_pointer_properties_ext) + ) + } let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_host_pointer_properties_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_host_pointer_properties_ext( @@ -36716,26 +38387,30 @@ pub mod extensions { } } impl AmdBufferMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdBufferMarkerFn { + AmdBufferMarkerFn { cmd_write_buffer_marker_amd: unsafe { + extern "system" fn cmd_write_buffer_marker_amd( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _marker: u32, + ) -> c_void { + panic!("Unable to load {}", stringify!(cmd_write_buffer_marker_amd)) + } let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_write_buffer_marker_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_write_buffer_marker_amd( @@ -36764,17 +38439,11 @@ pub mod extensions { } } impl AmdExtension181Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension181Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension181Fn {} } } pub struct AmdExtension182Fn {} @@ -36786,17 +38455,11 @@ pub mod extensions { } } impl AmdExtension182Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension182Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension182Fn {} } } pub struct AmdExtension183Fn {} @@ -36808,17 +38471,11 @@ pub mod extensions { } } impl AmdExtension183Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension183Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension183Fn {} } } pub struct AmdExtension184Fn {} @@ -36830,17 +38487,11 @@ pub mod extensions { } } impl AmdExtension184Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension184Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension184Fn {} } } pub struct AmdExtension185Fn {} @@ -36852,17 +38503,11 @@ pub mod extensions { } } impl AmdExtension185Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension185Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension185Fn {} } } pub struct AmdShaderCorePropertiesFn {} @@ -36874,17 +38519,11 @@ pub mod extensions { } } impl AmdShaderCorePropertiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderCorePropertiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderCorePropertiesFn {} } } #[doc = "Generated from \'VK_AMD_shader_core_properties\'"] @@ -36900,17 +38539,11 @@ pub mod extensions { } } impl AmdExtension187Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension187Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension187Fn {} } } pub struct AmdExtension188Fn {} @@ -36922,17 +38555,11 @@ pub mod extensions { } } impl AmdExtension188Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension188Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension188Fn {} } } pub struct AmdExtension189Fn {} @@ -36944,17 +38571,11 @@ pub mod extensions { } } impl AmdExtension189Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension189Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension189Fn {} } } pub struct AmdExtension190Fn {} @@ -36966,17 +38587,11 @@ pub mod extensions { } } impl AmdExtension190Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension190Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension190Fn {} } } pub struct ExtVertexAttributeDivisorFn {} @@ -36988,17 +38603,11 @@ pub mod extensions { } } impl ExtVertexAttributeDivisorFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtVertexAttributeDivisorFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtVertexAttributeDivisorFn {} } } #[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] @@ -37020,17 +38629,11 @@ pub mod extensions { } } impl GoogleExtension192Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension192Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension192Fn {} } } pub struct GoogleExtension193Fn {} @@ -37042,17 +38645,11 @@ pub mod extensions { } } impl GoogleExtension193Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension193Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension193Fn {} } } pub struct GoogleExtension194Fn {} @@ -37064,17 +38661,11 @@ pub mod extensions { } } impl GoogleExtension194Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension194Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension194Fn {} } } pub struct GoogleExtension195Fn {} @@ -37086,17 +38677,11 @@ pub mod extensions { } } impl GoogleExtension195Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension195Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension195Fn {} } } pub struct GoogleExtension196Fn {} @@ -37108,17 +38693,11 @@ pub mod extensions { } } impl GoogleExtension196Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension196Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension196Fn {} } } pub struct ExtExtension197Fn {} @@ -37130,17 +38709,11 @@ pub mod extensions { } } impl ExtExtension197Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension197Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension197Fn {} } } pub struct ArmExtension198Fn {} @@ -37152,17 +38725,11 @@ pub mod extensions { } } impl ArmExtension198Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ArmExtension198Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ArmExtension198Fn {} } } pub struct NvShaderSubgroupPartitionedFn {} @@ -37174,17 +38741,11 @@ pub mod extensions { } } impl NvShaderSubgroupPartitionedFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvShaderSubgroupPartitionedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvShaderSubgroupPartitionedFn {} } } #[doc = "Generated from \'VK_NV_shader_subgroup_partitioned\'"] @@ -37200,17 +38761,11 @@ pub mod extensions { } } impl KhrExtension200Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension200Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension200Fn {} } } pub struct KhrExtension201Fn {} @@ -37222,17 +38777,11 @@ pub mod extensions { } } impl KhrExtension201Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension201Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension201Fn {} } } pub struct NvExtension202Fn {} @@ -37244,17 +38793,11 @@ pub mod extensions { } } impl NvExtension202Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension202Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension202Fn {} } } pub struct NvExtension203Fn {} @@ -37266,17 +38809,11 @@ pub mod extensions { } } impl NvExtension203Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension203Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension203Fn {} } } pub struct NvExtension204Fn {} @@ -37288,17 +38825,11 @@ pub mod extensions { } } impl NvExtension204Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension204Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension204Fn {} } } pub struct NvExtension205Fn {} @@ -37310,17 +38841,11 @@ pub mod extensions { } } impl NvExtension205Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension205Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension205Fn {} } } pub struct NvExtension206Fn {} @@ -37332,17 +38857,11 @@ pub mod extensions { } } impl NvExtension206Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension206Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension206Fn {} } } pub struct NvExtension207Fn {} @@ -37354,17 +38873,11 @@ pub mod extensions { } } impl NvExtension207Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension207Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension207Fn {} } } pub struct KhrExtension208Fn {} @@ -37376,17 +38889,11 @@ pub mod extensions { } } impl KhrExtension208Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension208Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension208Fn {} } } pub struct KhrExtension209Fn {} @@ -37398,17 +38905,11 @@ pub mod extensions { } } impl KhrExtension209Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension209Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension209Fn {} } } pub struct IntelExtension210Fn {} @@ -37420,17 +38921,11 @@ pub mod extensions { } } impl IntelExtension210Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = IntelExtension210Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + IntelExtension210Fn {} } } pub struct IntelExtension211Fn {} @@ -37442,17 +38937,11 @@ pub mod extensions { } } impl IntelExtension211Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = IntelExtension211Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + IntelExtension211Fn {} } } pub struct KhrExtension212Fn {} @@ -37464,17 +38953,11 @@ pub mod extensions { } } impl KhrExtension212Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension212Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension212Fn {} } } #[doc = "Generated from \'VK_VERSION_1_1\'"] @@ -38046,52 +39529,13 @@ fn display_flags( } Ok(()) } -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -38117,875 +39561,21 @@ impl fmt::Display for CoverageModulationModeNV { } } } -impl fmt::Display for QueryPipelineStatisticFlags { +impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39034,60 +39624,16 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for DebugReportFlagsEXT { +impl fmt::Display for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorSpaceKHR { +impl fmt::Display for DeviceEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), _ => None, }; if let Some(x) = name { @@ -39097,77 +39643,504 @@ impl fmt::Display for ColorSpaceKHR { } } } +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BlendFactor { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), _ => None, }; if let Some(x) = name { @@ -39196,27 +40169,21 @@ impl fmt::Display for CommandBufferUsageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for StencilFaceFlags { +impl fmt::Display for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectEntryTypeNVX { +impl fmt::Display for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), _ => None, }; if let Some(x) = name { @@ -39226,19 +40193,79 @@ impl fmt::Display for ObjectEntryTypeNVX { } } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for SystemAllocationScope { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39256,6 +40283,44 @@ impl fmt::Display for SystemAllocationScope { } } } +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for SamplerYcbcrModelConversion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39273,334 +40338,31 @@ impl fmt::Display for SamplerYcbcrModelConversion { } } } -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { +impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39664,22 +40426,26 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } _ => None, }; if let Some(x) = name { @@ -39689,11 +40455,21 @@ impl fmt::Display for PointClippingBehavior { } } } -impl fmt::Display for FrontFace { +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -39703,65 +40479,12 @@ impl fmt::Display for FrontFace { } } } -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } @@ -39780,26 +40503,11 @@ impl fmt::Display for BlendOverlapEXT { } } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), _ => None, }; if let Some(x) = name { @@ -39809,353 +40517,15 @@ impl fmt::Display for SamplerReductionModeEXT { } } } -impl fmt::Display for StencilOp { +impl fmt::Display for PresentModeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), _ => None, }; if let Some(x) = name { @@ -40605,32 +40975,192 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for ExternalSemaphoreFeatureFlags { +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40680,13 +41210,345 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for ColorComponentFlags { +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), ]; display_flags(f, KNOWN, self.0) } @@ -40705,6 +41567,166 @@ impl fmt::Display for CommandBufferLevel { } } } +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40762,3 +41784,464 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 44e2196..61acd62 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -107,7 +107,7 @@ unsafe fn create_surface( dpy: x11_display as *mut vk::Display, }; let xlib_surface_loader = - XlibSurface::new(entry, instance).expect("Unable to load xlib surface"); + XlibSurface::new(entry, instance); xlib_surface_loader.create_xlib_surface_khr(&x11_create_info, None) } @@ -131,7 +131,7 @@ unsafe fn create_surface( hwnd: hwnd as *const c_void, }; let win32_surface_loader = - Win32Surface::new(entry, instance).expect("Unable to load win32 surface"); + Win32Surface::new(entry, instance); win32_surface_loader.create_win32_surface_khr(&win32_create_info, None) } @@ -314,7 +314,7 @@ impl ExampleBase { p_user_data: ptr::null_mut(), }; let debug_report_loader = - DebugReport::new(&entry, &instance).expect("Unable to load debug report"); + DebugReport::new(&entry, &instance); let debug_call_back = debug_report_loader .create_debug_report_callback_ext(&debug_info, None) .unwrap(); @@ -323,7 +323,7 @@ impl ExampleBase { .enumerate_physical_devices() .expect("Physical device error"); let surface_loader = - Surface::new(&entry, &instance).expect("Unable to load the Surface extension"); + Surface::new(&entry, &instance); let (pdevice, queue_family_index) = pdevices .iter() .map(|pdevice| { @@ -425,7 +425,7 @@ impl ExampleBase { .find(|&mode| mode == vk::PresentModeKHR::MAILBOX) .unwrap_or(vk::PresentModeKHR::FIFO); let swapchain_loader = - Swapchain::new(&instance, &device).expect("Unable to load swapchain"); + Swapchain::new(&instance, &device); let swapchain_create_info = vk::SwapchainCreateInfoKHR { s_type: vk::StructureType::SWAPCHAIN_CREATE_INFO_KHR, p_next: ptr::null(), diff --git a/generator/src/lib.rs b/generator/src/lib.rs index f061e6a..768ad9c 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -687,6 +687,9 @@ pub type CommandMap<'a> = HashMap; fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quote::Tokens { let names: Vec<_> = commands.iter().map(|cmd| cmd.command_ident()).collect(); let names_ref = &names; + let names_ref1 = &names; + let names_ref2 = &names; + let names_ref3 = &names; let raw_names: Vec<_> = commands .iter() .map(|cmd| Ident::from(cmd.name.as_str())) @@ -728,6 +731,17 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo #(#inner_params_iter,)* } }).collect(); + let expanded_params_unused: Vec<_> = params + .iter() + .map(|inner_params| { + let inner_params_iter = inner_params.iter().map(|&(ref param_name, ref param_ty)| { + let unused_name = Ident::from(format!("_{}", param_name).as_str()); + quote!{#unused_name: #param_ty} + }); + quote!{ + #(#inner_params_iter,)* + } + }).collect(); let expanded_params_ref = &expanded_params; let return_types: Vec<_> = commands @@ -753,31 +767,28 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo } } impl #ident { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void { - let mut _err_str = Vec::new(); - let s = #ident { + #ident { #( #names_ref: unsafe { + + extern "system" fn #names_ref1 (#expanded_params_unused) -> #return_types_ref { + panic!("Unable to load {}", stringify!(#names_ref2)) + } let raw_name = stringify!(#raw_names_ref); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null(){ - _err_str.push(raw_name); + #names_ref3 + } + else{ + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, )* - }; - - if _err_str.is_empty() { - Ok(s) } - else{ - Err(_err_str) - } - } #( pub unsafe fn #names_ref(&self, #expanded_params_ref) -> #return_types_ref { From 35d6bdf1445a59fcf807673085b7b052d5549ff5 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 4 Nov 2018 09:26:10 +0100 Subject: [PATCH 111/122] Remove format --- generator/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 768ad9c..78da9ae 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -775,7 +775,7 @@ fn generate_function_pointers(ident: Ident, commands: &[&vkxml::Command]) -> quo #names_ref: unsafe { extern "system" fn #names_ref1 (#expanded_params_unused) -> #return_types_ref { - panic!("Unable to load {}", stringify!(#names_ref2)) + panic!(concat!("Unable to load ", stringify!(#names_ref2))) } let raw_name = stringify!(#raw_names_ref); let cname = ::std::ffi::CString::new(raw_name).unwrap(); From b9c5f560841f99247d73ed44ca12c8405db58f70 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 4 Nov 2018 09:38:39 +0100 Subject: [PATCH 112/122] Remove device error --- ash/src/instance.rs | 39 +++++++-------------------------------- ash/src/lib.rs | 2 +- 2 files changed, 8 insertions(+), 33 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 10d60c2..c86b9a7 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -1,8 +1,6 @@ #![allow(dead_code)] use device::Device; use prelude::*; -use std::error::Error; -use std::fmt; use std::mem; use std::os::raw::c_char; use std::ptr; @@ -11,31 +9,6 @@ use version::{FunctionPointers, V1_0, V1_1}; use vk; use RawPtr; -#[derive(Debug)] -pub enum DeviceError { - LoadError(Vec<&'static str>), - VkError(vk::Result), -} - -impl fmt::Display for DeviceError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "DeviceError::{:?}", self) - } -} - -impl Error for DeviceError { - fn description(&self) -> &str { - "DeviceErrorr" - } - - fn cause(&self) -> Option<&Error> { - if let &DeviceError::VkError(ref err) = self { - return err.cause(); - } - None - } -} - #[derive(Clone)] pub struct Instance { handle: vk::Instance, @@ -87,7 +60,9 @@ impl Instance { pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; - unsafe fn enumerate_physical_device_groups(&self) -> VkResult> { + unsafe fn enumerate_physical_device_groups( + &self, + ) -> VkResult> { let mut group_count = mem::uninitialized(); self.fp_v1_1().enumerate_physical_device_groups( self.handle(), @@ -134,7 +109,7 @@ pub trait InstanceV1_1: InstanceV1_0 { &self, physical_device: vk::PhysicalDevice, format_info: &vk::PhysicalDeviceImageFormatInfo2, - image_format_prop: &mut vk::ImageFormatProperties2 + image_format_prop: &mut vk::ImageFormatProperties2, ) -> VkResult<()> { let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( physical_device, @@ -164,7 +139,7 @@ pub trait InstanceV1_1: InstanceV1_0 { unsafe fn get_physical_device_queue_family_properties2( &self, physical_device: vk::PhysicalDevice, - queue_family_props: &mut [vk::QueueFamilyProperties2] + queue_family_props: &mut [vk::QueueFamilyProperties2], ) { let mut queue_count = queue_family_props.len() as u32; self.fp_v1_1().get_physical_device_queue_family_properties2( @@ -265,7 +240,7 @@ pub trait InstanceV1_0 { physical_device: vk::PhysicalDevice, create_info: &vk::DeviceCreateInfo, allocation_callbacks: Option<&vk::AllocationCallbacks>, - ) -> Result, DeviceError> { + ) -> Result, vk::Result> { let mut device: vk::Device = mem::uninitialized(); let err_code = self.fp_v1_0().create_device( physical_device, @@ -274,7 +249,7 @@ pub trait InstanceV1_0 { &mut device, ); if err_code != vk::Result::SUCCESS { - return Err(DeviceError::VkError(err_code)); + return Err(err_code); } let device_fn = <::Fp as FunctionPointers>::DeviceFp::load( self.fp_v1_0(), diff --git a/ash/src/lib.rs b/ash/src/lib.rs index bb9b464..a3addf6 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -3,7 +3,7 @@ extern crate lazy_static; extern crate shared_library; pub use device::Device; pub use entry::{Entry, InstanceError, LoadingError}; -pub use instance::{DeviceError, Instance}; +pub use instance::Instance; mod device; mod entry; From 1f8941351dd1d535b977d703b276f246d81dd86a Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 4 Nov 2018 09:46:14 +0100 Subject: [PATCH 113/122] Regenerate vk.rs --- ash/src/vk.rs | 4732 ++++++++++++++++++++++++++----------------------- 1 file changed, 2477 insertions(+), 2255 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index fea626e..6844c10 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -267,7 +267,10 @@ impl StaticFn { _instance: Instance, _p_name: *const c_char, ) -> PFN_vkVoidFunction { - panic!("Unable to load {}", stringify!(get_instance_proc_addr)) + panic!(concat!( + "Unable to load ", + stringify!(get_instance_proc_addr) + )) } let raw_name = stringify!(vkGetInstanceProcAddr); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -327,7 +330,7 @@ impl EntryFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_instance: *mut Instance, ) -> Result { - panic!("Unable to load {}", stringify!(create_instance)) + panic!(concat!("Unable to load ", stringify!(create_instance))) } let raw_name = stringify!(vkCreateInstance); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -344,10 +347,10 @@ impl EntryFnV1_0 { _p_property_count: *mut u32, _p_properties: *mut ExtensionProperties, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(enumerate_instance_extension_properties) - ) + )) } let raw_name = stringify!(vkEnumerateInstanceExtensionProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -363,10 +366,10 @@ impl EntryFnV1_0 { _p_property_count: *mut u32, _p_properties: *mut LayerProperties, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(enumerate_instance_layer_properties) - ) + )) } let raw_name = stringify!(vkEnumerateInstanceLayerProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -513,7 +516,7 @@ impl InstanceFnV1_0 { _instance: Instance, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_instance)) + panic!(concat!("Unable to load ", stringify!(destroy_instance))) } let raw_name = stringify!(vkDestroyInstance); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -530,7 +533,10 @@ impl InstanceFnV1_0 { _p_physical_device_count: *mut u32, _p_physical_devices: *mut PhysicalDevice, ) -> Result { - panic!("Unable to load {}", stringify!(enumerate_physical_devices)) + panic!(concat!( + "Unable to load ", + stringify!(enumerate_physical_devices) + )) } let raw_name = stringify!(vkEnumeratePhysicalDevices); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -546,10 +552,10 @@ impl InstanceFnV1_0 { _physical_device: PhysicalDevice, _p_features: *mut PhysicalDeviceFeatures, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_features) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceFeatures); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -566,10 +572,10 @@ impl InstanceFnV1_0 { _format: Format, _p_format_properties: *mut FormatProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_format_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -590,10 +596,10 @@ impl InstanceFnV1_0 { _flags: ImageCreateFlags, _p_image_format_properties: *mut ImageFormatProperties, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_image_format_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -609,10 +615,10 @@ impl InstanceFnV1_0 { _physical_device: PhysicalDevice, _p_properties: *mut PhysicalDeviceProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -629,10 +635,10 @@ impl InstanceFnV1_0 { _p_queue_family_property_count: *mut u32, _p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_queue_family_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -648,10 +654,10 @@ impl InstanceFnV1_0 { _physical_device: PhysicalDevice, _p_memory_properties: *mut PhysicalDeviceMemoryProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_memory_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -667,7 +673,7 @@ impl InstanceFnV1_0 { _device: Device, _p_name: *const c_char, ) -> PFN_vkVoidFunction { - panic!("Unable to load {}", stringify!(get_device_proc_addr)) + panic!(concat!("Unable to load ", stringify!(get_device_proc_addr))) } let raw_name = stringify!(vkGetDeviceProcAddr); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -685,7 +691,7 @@ impl InstanceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_device: *mut Device, ) -> Result { - panic!("Unable to load {}", stringify!(create_device)) + panic!(concat!("Unable to load ", stringify!(create_device))) } let raw_name = stringify!(vkCreateDevice); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -703,10 +709,10 @@ impl InstanceFnV1_0 { _p_property_count: *mut u32, _p_properties: *mut ExtensionProperties, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(enumerate_device_extension_properties) - ) + )) } let raw_name = stringify!(vkEnumerateDeviceExtensionProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -723,10 +729,10 @@ impl InstanceFnV1_0 { _p_property_count: *mut u32, _p_properties: *mut LayerProperties, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(enumerate_device_layer_properties) - ) + )) } let raw_name = stringify!(vkEnumerateDeviceLayerProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -748,10 +754,10 @@ impl InstanceFnV1_0 { _p_property_count: *mut u32, _p_properties: *mut SparseImageFormatProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_sparse_image_format_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1704,7 +1710,7 @@ impl DeviceFnV1_0 { _device: Device, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_device)) + panic!(concat!("Unable to load ", stringify!(destroy_device))) } let raw_name = stringify!(vkDestroyDevice); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1722,7 +1728,7 @@ impl DeviceFnV1_0 { _queue_index: u32, _p_queue: *mut Queue, ) -> c_void { - panic!("Unable to load {}", stringify!(get_device_queue)) + panic!(concat!("Unable to load ", stringify!(get_device_queue))) } let raw_name = stringify!(vkGetDeviceQueue); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1740,7 +1746,7 @@ impl DeviceFnV1_0 { _p_submits: *const SubmitInfo, _fence: Fence, ) -> Result { - panic!("Unable to load {}", stringify!(queue_submit)) + panic!(concat!("Unable to load ", stringify!(queue_submit))) } let raw_name = stringify!(vkQueueSubmit); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1753,7 +1759,7 @@ impl DeviceFnV1_0 { }, queue_wait_idle: unsafe { extern "system" fn queue_wait_idle(_queue: Queue) -> Result { - panic!("Unable to load {}", stringify!(queue_wait_idle)) + panic!(concat!("Unable to load ", stringify!(queue_wait_idle))) } let raw_name = stringify!(vkQueueWaitIdle); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1766,7 +1772,7 @@ impl DeviceFnV1_0 { }, device_wait_idle: unsafe { extern "system" fn device_wait_idle(_device: Device) -> Result { - panic!("Unable to load {}", stringify!(device_wait_idle)) + panic!(concat!("Unable to load ", stringify!(device_wait_idle))) } let raw_name = stringify!(vkDeviceWaitIdle); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1784,7 +1790,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_memory: *mut DeviceMemory, ) -> Result { - panic!("Unable to load {}", stringify!(allocate_memory)) + panic!(concat!("Unable to load ", stringify!(allocate_memory))) } let raw_name = stringify!(vkAllocateMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1801,7 +1807,7 @@ impl DeviceFnV1_0 { _memory: DeviceMemory, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(free_memory)) + panic!(concat!("Unable to load ", stringify!(free_memory))) } let raw_name = stringify!(vkFreeMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1821,7 +1827,7 @@ impl DeviceFnV1_0 { _flags: MemoryMapFlags, _pp_data: *mut *mut c_void, ) -> Result { - panic!("Unable to load {}", stringify!(map_memory)) + panic!(concat!("Unable to load ", stringify!(map_memory))) } let raw_name = stringify!(vkMapMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1834,7 +1840,7 @@ impl DeviceFnV1_0 { }, unmap_memory: unsafe { extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) -> c_void { - panic!("Unable to load {}", stringify!(unmap_memory)) + panic!(concat!("Unable to load ", stringify!(unmap_memory))) } let raw_name = stringify!(vkUnmapMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1851,7 +1857,10 @@ impl DeviceFnV1_0 { _memory_range_count: u32, _p_memory_ranges: *const MappedMemoryRange, ) -> Result { - panic!("Unable to load {}", stringify!(flush_mapped_memory_ranges)) + panic!(concat!( + "Unable to load ", + stringify!(flush_mapped_memory_ranges) + )) } let raw_name = stringify!(vkFlushMappedMemoryRanges); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1868,10 +1877,10 @@ impl DeviceFnV1_0 { _memory_range_count: u32, _p_memory_ranges: *const MappedMemoryRange, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(invalidate_mapped_memory_ranges) - ) + )) } let raw_name = stringify!(vkInvalidateMappedMemoryRanges); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1888,10 +1897,10 @@ impl DeviceFnV1_0 { _memory: DeviceMemory, _p_committed_memory_in_bytes: *mut DeviceSize, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_device_memory_commitment) - ) + )) } let raw_name = stringify!(vkGetDeviceMemoryCommitment); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1909,7 +1918,7 @@ impl DeviceFnV1_0 { _memory: DeviceMemory, _memory_offset: DeviceSize, ) -> Result { - panic!("Unable to load {}", stringify!(bind_buffer_memory)) + panic!(concat!("Unable to load ", stringify!(bind_buffer_memory))) } let raw_name = stringify!(vkBindBufferMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1927,7 +1936,7 @@ impl DeviceFnV1_0 { _memory: DeviceMemory, _memory_offset: DeviceSize, ) -> Result { - panic!("Unable to load {}", stringify!(bind_image_memory)) + panic!(concat!("Unable to load ", stringify!(bind_image_memory))) } let raw_name = stringify!(vkBindImageMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1944,10 +1953,10 @@ impl DeviceFnV1_0 { _buffer: Buffer, _p_memory_requirements: *mut MemoryRequirements, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_buffer_memory_requirements) - ) + )) } let raw_name = stringify!(vkGetBufferMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1964,10 +1973,10 @@ impl DeviceFnV1_0 { _image: Image, _p_memory_requirements: *mut MemoryRequirements, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_image_memory_requirements) - ) + )) } let raw_name = stringify!(vkGetImageMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -1985,10 +1994,10 @@ impl DeviceFnV1_0 { _p_sparse_memory_requirement_count: *mut u32, _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_image_sparse_memory_requirements) - ) + )) } let raw_name = stringify!(vkGetImageSparseMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2006,7 +2015,7 @@ impl DeviceFnV1_0 { _p_bind_info: *const BindSparseInfo, _fence: Fence, ) -> Result { - panic!("Unable to load {}", stringify!(queue_bind_sparse)) + panic!(concat!("Unable to load ", stringify!(queue_bind_sparse))) } let raw_name = stringify!(vkQueueBindSparse); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2024,7 +2033,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_fence: *mut Fence, ) -> Result { - panic!("Unable to load {}", stringify!(create_fence)) + panic!(concat!("Unable to load ", stringify!(create_fence))) } let raw_name = stringify!(vkCreateFence); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2041,7 +2050,7 @@ impl DeviceFnV1_0 { _fence: Fence, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_fence)) + panic!(concat!("Unable to load ", stringify!(destroy_fence))) } let raw_name = stringify!(vkDestroyFence); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2058,7 +2067,7 @@ impl DeviceFnV1_0 { _fence_count: u32, _p_fences: *const Fence, ) -> Result { - panic!("Unable to load {}", stringify!(reset_fences)) + panic!(concat!("Unable to load ", stringify!(reset_fences))) } let raw_name = stringify!(vkResetFences); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2071,7 +2080,7 @@ impl DeviceFnV1_0 { }, get_fence_status: unsafe { extern "system" fn get_fence_status(_device: Device, _fence: Fence) -> Result { - panic!("Unable to load {}", stringify!(get_fence_status)) + panic!(concat!("Unable to load ", stringify!(get_fence_status))) } let raw_name = stringify!(vkGetFenceStatus); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2090,7 +2099,7 @@ impl DeviceFnV1_0 { _wait_all: Bool32, _timeout: u64, ) -> Result { - panic!("Unable to load {}", stringify!(wait_for_fences)) + panic!(concat!("Unable to load ", stringify!(wait_for_fences))) } let raw_name = stringify!(vkWaitForFences); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2108,7 +2117,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_semaphore: *mut Semaphore, ) -> Result { - panic!("Unable to load {}", stringify!(create_semaphore)) + panic!(concat!("Unable to load ", stringify!(create_semaphore))) } let raw_name = stringify!(vkCreateSemaphore); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2125,7 +2134,7 @@ impl DeviceFnV1_0 { _semaphore: Semaphore, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_semaphore)) + panic!(concat!("Unable to load ", stringify!(destroy_semaphore))) } let raw_name = stringify!(vkDestroySemaphore); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2143,7 +2152,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_event: *mut Event, ) -> Result { - panic!("Unable to load {}", stringify!(create_event)) + panic!(concat!("Unable to load ", stringify!(create_event))) } let raw_name = stringify!(vkCreateEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2160,7 +2169,7 @@ impl DeviceFnV1_0 { _event: Event, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_event)) + panic!(concat!("Unable to load ", stringify!(destroy_event))) } let raw_name = stringify!(vkDestroyEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2173,7 +2182,7 @@ impl DeviceFnV1_0 { }, get_event_status: unsafe { extern "system" fn get_event_status(_device: Device, _event: Event) -> Result { - panic!("Unable to load {}", stringify!(get_event_status)) + panic!(concat!("Unable to load ", stringify!(get_event_status))) } let raw_name = stringify!(vkGetEventStatus); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2186,7 +2195,7 @@ impl DeviceFnV1_0 { }, set_event: unsafe { extern "system" fn set_event(_device: Device, _event: Event) -> Result { - panic!("Unable to load {}", stringify!(set_event)) + panic!(concat!("Unable to load ", stringify!(set_event))) } let raw_name = stringify!(vkSetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2199,7 +2208,7 @@ impl DeviceFnV1_0 { }, reset_event: unsafe { extern "system" fn reset_event(_device: Device, _event: Event) -> Result { - panic!("Unable to load {}", stringify!(reset_event)) + panic!(concat!("Unable to load ", stringify!(reset_event))) } let raw_name = stringify!(vkResetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2217,7 +2226,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_query_pool: *mut QueryPool, ) -> Result { - panic!("Unable to load {}", stringify!(create_query_pool)) + panic!(concat!("Unable to load ", stringify!(create_query_pool))) } let raw_name = stringify!(vkCreateQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2234,7 +2243,7 @@ impl DeviceFnV1_0 { _query_pool: QueryPool, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_query_pool)) + panic!(concat!("Unable to load ", stringify!(destroy_query_pool))) } let raw_name = stringify!(vkDestroyQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2256,7 +2265,10 @@ impl DeviceFnV1_0 { _stride: DeviceSize, _flags: QueryResultFlags, ) -> Result { - panic!("Unable to load {}", stringify!(get_query_pool_results)) + panic!(concat!( + "Unable to load ", + stringify!(get_query_pool_results) + )) } let raw_name = stringify!(vkGetQueryPoolResults); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2274,7 +2286,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_buffer: *mut Buffer, ) -> Result { - panic!("Unable to load {}", stringify!(create_buffer)) + panic!(concat!("Unable to load ", stringify!(create_buffer))) } let raw_name = stringify!(vkCreateBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2291,7 +2303,7 @@ impl DeviceFnV1_0 { _buffer: Buffer, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_buffer)) + panic!(concat!("Unable to load ", stringify!(destroy_buffer))) } let raw_name = stringify!(vkDestroyBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2309,7 +2321,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_view: *mut BufferView, ) -> Result { - panic!("Unable to load {}", stringify!(create_buffer_view)) + panic!(concat!("Unable to load ", stringify!(create_buffer_view))) } let raw_name = stringify!(vkCreateBufferView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2326,7 +2338,7 @@ impl DeviceFnV1_0 { _buffer_view: BufferView, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_buffer_view)) + panic!(concat!("Unable to load ", stringify!(destroy_buffer_view))) } let raw_name = stringify!(vkDestroyBufferView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2344,7 +2356,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_image: *mut Image, ) -> Result { - panic!("Unable to load {}", stringify!(create_image)) + panic!(concat!("Unable to load ", stringify!(create_image))) } let raw_name = stringify!(vkCreateImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2361,7 +2373,7 @@ impl DeviceFnV1_0 { _image: Image, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_image)) + panic!(concat!("Unable to load ", stringify!(destroy_image))) } let raw_name = stringify!(vkDestroyImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2379,10 +2391,10 @@ impl DeviceFnV1_0 { _p_subresource: *const ImageSubresource, _p_layout: *mut SubresourceLayout, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_image_subresource_layout) - ) + )) } let raw_name = stringify!(vkGetImageSubresourceLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2400,7 +2412,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_view: *mut ImageView, ) -> Result { - panic!("Unable to load {}", stringify!(create_image_view)) + panic!(concat!("Unable to load ", stringify!(create_image_view))) } let raw_name = stringify!(vkCreateImageView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2417,7 +2429,7 @@ impl DeviceFnV1_0 { _image_view: ImageView, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_image_view)) + panic!(concat!("Unable to load ", stringify!(destroy_image_view))) } let raw_name = stringify!(vkDestroyImageView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2435,7 +2447,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_shader_module: *mut ShaderModule, ) -> Result { - panic!("Unable to load {}", stringify!(create_shader_module)) + panic!(concat!("Unable to load ", stringify!(create_shader_module))) } let raw_name = stringify!(vkCreateShaderModule); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2452,7 +2464,10 @@ impl DeviceFnV1_0 { _shader_module: ShaderModule, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_shader_module)) + panic!(concat!( + "Unable to load ", + stringify!(destroy_shader_module) + )) } let raw_name = stringify!(vkDestroyShaderModule); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2470,7 +2485,10 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_pipeline_cache: *mut PipelineCache, ) -> Result { - panic!("Unable to load {}", stringify!(create_pipeline_cache)) + panic!(concat!( + "Unable to load ", + stringify!(create_pipeline_cache) + )) } let raw_name = stringify!(vkCreatePipelineCache); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2487,7 +2505,10 @@ impl DeviceFnV1_0 { _pipeline_cache: PipelineCache, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_pipeline_cache)) + panic!(concat!( + "Unable to load ", + stringify!(destroy_pipeline_cache) + )) } let raw_name = stringify!(vkDestroyPipelineCache); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2505,7 +2526,10 @@ impl DeviceFnV1_0 { _p_data_size: *mut usize, _p_data: *mut c_void, ) -> Result { - panic!("Unable to load {}", stringify!(get_pipeline_cache_data)) + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_cache_data) + )) } let raw_name = stringify!(vkGetPipelineCacheData); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2523,7 +2547,10 @@ impl DeviceFnV1_0 { _src_cache_count: u32, _p_src_caches: *const PipelineCache, ) -> Result { - panic!("Unable to load {}", stringify!(merge_pipeline_caches)) + panic!(concat!( + "Unable to load ", + stringify!(merge_pipeline_caches) + )) } let raw_name = stringify!(vkMergePipelineCaches); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2543,7 +2570,10 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_pipelines: *mut Pipeline, ) -> Result { - panic!("Unable to load {}", stringify!(create_graphics_pipelines)) + panic!(concat!( + "Unable to load ", + stringify!(create_graphics_pipelines) + )) } let raw_name = stringify!(vkCreateGraphicsPipelines); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2563,7 +2593,10 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_pipelines: *mut Pipeline, ) -> Result { - panic!("Unable to load {}", stringify!(create_compute_pipelines)) + panic!(concat!( + "Unable to load ", + stringify!(create_compute_pipelines) + )) } let raw_name = stringify!(vkCreateComputePipelines); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2580,7 +2613,7 @@ impl DeviceFnV1_0 { _pipeline: Pipeline, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_pipeline)) + panic!(concat!("Unable to load ", stringify!(destroy_pipeline))) } let raw_name = stringify!(vkDestroyPipeline); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2598,7 +2631,10 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_pipeline_layout: *mut PipelineLayout, ) -> Result { - panic!("Unable to load {}", stringify!(create_pipeline_layout)) + panic!(concat!( + "Unable to load ", + stringify!(create_pipeline_layout) + )) } let raw_name = stringify!(vkCreatePipelineLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2615,7 +2651,10 @@ impl DeviceFnV1_0 { _pipeline_layout: PipelineLayout, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_pipeline_layout)) + panic!(concat!( + "Unable to load ", + stringify!(destroy_pipeline_layout) + )) } let raw_name = stringify!(vkDestroyPipelineLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2633,7 +2672,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_sampler: *mut Sampler, ) -> Result { - panic!("Unable to load {}", stringify!(create_sampler)) + panic!(concat!("Unable to load ", stringify!(create_sampler))) } let raw_name = stringify!(vkCreateSampler); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2650,7 +2689,7 @@ impl DeviceFnV1_0 { _sampler: Sampler, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_sampler)) + panic!(concat!("Unable to load ", stringify!(destroy_sampler))) } let raw_name = stringify!(vkDestroySampler); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2668,10 +2707,10 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_set_layout: *mut DescriptorSetLayout, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_descriptor_set_layout) - ) + )) } let raw_name = stringify!(vkCreateDescriptorSetLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2688,10 +2727,10 @@ impl DeviceFnV1_0 { _descriptor_set_layout: DescriptorSetLayout, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(destroy_descriptor_set_layout) - ) + )) } let raw_name = stringify!(vkDestroyDescriptorSetLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2709,7 +2748,10 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_descriptor_pool: *mut DescriptorPool, ) -> Result { - panic!("Unable to load {}", stringify!(create_descriptor_pool)) + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_pool) + )) } let raw_name = stringify!(vkCreateDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2726,7 +2768,10 @@ impl DeviceFnV1_0 { _descriptor_pool: DescriptorPool, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_descriptor_pool)) + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_pool) + )) } let raw_name = stringify!(vkDestroyDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2743,7 +2788,10 @@ impl DeviceFnV1_0 { _descriptor_pool: DescriptorPool, _flags: DescriptorPoolResetFlags, ) -> Result { - panic!("Unable to load {}", stringify!(reset_descriptor_pool)) + panic!(concat!( + "Unable to load ", + stringify!(reset_descriptor_pool) + )) } let raw_name = stringify!(vkResetDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2760,7 +2808,10 @@ impl DeviceFnV1_0 { _p_allocate_info: *const DescriptorSetAllocateInfo, _p_descriptor_sets: *mut DescriptorSet, ) -> Result { - panic!("Unable to load {}", stringify!(allocate_descriptor_sets)) + panic!(concat!( + "Unable to load ", + stringify!(allocate_descriptor_sets) + )) } let raw_name = stringify!(vkAllocateDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2778,7 +2829,7 @@ impl DeviceFnV1_0 { _descriptor_set_count: u32, _p_descriptor_sets: *const DescriptorSet, ) -> Result { - panic!("Unable to load {}", stringify!(free_descriptor_sets)) + panic!(concat!("Unable to load ", stringify!(free_descriptor_sets))) } let raw_name = stringify!(vkFreeDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2797,7 +2848,10 @@ impl DeviceFnV1_0 { _descriptor_copy_count: u32, _p_descriptor_copies: *const CopyDescriptorSet, ) -> c_void { - panic!("Unable to load {}", stringify!(update_descriptor_sets)) + panic!(concat!( + "Unable to load ", + stringify!(update_descriptor_sets) + )) } let raw_name = stringify!(vkUpdateDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2815,7 +2869,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_framebuffer: *mut Framebuffer, ) -> Result { - panic!("Unable to load {}", stringify!(create_framebuffer)) + panic!(concat!("Unable to load ", stringify!(create_framebuffer))) } let raw_name = stringify!(vkCreateFramebuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2832,7 +2886,7 @@ impl DeviceFnV1_0 { _framebuffer: Framebuffer, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_framebuffer)) + panic!(concat!("Unable to load ", stringify!(destroy_framebuffer))) } let raw_name = stringify!(vkDestroyFramebuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2850,7 +2904,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_render_pass: *mut RenderPass, ) -> Result { - panic!("Unable to load {}", stringify!(create_render_pass)) + panic!(concat!("Unable to load ", stringify!(create_render_pass))) } let raw_name = stringify!(vkCreateRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2867,7 +2921,7 @@ impl DeviceFnV1_0 { _render_pass: RenderPass, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_render_pass)) + panic!(concat!("Unable to load ", stringify!(destroy_render_pass))) } let raw_name = stringify!(vkDestroyRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2884,7 +2938,10 @@ impl DeviceFnV1_0 { _render_pass: RenderPass, _p_granularity: *mut Extent2D, ) -> c_void { - panic!("Unable to load {}", stringify!(get_render_area_granularity)) + panic!(concat!( + "Unable to load ", + stringify!(get_render_area_granularity) + )) } let raw_name = stringify!(vkGetRenderAreaGranularity); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2902,7 +2959,7 @@ impl DeviceFnV1_0 { _p_allocator: *const AllocationCallbacks, _p_command_pool: *mut CommandPool, ) -> Result { - panic!("Unable to load {}", stringify!(create_command_pool)) + panic!(concat!("Unable to load ", stringify!(create_command_pool))) } let raw_name = stringify!(vkCreateCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2919,7 +2976,7 @@ impl DeviceFnV1_0 { _command_pool: CommandPool, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_command_pool)) + panic!(concat!("Unable to load ", stringify!(destroy_command_pool))) } let raw_name = stringify!(vkDestroyCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2936,7 +2993,7 @@ impl DeviceFnV1_0 { _command_pool: CommandPool, _flags: CommandPoolResetFlags, ) -> Result { - panic!("Unable to load {}", stringify!(reset_command_pool)) + panic!(concat!("Unable to load ", stringify!(reset_command_pool))) } let raw_name = stringify!(vkResetCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2953,7 +3010,10 @@ impl DeviceFnV1_0 { _p_allocate_info: *const CommandBufferAllocateInfo, _p_command_buffers: *mut CommandBuffer, ) -> Result { - panic!("Unable to load {}", stringify!(allocate_command_buffers)) + panic!(concat!( + "Unable to load ", + stringify!(allocate_command_buffers) + )) } let raw_name = stringify!(vkAllocateCommandBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2971,7 +3031,7 @@ impl DeviceFnV1_0 { _command_buffer_count: u32, _p_command_buffers: *const CommandBuffer, ) -> c_void { - panic!("Unable to load {}", stringify!(free_command_buffers)) + panic!(concat!("Unable to load ", stringify!(free_command_buffers))) } let raw_name = stringify!(vkFreeCommandBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -2987,7 +3047,7 @@ impl DeviceFnV1_0 { _command_buffer: CommandBuffer, _p_begin_info: *const CommandBufferBeginInfo, ) -> Result { - panic!("Unable to load {}", stringify!(begin_command_buffer)) + panic!(concat!("Unable to load ", stringify!(begin_command_buffer))) } let raw_name = stringify!(vkBeginCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3000,7 +3060,7 @@ impl DeviceFnV1_0 { }, end_command_buffer: unsafe { extern "system" fn end_command_buffer(_command_buffer: CommandBuffer) -> Result { - panic!("Unable to load {}", stringify!(end_command_buffer)) + panic!(concat!("Unable to load ", stringify!(end_command_buffer))) } let raw_name = stringify!(vkEndCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3016,7 +3076,7 @@ impl DeviceFnV1_0 { _command_buffer: CommandBuffer, _flags: CommandBufferResetFlags, ) -> Result { - panic!("Unable to load {}", stringify!(reset_command_buffer)) + panic!(concat!("Unable to load ", stringify!(reset_command_buffer))) } let raw_name = stringify!(vkResetCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3033,7 +3093,7 @@ impl DeviceFnV1_0 { _pipeline_bind_point: PipelineBindPoint, _pipeline: Pipeline, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_bind_pipeline)) + panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline))) } let raw_name = stringify!(vkCmdBindPipeline); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3051,7 +3111,7 @@ impl DeviceFnV1_0 { _viewport_count: u32, _p_viewports: *const Viewport, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_viewport)) + panic!(concat!("Unable to load ", stringify!(cmd_set_viewport))) } let raw_name = stringify!(vkCmdSetViewport); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3069,7 +3129,7 @@ impl DeviceFnV1_0 { _scissor_count: u32, _p_scissors: *const Rect2D, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_scissor)) + panic!(concat!("Unable to load ", stringify!(cmd_set_scissor))) } let raw_name = stringify!(vkCmdSetScissor); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3085,7 +3145,7 @@ impl DeviceFnV1_0 { _command_buffer: CommandBuffer, _line_width: c_float, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_line_width)) + panic!(concat!("Unable to load ", stringify!(cmd_set_line_width))) } let raw_name = stringify!(vkCmdSetLineWidth); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3103,7 +3163,7 @@ impl DeviceFnV1_0 { _depth_bias_clamp: c_float, _depth_bias_slope_factor: c_float, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_depth_bias)) + panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias))) } let raw_name = stringify!(vkCmdSetDepthBias); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3119,7 +3179,10 @@ impl DeviceFnV1_0 { _command_buffer: CommandBuffer, _blend_constants: [c_float; 4], ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_blend_constants)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_blend_constants) + )) } let raw_name = stringify!(vkCmdSetBlendConstants); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3136,7 +3199,7 @@ impl DeviceFnV1_0 { _min_depth_bounds: c_float, _max_depth_bounds: c_float, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_depth_bounds)) + panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds))) } let raw_name = stringify!(vkCmdSetDepthBounds); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3153,10 +3216,10 @@ impl DeviceFnV1_0 { _face_mask: StencilFaceFlags, _compare_mask: u32, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_set_stencil_compare_mask) - ) + )) } let raw_name = stringify!(vkCmdSetStencilCompareMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3173,7 +3236,10 @@ impl DeviceFnV1_0 { _face_mask: StencilFaceFlags, _write_mask: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_stencil_write_mask)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_write_mask) + )) } let raw_name = stringify!(vkCmdSetStencilWriteMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3190,7 +3256,10 @@ impl DeviceFnV1_0 { _face_mask: StencilFaceFlags, _reference: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_stencil_reference)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_reference) + )) } let raw_name = stringify!(vkCmdSetStencilReference); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3212,7 +3281,10 @@ impl DeviceFnV1_0 { _dynamic_offset_count: u32, _p_dynamic_offsets: *const u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_bind_descriptor_sets)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_sets) + )) } let raw_name = stringify!(vkCmdBindDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3230,7 +3302,10 @@ impl DeviceFnV1_0 { _offset: DeviceSize, _index_type: IndexType, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_bind_index_buffer)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_index_buffer) + )) } let raw_name = stringify!(vkCmdBindIndexBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3249,7 +3324,10 @@ impl DeviceFnV1_0 { _p_buffers: *const Buffer, _p_offsets: *const DeviceSize, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_bind_vertex_buffers)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers) + )) } let raw_name = stringify!(vkCmdBindVertexBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3268,7 +3346,7 @@ impl DeviceFnV1_0 { _first_vertex: u32, _first_instance: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_draw)) + panic!(concat!("Unable to load ", stringify!(cmd_draw))) } let raw_name = stringify!(vkCmdDraw); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3288,7 +3366,7 @@ impl DeviceFnV1_0 { _vertex_offset: i32, _first_instance: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_draw_indexed)) + panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed))) } let raw_name = stringify!(vkCmdDrawIndexed); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3307,7 +3385,7 @@ impl DeviceFnV1_0 { _draw_count: u32, _stride: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_draw_indirect)) + panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect))) } let raw_name = stringify!(vkCmdDrawIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3326,7 +3404,10 @@ impl DeviceFnV1_0 { _draw_count: u32, _stride: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_draw_indexed_indirect)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect) + )) } let raw_name = stringify!(vkCmdDrawIndexedIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3344,7 +3425,7 @@ impl DeviceFnV1_0 { _group_count_y: u32, _group_count_z: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_dispatch)) + panic!(concat!("Unable to load ", stringify!(cmd_dispatch))) } let raw_name = stringify!(vkCmdDispatch); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3361,7 +3442,10 @@ impl DeviceFnV1_0 { _buffer: Buffer, _offset: DeviceSize, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_dispatch_indirect)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_indirect) + )) } let raw_name = stringify!(vkCmdDispatchIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3380,7 +3464,7 @@ impl DeviceFnV1_0 { _region_count: u32, _p_regions: *const BufferCopy, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_copy_buffer)) + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer))) } let raw_name = stringify!(vkCmdCopyBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3401,7 +3485,7 @@ impl DeviceFnV1_0 { _region_count: u32, _p_regions: *const ImageCopy, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_copy_image)) + panic!(concat!("Unable to load ", stringify!(cmd_copy_image))) } let raw_name = stringify!(vkCmdCopyImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3423,7 +3507,7 @@ impl DeviceFnV1_0 { _p_regions: *const ImageBlit, _filter: Filter, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_blit_image)) + panic!(concat!("Unable to load ", stringify!(cmd_blit_image))) } let raw_name = stringify!(vkCmdBlitImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3443,7 +3527,10 @@ impl DeviceFnV1_0 { _region_count: u32, _p_regions: *const BufferImageCopy, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_copy_buffer_to_image)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image) + )) } let raw_name = stringify!(vkCmdCopyBufferToImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3463,7 +3550,10 @@ impl DeviceFnV1_0 { _region_count: u32, _p_regions: *const BufferImageCopy, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_copy_image_to_buffer)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer) + )) } let raw_name = stringify!(vkCmdCopyImageToBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3482,7 +3572,7 @@ impl DeviceFnV1_0 { _data_size: DeviceSize, _p_data: *const c_void, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_update_buffer)) + panic!(concat!("Unable to load ", stringify!(cmd_update_buffer))) } let raw_name = stringify!(vkCmdUpdateBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3501,7 +3591,7 @@ impl DeviceFnV1_0 { _size: DeviceSize, _data: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_fill_buffer)) + panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer))) } let raw_name = stringify!(vkCmdFillBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3521,7 +3611,10 @@ impl DeviceFnV1_0 { _range_count: u32, _p_ranges: *const ImageSubresourceRange, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_clear_color_image)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_color_image) + )) } let raw_name = stringify!(vkCmdClearColorImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3541,10 +3634,10 @@ impl DeviceFnV1_0 { _range_count: u32, _p_ranges: *const ImageSubresourceRange, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_clear_depth_stencil_image) - ) + )) } let raw_name = stringify!(vkCmdClearDepthStencilImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3563,7 +3656,10 @@ impl DeviceFnV1_0 { _rect_count: u32, _p_rects: *const ClearRect, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_clear_attachments)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_attachments) + )) } let raw_name = stringify!(vkCmdClearAttachments); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3584,7 +3680,7 @@ impl DeviceFnV1_0 { _region_count: u32, _p_regions: *const ImageResolve, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_resolve_image)) + panic!(concat!("Unable to load ", stringify!(cmd_resolve_image))) } let raw_name = stringify!(vkCmdResolveImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3601,7 +3697,7 @@ impl DeviceFnV1_0 { _event: Event, _stage_mask: PipelineStageFlags, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_event)) + panic!(concat!("Unable to load ", stringify!(cmd_set_event))) } let raw_name = stringify!(vkCmdSetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3618,7 +3714,7 @@ impl DeviceFnV1_0 { _event: Event, _stage_mask: PipelineStageFlags, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_reset_event)) + panic!(concat!("Unable to load ", stringify!(cmd_reset_event))) } let raw_name = stringify!(vkCmdResetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3643,7 +3739,7 @@ impl DeviceFnV1_0 { _image_memory_barrier_count: u32, _p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_wait_events)) + panic!(concat!("Unable to load ", stringify!(cmd_wait_events))) } let raw_name = stringify!(vkCmdWaitEvents); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3667,7 +3763,7 @@ impl DeviceFnV1_0 { _image_memory_barrier_count: u32, _p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_pipeline_barrier)) + panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier))) } let raw_name = stringify!(vkCmdPipelineBarrier); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3685,7 +3781,7 @@ impl DeviceFnV1_0 { _query: u32, _flags: QueryControlFlags, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_begin_query)) + panic!(concat!("Unable to load ", stringify!(cmd_begin_query))) } let raw_name = stringify!(vkCmdBeginQuery); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3702,7 +3798,7 @@ impl DeviceFnV1_0 { _query_pool: QueryPool, _query: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_end_query)) + panic!(concat!("Unable to load ", stringify!(cmd_end_query))) } let raw_name = stringify!(vkCmdEndQuery); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3720,7 +3816,7 @@ impl DeviceFnV1_0 { _first_query: u32, _query_count: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_reset_query_pool)) + panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool))) } let raw_name = stringify!(vkCmdResetQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3738,7 +3834,7 @@ impl DeviceFnV1_0 { _query_pool: QueryPool, _query: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_write_timestamp)) + panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp))) } let raw_name = stringify!(vkCmdWriteTimestamp); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3760,7 +3856,10 @@ impl DeviceFnV1_0 { _stride: DeviceSize, _flags: QueryResultFlags, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_copy_query_pool_results)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_query_pool_results) + )) } let raw_name = stringify!(vkCmdCopyQueryPoolResults); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3780,7 +3879,7 @@ impl DeviceFnV1_0 { _size: u32, _p_values: *const c_void, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_push_constants)) + panic!(concat!("Unable to load ", stringify!(cmd_push_constants))) } let raw_name = stringify!(vkCmdPushConstants); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3797,7 +3896,10 @@ impl DeviceFnV1_0 { _p_render_pass_begin: *const RenderPassBeginInfo, _contents: SubpassContents, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_begin_render_pass)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_render_pass) + )) } let raw_name = stringify!(vkCmdBeginRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3813,7 +3915,7 @@ impl DeviceFnV1_0 { _command_buffer: CommandBuffer, _contents: SubpassContents, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_next_subpass)) + panic!(concat!("Unable to load ", stringify!(cmd_next_subpass))) } let raw_name = stringify!(vkCmdNextSubpass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3826,7 +3928,7 @@ impl DeviceFnV1_0 { }, cmd_end_render_pass: unsafe { extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) -> c_void { - panic!("Unable to load {}", stringify!(cmd_end_render_pass)) + panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass))) } let raw_name = stringify!(vkCmdEndRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -3843,7 +3945,7 @@ impl DeviceFnV1_0 { _command_buffer_count: u32, _p_command_buffers: *const CommandBuffer, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_execute_commands)) + panic!(concat!("Unable to load ", stringify!(cmd_execute_commands))) } let raw_name = stringify!(vkCmdExecuteCommands); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5087,7 +5189,10 @@ impl EntryFnV1_1 { EntryFnV1_1 { enumerate_instance_version: unsafe { extern "system" fn enumerate_instance_version(_p_api_version: *mut u32) -> Result { - panic!("Unable to load {}", stringify!(enumerate_instance_version)) + panic!(concat!( + "Unable to load ", + stringify!(enumerate_instance_version) + )) } let raw_name = stringify!(vkEnumerateInstanceVersion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5206,10 +5311,10 @@ impl InstanceFnV1_1 { _p_physical_device_group_count: *mut u32, _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(enumerate_physical_device_groups) - ) + )) } let raw_name = stringify!(vkEnumeratePhysicalDeviceGroups); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5225,10 +5330,10 @@ impl InstanceFnV1_1 { _physical_device: PhysicalDevice, _p_features: *mut PhysicalDeviceFeatures2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_features2) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceFeatures2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5244,10 +5349,10 @@ impl InstanceFnV1_1 { _physical_device: PhysicalDevice, _p_properties: *mut PhysicalDeviceProperties2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_properties2) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5264,10 +5369,10 @@ impl InstanceFnV1_1 { _format: Format, _p_format_properties: *mut FormatProperties2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_format_properties2) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5284,10 +5389,10 @@ impl InstanceFnV1_1 { _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, _p_image_format_properties: *mut ImageFormatProperties2, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_image_format_properties2) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5304,10 +5409,10 @@ impl InstanceFnV1_1 { _p_queue_family_property_count: *mut u32, _p_queue_family_properties: *mut QueueFamilyProperties2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_queue_family_properties2) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5323,10 +5428,10 @@ impl InstanceFnV1_1 { _physical_device: PhysicalDevice, _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_memory_properties2) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5344,10 +5449,10 @@ impl InstanceFnV1_1 { _p_property_count: *mut u32, _p_properties: *mut SparseImageFormatProperties2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_sparse_image_format_properties2) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5364,10 +5469,10 @@ impl InstanceFnV1_1 { _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, _p_external_buffer_properties: *mut ExternalBufferProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_external_buffer_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceExternalBufferProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5384,10 +5489,10 @@ impl InstanceFnV1_1 { _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, _p_external_fence_properties: *mut ExternalFenceProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_external_fence_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceExternalFenceProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5404,10 +5509,10 @@ impl InstanceFnV1_1 { _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_external_semaphore_properties) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceExternalSemaphoreProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5668,7 +5773,7 @@ impl DeviceFnV1_1 { _bind_info_count: u32, _p_bind_infos: *const BindBufferMemoryInfo, ) -> Result { - panic!("Unable to load {}", stringify!(bind_buffer_memory2)) + panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2))) } let raw_name = stringify!(vkBindBufferMemory2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5685,7 +5790,7 @@ impl DeviceFnV1_1 { _bind_info_count: u32, _p_bind_infos: *const BindImageMemoryInfo, ) -> Result { - panic!("Unable to load {}", stringify!(bind_image_memory2)) + panic!(concat!("Unable to load ", stringify!(bind_image_memory2))) } let raw_name = stringify!(vkBindImageMemory2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5704,10 +5809,10 @@ impl DeviceFnV1_1 { _remote_device_index: u32, _p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_device_group_peer_memory_features) - ) + )) } let raw_name = stringify!(vkGetDeviceGroupPeerMemoryFeatures); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5723,7 +5828,7 @@ impl DeviceFnV1_1 { _command_buffer: CommandBuffer, _device_mask: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_set_device_mask)) + panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask))) } let raw_name = stringify!(vkCmdSetDeviceMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5744,7 +5849,7 @@ impl DeviceFnV1_1 { _group_count_y: u32, _group_count_z: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_dispatch_base)) + panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base))) } let raw_name = stringify!(vkCmdDispatchBase); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5761,10 +5866,10 @@ impl DeviceFnV1_1 { _p_info: *const ImageMemoryRequirementsInfo2, _p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_image_memory_requirements2) - ) + )) } let raw_name = stringify!(vkGetImageMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5781,10 +5886,10 @@ impl DeviceFnV1_1 { _p_info: *const BufferMemoryRequirementsInfo2, _p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_buffer_memory_requirements2) - ) + )) } let raw_name = stringify!(vkGetBufferMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5802,10 +5907,10 @@ impl DeviceFnV1_1 { _p_sparse_memory_requirement_count: *mut u32, _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_image_sparse_memory_requirements2) - ) + )) } let raw_name = stringify!(vkGetImageSparseMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5822,7 +5927,7 @@ impl DeviceFnV1_1 { _command_pool: CommandPool, _flags: CommandPoolTrimFlags, ) -> c_void { - panic!("Unable to load {}", stringify!(trim_command_pool)) + panic!(concat!("Unable to load ", stringify!(trim_command_pool))) } let raw_name = stringify!(vkTrimCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5839,7 +5944,7 @@ impl DeviceFnV1_1 { _p_queue_info: *const DeviceQueueInfo2, _p_queue: *mut Queue, ) -> c_void { - panic!("Unable to load {}", stringify!(get_device_queue2)) + panic!(concat!("Unable to load ", stringify!(get_device_queue2))) } let raw_name = stringify!(vkGetDeviceQueue2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5857,10 +5962,10 @@ impl DeviceFnV1_1 { _p_allocator: *const AllocationCallbacks, _p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_sampler_ycbcr_conversion) - ) + )) } let raw_name = stringify!(vkCreateSamplerYcbcrConversion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5877,10 +5982,10 @@ impl DeviceFnV1_1 { _ycbcr_conversion: SamplerYcbcrConversion, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(destroy_sampler_ycbcr_conversion) - ) + )) } let raw_name = stringify!(vkDestroySamplerYcbcrConversion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5898,10 +6003,10 @@ impl DeviceFnV1_1 { _p_allocator: *const AllocationCallbacks, _p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_descriptor_update_template) - ) + )) } let raw_name = stringify!(vkCreateDescriptorUpdateTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5918,10 +6023,10 @@ impl DeviceFnV1_1 { _descriptor_update_template: DescriptorUpdateTemplate, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(destroy_descriptor_update_template) - ) + )) } let raw_name = stringify!(vkDestroyDescriptorUpdateTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5939,10 +6044,10 @@ impl DeviceFnV1_1 { _descriptor_update_template: DescriptorUpdateTemplate, _p_data: *const c_void, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(update_descriptor_set_with_template) - ) + )) } let raw_name = stringify!(vkUpdateDescriptorSetWithTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -5959,10 +6064,10 @@ impl DeviceFnV1_1 { _p_create_info: *const DescriptorSetLayoutCreateInfo, _p_support: *mut DescriptorSetLayoutSupport, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_descriptor_set_layout_support) - ) + )) } let raw_name = stringify!(vkGetDescriptorSetLayoutSupport); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30068,7 +30173,7 @@ pub mod extensions { _surface: SurfaceKHR, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_surface_khr)) + panic!(concat!("Unable to load ", stringify!(destroy_surface_khr))) } let raw_name = stringify!(vkDestroySurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30086,10 +30191,10 @@ pub mod extensions { _surface: SurfaceKHR, _p_supported: *mut Bool32, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_surface_support_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30106,10 +30211,10 @@ pub mod extensions { _surface: SurfaceKHR, _p_surface_capabilities: *mut SurfaceCapabilitiesKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_surface_capabilities_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30127,10 +30232,10 @@ pub mod extensions { _p_surface_format_count: *mut u32, _p_surface_formats: *mut SurfaceFormatKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_surface_formats_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30148,10 +30253,10 @@ pub mod extensions { _p_present_mode_count: *mut u32, _p_present_modes: *mut PresentModeKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_surface_present_modes_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30273,7 +30378,7 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_swapchain: *mut SwapchainKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_swapchain_khr)) + panic!(concat!("Unable to load ", stringify!(create_swapchain_khr))) } let raw_name = stringify!(vkCreateSwapchainKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30290,7 +30395,10 @@ pub mod extensions { _swapchain: SwapchainKHR, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_swapchain_khr)) + panic!(concat!( + "Unable to load ", + stringify!(destroy_swapchain_khr) + )) } let raw_name = stringify!(vkDestroySwapchainKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30308,7 +30416,10 @@ pub mod extensions { _p_swapchain_image_count: *mut u32, _p_swapchain_images: *mut Image, ) -> Result { - panic!("Unable to load {}", stringify!(get_swapchain_images_khr)) + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_images_khr) + )) } let raw_name = stringify!(vkGetSwapchainImagesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30328,7 +30439,10 @@ pub mod extensions { _fence: Fence, _p_image_index: *mut u32, ) -> Result { - panic!("Unable to load {}", stringify!(acquire_next_image_khr)) + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image_khr) + )) } let raw_name = stringify!(vkAcquireNextImageKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30344,7 +30458,7 @@ pub mod extensions { _queue: Queue, _p_present_info: *const PresentInfoKHR, ) -> Result { - panic!("Unable to load {}", stringify!(queue_present_khr)) + panic!(concat!("Unable to load ", stringify!(queue_present_khr))) } let raw_name = stringify!(vkQueuePresentKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30356,10 +30470,10 @@ pub mod extensions { } }, get_device_group_present_capabilities_khr: unsafe {extern "system" fn get_device_group_present_capabilities_khr ( _device : Device , _p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result{ - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_device_group_present_capabilities_khr) - ) + )) } let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30376,10 +30490,10 @@ pub mod extensions { _surface: SurfaceKHR, _p_modes: *mut DeviceGroupPresentModeFlagsKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_device_group_surface_present_modes_khr) - ) + )) } let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30397,10 +30511,10 @@ pub mod extensions { _p_rect_count: *mut u32, _p_rects: *mut Rect2D, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_present_rectangles_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30417,7 +30531,10 @@ pub mod extensions { _p_acquire_info: *const AcquireNextImageInfoKHR, _p_image_index: *mut u32, ) -> Result { - panic!("Unable to load {}", stringify!(acquire_next_image2_khr)) + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) } let raw_name = stringify!(vkAcquireNextImage2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30662,10 +30779,10 @@ pub mod extensions { _p_property_count: *mut u32, _p_properties: *mut DisplayPropertiesKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_display_properties_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30682,10 +30799,10 @@ pub mod extensions { _p_property_count: *mut u32, _p_properties: *mut DisplayPlanePropertiesKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_display_plane_properties_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30703,10 +30820,10 @@ pub mod extensions { _p_display_count: *mut u32, _p_displays: *mut DisplayKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_display_plane_supported_displays_khr) - ) + )) } let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30724,10 +30841,10 @@ pub mod extensions { _p_property_count: *mut u32, _p_properties: *mut DisplayModePropertiesKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_display_mode_properties_khr) - ) + )) } let raw_name = stringify!(vkGetDisplayModePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30746,7 +30863,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_mode: *mut DisplayModeKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_display_mode_khr)) + panic!(concat!( + "Unable to load ", + stringify!(create_display_mode_khr) + )) } let raw_name = stringify!(vkCreateDisplayModeKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30764,10 +30884,10 @@ pub mod extensions { _plane_index: u32, _p_capabilities: *mut DisplayPlaneCapabilitiesKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_display_plane_capabilities_khr) - ) + )) } let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30785,10 +30905,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_display_plane_surface_khr) - ) + )) } let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -30942,10 +31062,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_swapchains: *mut SwapchainKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_shared_swapchains_khr) - ) + )) } let raw_name = stringify!(vkCreateSharedSwapchainsKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31022,7 +31142,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_xlib_surface_khr)) + panic!(concat!( + "Unable to load ", + stringify!(create_xlib_surface_khr) + )) } let raw_name = stringify!(vkCreateXlibSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31040,10 +31163,10 @@ pub mod extensions { _dpy: *mut Display, _visual_id: VisualID, ) -> Bool32 { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_xlib_presentation_support_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31123,7 +31246,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_xcb_surface_khr)) + panic!(concat!( + "Unable to load ", + stringify!(create_xcb_surface_khr) + )) } let raw_name = stringify!(vkCreateXcbSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31141,10 +31267,10 @@ pub mod extensions { _connection: *mut xcb_connection_t, _visual_id: xcb_visualid_t, ) -> Bool32 { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_xcb_presentation_support_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31224,7 +31350,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_wayland_surface_khr)) + panic!(concat!( + "Unable to load ", + stringify!(create_wayland_surface_khr) + )) } let raw_name = stringify!(vkCreateWaylandSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31241,10 +31370,10 @@ pub mod extensions { _queue_family_index: u32, _display: *mut wl_display, ) -> Bool32 { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_wayland_presentation_support_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31321,7 +31450,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_mir_surface_khr)) + panic!(concat!( + "Unable to load ", + stringify!(create_mir_surface_khr) + )) } let raw_name = stringify!(vkCreateMirSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31338,10 +31470,10 @@ pub mod extensions { _queue_family_index: u32, _connection: *mut MirConnection, ) -> Bool32 { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_mir_presentation_support_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31411,7 +31543,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_android_surface_khr)) + panic!(concat!( + "Unable to load ", + stringify!(create_android_surface_khr) + )) } let raw_name = stringify!(vkCreateAndroidSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31473,7 +31608,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_win32_surface_khr)) + panic!(concat!( + "Unable to load ", + stringify!(create_win32_surface_khr) + )) } let raw_name = stringify!(vkCreateWin32SurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31489,10 +31627,10 @@ pub mod extensions { _physical_device: PhysicalDevice, _queue_family_index: u32, ) -> Bool32 { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_win32_presentation_support_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31575,10 +31713,10 @@ pub mod extensions { _image_usage: ImageUsageFlags, _gralloc_usage: *mut c_int, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_swapchain_gralloc_usage_android) - ) + )) } let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31597,7 +31735,10 @@ pub mod extensions { _semaphore: Semaphore, _fence: Fence, ) -> Result { - panic!("Unable to load {}", stringify!(acquire_image_android)) + panic!(concat!( + "Unable to load ", + stringify!(acquire_image_android) + )) } let raw_name = stringify!(vkAcquireImageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31616,10 +31757,10 @@ pub mod extensions { _image: Image, _p_native_fence_fd: *mut c_int, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(queue_signal_release_image_android) - ) + )) } let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31721,10 +31862,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_callback: *mut DebugReportCallbackEXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_debug_report_callback_ext) - ) + )) } let raw_name = stringify!(vkCreateDebugReportCallbackEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31741,10 +31882,10 @@ pub mod extensions { _callback: DebugReportCallbackEXT, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(destroy_debug_report_callback_ext) - ) + )) } let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -31766,7 +31907,10 @@ pub mod extensions { _p_layer_prefix: *const c_char, _p_message: *const c_char, ) -> c_void { - panic!("Unable to load {}", stringify!(debug_report_message_ext)) + panic!(concat!( + "Unable to load ", + stringify!(debug_report_message_ext) + )) } let raw_name = stringify!(vkDebugReportMessageEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32064,10 +32208,10 @@ pub mod extensions { _device: Device, _p_tag_info: *const DebugMarkerObjectTagInfoEXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(debug_marker_set_object_tag_ext) - ) + )) } let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32083,10 +32227,10 @@ pub mod extensions { _device: Device, _p_name_info: *const DebugMarkerObjectNameInfoEXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(debug_marker_set_object_name_ext) - ) + )) } let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32102,7 +32246,10 @@ pub mod extensions { _command_buffer: CommandBuffer, _p_marker_info: *const DebugMarkerMarkerInfoEXT, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_debug_marker_begin_ext)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_begin_ext) + )) } let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32117,7 +32264,10 @@ pub mod extensions { extern "system" fn cmd_debug_marker_end_ext( _command_buffer: CommandBuffer, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_debug_marker_end_ext)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_end_ext) + )) } let raw_name = stringify!(vkCmdDebugMarkerEndEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32133,7 +32283,10 @@ pub mod extensions { _command_buffer: CommandBuffer, _p_marker_info: *const DebugMarkerMarkerInfoEXT, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_debug_marker_insert_ext)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_insert_ext) + )) } let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32408,7 +32561,10 @@ pub mod extensions { _max_draw_count: u32, _stride: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_draw_indirect_count_amd)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_amd) + )) } let raw_name = stringify!(vkCmdDrawIndirectCountAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32429,10 +32585,10 @@ pub mod extensions { _max_draw_count: u32, _stride: u32, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_draw_indexed_indirect_count_amd) - ) + )) } let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32652,7 +32808,7 @@ pub mod extensions { _p_info_size: *mut usize, _p_info: *mut c_void, ) -> Result { - panic!("Unable to load {}", stringify!(get_shader_info_amd)) + panic!(concat!("Unable to load ", stringify!(get_shader_info_amd))) } let raw_name = stringify!(vkGetShaderInfoAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -32936,10 +33092,10 @@ pub mod extensions { _external_handle_type: ExternalMemoryHandleTypeFlagsNV, _p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_external_image_format_properties_nv) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33030,7 +33186,10 @@ pub mod extensions { _handle_type: ExternalMemoryHandleTypeFlagsNV, _p_handle: *mut HANDLE, ) -> Result { - panic!("Unable to load {}", stringify!(get_memory_win32_handle_nv)) + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_nv) + )) } let raw_name = stringify!(vkGetMemoryWin32HandleNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33120,10 +33279,10 @@ pub mod extensions { { KhrDeviceGroupFn { get_device_group_present_capabilities_khr: unsafe {extern "system" fn get_device_group_present_capabilities_khr ( _device : Device , _p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result{ - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_device_group_present_capabilities_khr) - ) + )) } let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33140,10 +33299,10 @@ pub mod extensions { _surface: SurfaceKHR, _p_modes: *mut DeviceGroupPresentModeFlagsKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_device_group_surface_present_modes_khr) - ) + )) } let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33161,10 +33320,10 @@ pub mod extensions { _p_rect_count: *mut u32, _p_rects: *mut Rect2D, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_present_rectangles_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33181,7 +33340,10 @@ pub mod extensions { _p_acquire_info: *const AcquireNextImageInfoKHR, _p_image_index: *mut u32, ) -> Result { - panic!("Unable to load {}", stringify!(acquire_next_image2_khr)) + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) } let raw_name = stringify!(vkAcquireNextImage2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33285,7 +33447,7 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_vi_surface_nn)) + panic!(concat!("Unable to load ", stringify!(create_vi_surface_nn))) } let raw_name = stringify!(vkCreateViSurfaceNN); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33495,7 +33657,10 @@ pub mod extensions { _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, _p_handle: *mut HANDLE, ) -> Result { - panic!("Unable to load {}", stringify!(get_memory_win32_handle_khr)) + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_khr) + )) } let raw_name = stringify!(vkGetMemoryWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33513,10 +33678,10 @@ pub mod extensions { _handle: HANDLE, _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_memory_win32_handle_properties_khr) - ) + )) } let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33604,7 +33769,7 @@ pub mod extensions { _p_get_fd_info: *const MemoryGetFdInfoKHR, _p_fd: *mut c_int, ) -> Result { - panic!("Unable to load {}", stringify!(get_memory_fd_khr)) + panic!(concat!("Unable to load ", stringify!(get_memory_fd_khr))) } let raw_name = stringify!(vkGetMemoryFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33622,10 +33787,10 @@ pub mod extensions { _fd: c_int, _p_memory_fd_properties: *mut MemoryFdPropertiesKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_memory_fd_properties_khr) - ) + )) } let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33738,10 +33903,10 @@ pub mod extensions { { KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr: unsafe {extern "system" fn import_semaphore_win32_handle_khr ( _device : Device , _p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result{ - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(import_semaphore_win32_handle_khr) - ) + )) } let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33758,10 +33923,10 @@ pub mod extensions { _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, _p_handle: *mut HANDLE, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_semaphore_win32_handle_khr) - ) + )) } let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33839,7 +34004,10 @@ pub mod extensions { _device: Device, _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, ) -> Result { - panic!("Unable to load {}", stringify!(import_semaphore_fd_khr)) + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_fd_khr) + )) } let raw_name = stringify!(vkImportSemaphoreFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33856,7 +34024,7 @@ pub mod extensions { _p_get_fd_info: *const SemaphoreGetFdInfoKHR, _p_fd: *mut c_int, ) -> Result { - panic!("Unable to load {}", stringify!(get_semaphore_fd_khr)) + panic!(concat!("Unable to load ", stringify!(get_semaphore_fd_khr))) } let raw_name = stringify!(vkGetSemaphoreFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33938,7 +34106,10 @@ pub mod extensions { _descriptor_write_count: u32, _p_descriptor_writes: *const WriteDescriptorSet, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_push_descriptor_set_khr)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_khr) + )) } let raw_name = stringify!(vkCmdPushDescriptorSetKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -33957,10 +34128,10 @@ pub mod extensions { _set: u32, _p_data: *const c_void, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_push_descriptor_set_with_template_khr) - ) + )) } let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34118,10 +34289,10 @@ pub mod extensions { _set: u32, _p_data: *const c_void, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_push_descriptor_set_with_template_khr) - ) + )) } let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34237,7 +34408,10 @@ pub mod extensions { _command_buffer: CommandBuffer, _p_process_commands_info: *const CmdProcessCommandsInfoNVX, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_process_commands_nvx)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_process_commands_nvx) + )) } let raw_name = stringify!(vkCmdProcessCommandsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34253,10 +34427,10 @@ pub mod extensions { _command_buffer: CommandBuffer, _p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_reserve_space_for_commands_nvx) - ) + )) } let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34274,10 +34448,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_indirect_commands_layout_nvx) - ) + )) } let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34294,10 +34468,10 @@ pub mod extensions { _indirect_commands_layout: IndirectCommandsLayoutNVX, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(destroy_indirect_commands_layout_nvx) - ) + )) } let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34315,7 +34489,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_object_table: *mut ObjectTableNVX, ) -> Result { - panic!("Unable to load {}", stringify!(create_object_table_nvx)) + panic!(concat!( + "Unable to load ", + stringify!(create_object_table_nvx) + )) } let raw_name = stringify!(vkCreateObjectTableNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34332,7 +34509,10 @@ pub mod extensions { _object_table: ObjectTableNVX, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!("Unable to load {}", stringify!(destroy_object_table_nvx)) + panic!(concat!( + "Unable to load ", + stringify!(destroy_object_table_nvx) + )) } let raw_name = stringify!(vkDestroyObjectTableNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34351,7 +34531,7 @@ pub mod extensions { _pp_object_table_entries: *const *const ObjectTableEntryNVX, _p_object_indices: *const u32, ) -> Result { - panic!("Unable to load {}", stringify!(register_objects_nvx)) + panic!(concat!("Unable to load ", stringify!(register_objects_nvx))) } let raw_name = stringify!(vkRegisterObjectsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34370,7 +34550,10 @@ pub mod extensions { _p_object_entry_types: *const ObjectEntryTypeNVX, _p_object_indices: *const u32, ) -> Result { - panic!("Unable to load {}", stringify!(unregister_objects_nvx)) + panic!(concat!( + "Unable to load ", + stringify!(unregister_objects_nvx) + )) } let raw_name = stringify!(vkUnregisterObjectsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34387,10 +34570,10 @@ pub mod extensions { _p_features: *mut DeviceGeneratedCommandsFeaturesNVX, _p_limits: *mut DeviceGeneratedCommandsLimitsNVX, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_generated_commands_properties_nvx) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34580,10 +34763,10 @@ pub mod extensions { _viewport_count: u32, _p_viewport_w_scalings: *const ViewportWScalingNV, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_set_viewport_w_scaling_nv) - ) + )) } let raw_name = stringify!(vkCmdSetViewportWScalingNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34644,7 +34827,7 @@ pub mod extensions { _physical_device: PhysicalDevice, _display: DisplayKHR, ) -> Result { - panic!("Unable to load {}", stringify!(release_display_ext)) + panic!(concat!("Unable to load ", stringify!(release_display_ext))) } let raw_name = stringify!(vkReleaseDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34700,7 +34883,10 @@ pub mod extensions { _dpy: *mut Display, _display: DisplayKHR, ) -> Result { - panic!("Unable to load {}", stringify!(acquire_xlib_display_ext)) + panic!(concat!( + "Unable to load ", + stringify!(acquire_xlib_display_ext) + )) } let raw_name = stringify!(vkAcquireXlibDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34718,10 +34904,10 @@ pub mod extensions { _rr_output: RROutput, _p_display: *mut DisplayKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_rand_r_output_display_ext) - ) + )) } let raw_name = stringify!(vkGetRandROutputDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34782,10 +34968,10 @@ pub mod extensions { _surface: SurfaceKHR, _p_surface_capabilities: *mut SurfaceCapabilities2EXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_surface_capabilities2_ext) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34868,7 +35054,10 @@ pub mod extensions { _display: DisplayKHR, _p_display_power_info: *const DisplayPowerInfoEXT, ) -> Result { - panic!("Unable to load {}", stringify!(display_power_control_ext)) + panic!(concat!( + "Unable to load ", + stringify!(display_power_control_ext) + )) } let raw_name = stringify!(vkDisplayPowerControlEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34886,7 +35075,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_fence: *mut Fence, ) -> Result { - panic!("Unable to load {}", stringify!(register_device_event_ext)) + panic!(concat!( + "Unable to load ", + stringify!(register_device_event_ext) + )) } let raw_name = stringify!(vkRegisterDeviceEventEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34905,7 +35097,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_fence: *mut Fence, ) -> Result { - panic!("Unable to load {}", stringify!(register_display_event_ext)) + panic!(concat!( + "Unable to load ", + stringify!(register_display_event_ext) + )) } let raw_name = stringify!(vkRegisterDisplayEventEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -34923,7 +35118,10 @@ pub mod extensions { _counter: SurfaceCounterFlagsEXT, _p_counter_value: *mut u64, ) -> Result { - panic!("Unable to load {}", stringify!(get_swapchain_counter_ext)) + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_counter_ext) + )) } let raw_name = stringify!(vkGetSwapchainCounterEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35032,10 +35230,10 @@ pub mod extensions { _swapchain: SwapchainKHR, _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_refresh_cycle_duration_google) - ) + )) } let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35053,10 +35251,10 @@ pub mod extensions { _p_presentation_timing_count: *mut u32, _p_presentation_timings: *mut PastPresentationTimingGOOGLE, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_past_presentation_timing_google) - ) + )) } let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35223,10 +35421,10 @@ pub mod extensions { _discard_rectangle_count: u32, _p_discard_rectangles: *const Rect2D, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_set_discard_rectangle_ext) - ) + )) } let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35444,7 +35642,7 @@ pub mod extensions { _p_swapchains: *const SwapchainKHR, _p_metadata: *const HdrMetadataEXT, ) -> c_void { - panic!("Unable to load {}", stringify!(set_hdr_metadata_ext)) + panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext))) } let raw_name = stringify!(vkSetHdrMetadataEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35575,7 +35773,10 @@ pub mod extensions { _device: Device, _swapchain: SwapchainKHR, ) -> Result { - panic!("Unable to load {}", stringify!(get_swapchain_status_khr)) + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_status_khr) + )) } let raw_name = stringify!(vkGetSwapchainStatusKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35666,10 +35867,10 @@ pub mod extensions { _device: Device, _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(import_fence_win32_handle_khr) - ) + )) } let raw_name = stringify!(vkImportFenceWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35686,7 +35887,10 @@ pub mod extensions { _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, _p_handle: *mut HANDLE, ) -> Result { - panic!("Unable to load {}", stringify!(get_fence_win32_handle_khr)) + panic!(concat!( + "Unable to load ", + stringify!(get_fence_win32_handle_khr) + )) } let raw_name = stringify!(vkGetFenceWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35758,7 +35962,7 @@ pub mod extensions { _device: Device, _p_import_fence_fd_info: *const ImportFenceFdInfoKHR, ) -> Result { - panic!("Unable to load {}", stringify!(import_fence_fd_khr)) + panic!(concat!("Unable to load ", stringify!(import_fence_fd_khr))) } let raw_name = stringify!(vkImportFenceFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35775,7 +35979,7 @@ pub mod extensions { _p_get_fd_info: *const FenceGetFdInfoKHR, _p_fd: *mut c_int, ) -> Result { - panic!("Unable to load {}", stringify!(get_fence_fd_khr)) + panic!(concat!("Unable to load ", stringify!(get_fence_fd_khr))) } let raw_name = stringify!(vkGetFenceFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35899,10 +36103,10 @@ pub mod extensions { _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, _p_surface_capabilities: *mut SurfaceCapabilities2KHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_surface_capabilities2_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -35920,10 +36124,10 @@ pub mod extensions { _p_surface_format_count: *mut u32, _p_surface_formats: *mut SurfaceFormat2KHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_surface_formats2_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36044,10 +36248,10 @@ pub mod extensions { _p_property_count: *mut u32, _p_properties: *mut DisplayProperties2KHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_display_properties2_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36064,10 +36268,10 @@ pub mod extensions { _p_property_count: *mut u32, _p_properties: *mut DisplayPlaneProperties2KHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_display_plane_properties2_khr) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36085,10 +36289,10 @@ pub mod extensions { _p_property_count: *mut u32, _p_properties: *mut DisplayModeProperties2KHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_display_mode_properties2_khr) - ) + )) } let raw_name = stringify!(vkGetDisplayModeProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36105,10 +36309,10 @@ pub mod extensions { _p_display_plane_info: *const DisplayPlaneInfo2KHR, _p_capabilities: *mut DisplayPlaneCapabilities2KHR, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_display_plane_capabilities2_khr) - ) + )) } let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36222,7 +36426,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_ios_surface_mvk)) + panic!(concat!( + "Unable to load ", + stringify!(create_ios_surface_mvk) + )) } let raw_name = stringify!(vkCreateIOSSurfaceMVK); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36280,7 +36487,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_surface: *mut SurfaceKHR, ) -> Result { - panic!("Unable to load {}", stringify!(create_mac_os_surface_mvk)) + panic!(concat!( + "Unable to load ", + stringify!(create_mac_os_surface_mvk) + )) } let raw_name = stringify!(vkCreateMacOSSurfaceMVK); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36450,10 +36660,10 @@ pub mod extensions { _device: Device, _p_name_info: *const DebugUtilsObjectNameInfoEXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(set_debug_utils_object_name_ext) - ) + )) } let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36469,10 +36679,10 @@ pub mod extensions { _device: Device, _p_tag_info: *const DebugUtilsObjectTagInfoEXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(set_debug_utils_object_tag_ext) - ) + )) } let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36488,10 +36698,10 @@ pub mod extensions { _queue: Queue, _p_label_info: *const DebugUtilsLabelEXT, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(queue_begin_debug_utils_label_ext) - ) + )) } let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36504,10 +36714,10 @@ pub mod extensions { }, queue_end_debug_utils_label_ext: unsafe { extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(queue_end_debug_utils_label_ext) - ) + )) } let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36523,10 +36733,10 @@ pub mod extensions { _queue: Queue, _p_label_info: *const DebugUtilsLabelEXT, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(queue_insert_debug_utils_label_ext) - ) + )) } let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36542,10 +36752,10 @@ pub mod extensions { _command_buffer: CommandBuffer, _p_label_info: *const DebugUtilsLabelEXT, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_begin_debug_utils_label_ext) - ) + )) } let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36560,10 +36770,10 @@ pub mod extensions { extern "system" fn cmd_end_debug_utils_label_ext( _command_buffer: CommandBuffer, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_end_debug_utils_label_ext) - ) + )) } let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36579,10 +36789,10 @@ pub mod extensions { _command_buffer: CommandBuffer, _p_label_info: *const DebugUtilsLabelEXT, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_insert_debug_utils_label_ext) - ) + )) } let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36600,10 +36810,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_messenger: *mut DebugUtilsMessengerEXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(create_debug_utils_messenger_ext) - ) + )) } let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36620,10 +36830,10 @@ pub mod extensions { _messenger: DebugUtilsMessengerEXT, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(destroy_debug_utils_messenger_ext) - ) + )) } let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36641,10 +36851,10 @@ pub mod extensions { _message_types: DebugUtilsMessageTypeFlagsEXT, _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(submit_debug_utils_message_ext) - ) + )) } let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36807,10 +37017,10 @@ pub mod extensions { _buffer: *const AHardwareBuffer, _p_properties: *mut AndroidHardwareBufferPropertiesANDROID, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_android_hardware_buffer_properties_android) - ) + )) } let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -36827,10 +37037,10 @@ pub mod extensions { _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, _p_buffer: *mut *mut AHardwareBuffer, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_memory_android_hardware_buffer_android) - ) + )) } let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -37146,10 +37356,10 @@ pub mod extensions { _command_buffer: CommandBuffer, _p_sample_locations_info: *const SampleLocationsInfoEXT, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_set_sample_locations_ext) - ) + )) } let raw_name = stringify!(vkCmdSetSampleLocationsEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -37166,10 +37376,10 @@ pub mod extensions { _samples: SampleCountFlags, _p_multisample_properties: *mut MultisamplePropertiesEXT, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_physical_device_multisample_properties_ext) - ) + )) } let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -37741,7 +37951,10 @@ pub mod extensions { _p_allocator: *const AllocationCallbacks, _p_validation_cache: *mut ValidationCacheEXT, ) -> Result { - panic!("Unable to load {}", stringify!(create_validation_cache_ext)) + panic!(concat!( + "Unable to load ", + stringify!(create_validation_cache_ext) + )) } let raw_name = stringify!(vkCreateValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -37758,10 +37971,10 @@ pub mod extensions { _validation_cache: ValidationCacheEXT, _p_allocator: *const AllocationCallbacks, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(destroy_validation_cache_ext) - ) + )) } let raw_name = stringify!(vkDestroyValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -37779,7 +37992,10 @@ pub mod extensions { _src_cache_count: u32, _p_src_caches: *const ValidationCacheEXT, ) -> Result { - panic!("Unable to load {}", stringify!(merge_validation_caches_ext)) + panic!(concat!( + "Unable to load ", + stringify!(merge_validation_caches_ext) + )) } let raw_name = stringify!(vkMergeValidationCachesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -37797,10 +38013,10 @@ pub mod extensions { _p_data_size: *mut usize, _p_data: *mut c_void, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_validation_cache_data_ext) - ) + )) } let raw_name = stringify!(vkGetValidationCacheDataEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -38077,7 +38293,10 @@ pub mod extensions { _max_draw_count: u32, _stride: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_draw_indirect_count_khr)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_khr) + )) } let raw_name = stringify!(vkCmdDrawIndirectCountKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -38098,10 +38317,10 @@ pub mod extensions { _max_draw_count: u32, _stride: u32, ) -> c_void { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(cmd_draw_indexed_indirect_count_khr) - ) + )) } let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -38314,10 +38533,10 @@ pub mod extensions { _p_host_pointer: *const c_void, _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, ) -> Result { - panic!( - "Unable to load {}", + panic!(concat!( + "Unable to load ", stringify!(get_memory_host_pointer_properties_ext) - ) + )) } let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -38400,7 +38619,10 @@ pub mod extensions { _dst_offset: DeviceSize, _marker: u32, ) -> c_void { - panic!("Unable to load {}", stringify!(cmd_write_buffer_marker_amd)) + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_buffer_marker_amd) + )) } let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); @@ -39529,13 +39751,20 @@ fn display_flags( } Ok(()) } -impl fmt::Display for PolygonMode { +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -39545,13 +39774,264 @@ impl fmt::Display for PolygonMode { } } } -impl fmt::Display for CoverageModulationModeNV { +impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), _ => None, }; if let Some(x) = name { @@ -39576,45 +40056,20 @@ impl fmt::Display for DebugReportFlagsEXT { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DebugReportObjectTypeEXT { +impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), _ => None, }; if let Some(x) = name { @@ -39624,41 +40079,6 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DescriptorPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -39674,20 +40094,25 @@ impl fmt::Display for DescriptorPoolCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorType { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), _ => None, }; if let Some(x) = name { @@ -39720,46 +40145,6 @@ impl fmt::Display for ExternalFenceHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -39775,290 +40160,55 @@ impl fmt::Display for ExternalFenceFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ShaderStageFlags { +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", ), ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ImageTiling { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40073,21 +40223,12 @@ impl fmt::Display for ImageTiling { } } } -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -40097,50 +40238,11 @@ impl fmt::Display for QueryType { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DynamicState { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -40150,68 +40252,12 @@ impl fmt::Display for DynamicState { } } } -impl fmt::Display for CommandBufferUsageFlags { +impl fmt::Display for ExternalMemoryHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40223,12 +40269,17 @@ impl fmt::Display for PeerMemoryFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentLoadOp { +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), _ => None, }; if let Some(x) = name { @@ -40238,86 +40289,52 @@ impl fmt::Display for AttachmentLoadOp { } } } -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageCreateFlags { +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryAllocateFlags { +impl fmt::Display for MemoryHeapFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; display_flags(f, KNOWN, self.0) } } @@ -40338,6 +40355,22 @@ impl fmt::Display for SamplerYcbcrModelConversion { } } } +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40349,11 +40382,11 @@ impl fmt::Display for CompositeAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentStoreOp { +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), _ => None, }; if let Some(x) = name { @@ -40363,6 +40396,100 @@ impl fmt::Display for AttachmentStoreOp { } } } +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40426,6 +40553,12 @@ impl fmt::Display for BlendOp { } } } +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40455,21 +40588,24 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for ColorSpaceKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), _ => None, }; if let Some(x) = name { @@ -40479,6 +40615,88 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[( @@ -40503,6 +40721,351 @@ impl fmt::Display for BlendOverlapEXT { } } } +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40517,15 +41080,70 @@ impl fmt::Display for PipelineBindPoint { } } } -impl fmt::Display for PresentModeKHR { +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), _ => None, }; if let Some(x) = name { @@ -40975,758 +41593,6 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -41784,17 +41650,155 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompareOp { +impl fmt::Display for CoverageModulationModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -41823,279 +41827,75 @@ impl fmt::Display for ExternalMemoryFeatureFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassDescriptionFlags { +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", ), ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for Format { +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), _ => None, }; if let Some(x) = name { @@ -42105,6 +41905,530 @@ impl fmt::Display for Format { } } } +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for TessellationDomainOrigin { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -42119,56 +42443,6 @@ impl fmt::Display for TessellationDomainOrigin { } } } -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -42182,65 +42456,13 @@ impl fmt::Display for InternalAllocationType { } } } -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), ]; display_flags(f, KNOWN, self.0) } From 03665e555579a6492820de39fd6d87345d3882e2 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 10:40:09 +0100 Subject: [PATCH 114/122] Remove FunctionPointers from Entry/Device/Instance --- ash/src/device.rs | 76 +++++++++++++++--------------- ash/src/entry.rs | 90 ++++++++++++++++++------------------ ash/src/instance.rs | 110 ++++++++++++++++++++++---------------------- 3 files changed, 139 insertions(+), 137 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index b21fa7c..d0a9a06 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -1717,46 +1717,48 @@ pub trait DeviceV1_0 { } #[derive(Clone)] -pub struct Device { +pub struct Device { handle: vk::Device, - device_fn: V::DeviceFp, + device_fn_1_0: vk::DeviceFnV1_0, + device_fn_1_1: vk::DeviceFnV1_1, } - -impl DeviceV1_0 for Device { - fn handle(&self) -> vk::Device { - self.handle - } - - fn fp_v1_0(&self) -> &vk::DeviceFnV1_0 { - &self.device_fn.device_fn - } -} - -impl DeviceV1_0 for Device { - fn handle(&self) -> vk::Device { - self.handle - } - - fn fp_v1_0(&self) -> &vk::DeviceFnV1_0 { - &self.device_fn.device_fn_1_0 - } -} - -impl DeviceV1_1 for Device { - fn fp_v1_1(&self) -> &vk::DeviceFnV1_1 { - &self.device_fn.device_fn_1_1 - } -} - -impl Device { - pub fn handle(&self) -> vk::Device { - self.handle - } - - pub unsafe fn from_raw(handle: vk::Device, device_fn: V::DeviceFp) -> Self { +impl Device { + pub unsafe fn load( + instance_fn: &vk::InstanceFnV1_0, + device: vk::Device, + ) -> Self { + let device_fn_1_0 = vk::DeviceFnV1_0::load(|name| { + mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) + }); + let device_fn_1_1 = vk::DeviceFnV1_1::load(|name| { + mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) + }); Device { - handle: handle, - device_fn: device_fn, + handle: device, + device_fn_1_0, + device_fn_1_1, } } } + +impl DeviceV1_0 for Device { + fn handle(&self) -> vk::Device { + self.handle + } + + fn fp_v1_0(&self) -> &vk::DeviceFnV1_0 { + &self.device_fn_1_0 + } +} + +impl DeviceV1_1 for Device { + fn fp_v1_1(&self) -> &vk::DeviceFnV1_1 { + &self.device_fn_1_1 + } +} + +impl Device { + pub fn handle(&self) -> vk::Device { + self.handle + } +} diff --git a/ash/src/entry.rs b/ash/src/entry.rs index e75f569..164659c 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -14,7 +14,18 @@ use RawPtr; #[cfg(windows)] const LIB_PATH: &'static str = "vulkan-1.dll"; -#[cfg(all(unix, not(any(target_os = "macos", target_os = "ios", target_os = "android"))))] +#[cfg( + all( + unix, + not( + any( + target_os = "macos", + target_os = "ios", + target_os = "android" + ) + ) + ) +)] const LIB_PATH: &'static str = "libvulkan.so.1"; #[cfg(target_os = "android")] @@ -29,9 +40,10 @@ lazy_static! { } #[derive(Clone)] -pub struct Entry { +pub struct Entry { static_fn: vk::StaticFn, - entry_fn: V::EntryFp, + entry_fn_1_0: vk::EntryFnV1_0, + entry_fn_1_1: vk::EntryFnV1_1, } #[derive(Debug)] @@ -66,29 +78,14 @@ impl Error for InstanceError { #[allow(non_camel_case_types)] pub trait EntryV1_0 { - type Fp: FunctionPointers; + type Instance; fn fp_v1_0(&self) -> &vk::EntryFnV1_0; fn static_fn(&self) -> &vk::StaticFn; - unsafe fn create_instance( &self, create_info: &vk::InstanceCreateInfo, allocation_callbacks: Option<&vk::AllocationCallbacks>, - ) -> Result, InstanceError> { - let mut instance: vk::Instance = mem::uninitialized(); - let err_code = self.fp_v1_0().create_instance( - create_info, - allocation_callbacks.as_raw_ptr(), - &mut instance, - ); - if err_code != vk::Result::SUCCESS { - return Err(InstanceError::VkError(err_code)); - } - let instance_fp = - ::InstanceFp::load(&self.static_fn(), instance); - Ok(Instance::from_raw(instance, instance_fp)) - } - + ) -> Result; fn enumerate_instance_layer_properties(&self) -> VkResult> { unsafe { let mut num = 0; @@ -106,7 +103,6 @@ pub trait EntryV1_0 { } } } - fn enumerate_instance_extension_properties(&self) -> VkResult> { unsafe { let mut num = 0; @@ -138,33 +134,33 @@ pub trait EntryV1_0 { } } -impl EntryV1_0 for Entry { - type Fp = V1_0; +impl EntryV1_0 for Entry { + type Instance = Instance; + unsafe fn create_instance( + &self, + create_info: &vk::InstanceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> Result { + let mut instance: vk::Instance = mem::uninitialized(); + let err_code = self.fp_v1_0().create_instance( + create_info, + allocation_callbacks.as_raw_ptr(), + &mut instance, + ); + if err_code != vk::Result::SUCCESS { + return Err(InstanceError::VkError(err_code)); + } + Ok(Instance::load(&self.static_fn, instance)) + } fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { - self.entry_fn.fp_v1_0() + &self.entry_fn_1_0 } fn static_fn(&self) -> &vk::StaticFn { &self.static_fn } } -impl EntryV1_0 for Entry { - type Fp = V1_1; - fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { - self.entry_fn.fp_v1_0() - } - fn static_fn(&self) -> &vk::StaticFn { - &self.static_fn - } -} - -impl EntryV1_1 for Entry { - fn fp_v1_1(&self) -> &vk::EntryFnV1_1 { - &self.entry_fn.entry_fn_1_1 - } -} - -impl Entry { +impl Entry { pub fn new() -> Result { let lib = VK_LIB .as_ref() @@ -175,12 +171,18 @@ impl Entry { .unwrap_or(ptr::null_mut()) }); - let entry_fn = - unsafe { V::EntryFp::load(&static_fn) }; + let entry_fn_1_0 = vk::EntryFnV1_0::load(|name| unsafe { + mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) + }); + + let entry_fn_1_1 = vk::EntryFnV1_1::load(|name| unsafe { + mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) + }); Ok(Entry { static_fn, - entry_fn, + entry_fn_1_0, + entry_fn_1_1, }) } } diff --git a/ash/src/instance.rs b/ash/src/instance.rs index c86b9a7..3df66fc 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -10,52 +10,66 @@ use vk; use RawPtr; #[derive(Clone)] -pub struct Instance { +pub struct Instance { handle: vk::Instance, - instance_fp: V::InstanceFp, + instance_fn_1_0: vk::InstanceFnV1_0, + instance_fn_1_1: vk::InstanceFnV1_1, } +impl Instance { + pub unsafe fn load( + static_fn: &vk::StaticFn, + instance: vk::Instance, + ) -> Self { + let instance_fn_1_0 = vk::InstanceFnV1_0::load(|name| { + mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) + }); + let instance_fn_1_1 = vk::InstanceFnV1_1::load(|name| { + mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) + }); -impl InstanceV1_0 for Instance { - type Fp = V1_0; - fn handle(&self) -> vk::Instance { - self.handle - } - - fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 { - &self.instance_fp.instance_fn - } -} - -impl InstanceV1_0 for Instance { - type Fp = V1_1; - fn handle(&self) -> vk::Instance { - self.handle - } - - fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 { - &self.instance_fp.instance_fn_1_0 - } -} - -impl InstanceV1_1 for Instance { - fn fp_v1_1(&self) -> &vk::InstanceFnV1_1 { - &self.instance_fp.instance_fn_1_1 - } -} - -impl Instance { - pub fn handle(&self) -> vk::Instance { - self.handle - } - - pub fn from_raw(handle: vk::Instance, version: V::InstanceFp) -> Self { Instance { - handle: handle, - instance_fp: version, + handle: instance, + instance_fn_1_0, + instance_fn_1_1, } } } +impl InstanceV1_0 for Instance { + type Device = Device; + unsafe fn create_device( + &self, + physical_device: vk::PhysicalDevice, + create_info: &vk::DeviceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> Result { + let mut device: vk::Device = mem::uninitialized(); + let err_code = self.fp_v1_0().create_device( + physical_device, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut device, + ); + if err_code != vk::Result::SUCCESS { + return Err(err_code); + } + Ok(Device::load(&self.instance_fn_1_0, device)) + } + fn handle(&self) -> vk::Instance { + self.handle + } + + fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 { + &self.instance_fn_1_0 + } +} + +impl InstanceV1_1 for Instance { + fn fp_v1_1(&self) -> &vk::InstanceFnV1_1 { + &self.instance_fn_1_1 + } +} + #[allow(non_camel_case_types)] pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; @@ -232,7 +246,7 @@ pub trait InstanceV1_1: InstanceV1_0 { #[allow(non_camel_case_types)] pub trait InstanceV1_0 { - type Fp: FunctionPointers; + type Device; fn handle(&self) -> vk::Instance; fn fp_v1_0(&self) -> &vk::InstanceFnV1_0; unsafe fn create_device( @@ -240,23 +254,7 @@ pub trait InstanceV1_0 { physical_device: vk::PhysicalDevice, create_info: &vk::DeviceCreateInfo, allocation_callbacks: Option<&vk::AllocationCallbacks>, - ) -> Result, vk::Result> { - let mut device: vk::Device = mem::uninitialized(); - let err_code = self.fp_v1_0().create_device( - physical_device, - create_info, - allocation_callbacks.as_raw_ptr(), - &mut device, - ); - if err_code != vk::Result::SUCCESS { - return Err(err_code); - } - let device_fn = <::Fp as FunctionPointers>::DeviceFp::load( - self.fp_v1_0(), - device, - ); - Ok(Device::from_raw(device, device_fn)) - } + ) -> Result; unsafe fn get_device_proc_addr( &self, From b5fc6d37f2e82f182c94d1fd965ad02721c29f85 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 10:41:58 +0100 Subject: [PATCH 115/122] Update the examples --- examples/src/lib.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 61acd62..6b7fc84 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -9,7 +9,7 @@ use ash::extensions::Win32Surface; #[cfg(not(windows))] use ash::extensions::XlibSurface; use ash::extensions::{DebugReport, Surface, Swapchain}; -pub use ash::version::{DeviceV1_0, EntryV1_0, InstanceV1_0, V1_0}; +pub use ash::version::{DeviceV1_0, EntryV1_0, InstanceV1_0,}; use ash::vk; use ash::Device; use ash::Entry; @@ -205,9 +205,9 @@ pub fn find_memorytype_index_f, - pub instance: Instance, - pub device: Device, + pub entry: Entry, + pub instance: Instance, + pub device: Device, pub surface_loader: Surface, pub swapchain_loader: Swapchain, pub debug_report_loader: DebugReport, @@ -301,7 +301,7 @@ impl ExampleBase { pp_enabled_extension_names: extension_names_raw.as_ptr(), enabled_extension_count: extension_names_raw.len() as u32, }; - let instance: Instance = entry + let instance: Instance = entry .create_instance(&create_info, None) .expect("Instance creation error"); let debug_info = vk::DebugReportCallbackCreateInfoEXT { @@ -374,7 +374,7 @@ impl ExampleBase { pp_enabled_extension_names: device_extension_names_raw.as_ptr(), p_enabled_features: &features, }; - let device: Device = instance + let device: Device = instance .create_device(pdevice, &device_create_info, None) .unwrap(); let present_queue = device.get_device_queue(queue_family_index as u32, 0); From 373ed4240225ed6a51910560028b50dc08566671 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 10:46:03 +0100 Subject: [PATCH 116/122] Remove unused versioning --- ash/src/device.rs | 1 - ash/src/entry.rs | 1 - ash/src/instance.rs | 2 - ash/src/version.rs | 179 ----------------------------------- examples/src/bin/texture.rs | 1 - examples/src/bin/triangle.rs | 1 - 6 files changed, 185 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index d0a9a06..8b9cbc0 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -3,7 +3,6 @@ use prelude::*; use std::mem; use std::os::raw::c_void; use std::ptr; -use version::{FunctionPointers, V1_0, V1_1}; use vk; use RawPtr; diff --git a/ash/src/entry.rs b/ash/src/entry.rs index 164659c..a6955d0 100644 --- a/ash/src/entry.rs +++ b/ash/src/entry.rs @@ -7,7 +7,6 @@ use std::mem; use std::os::raw::c_char; use std::path::Path; use std::ptr; -use version::{EntryLoader, FunctionPointers, InstanceLoader, V1_0, V1_1}; use vk; use RawPtr; diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 3df66fc..6137c1d 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -4,8 +4,6 @@ use prelude::*; use std::mem; use std::os::raw::c_char; use std::ptr; -use version::DeviceLoader; -use version::{FunctionPointers, V1_0, V1_1}; use vk; use RawPtr; diff --git a/ash/src/version.rs b/ash/src/version.rs index 4d86da3..922f6bf 100644 --- a/ash/src/version.rs +++ b/ash/src/version.rs @@ -1,182 +1,3 @@ pub use device::{DeviceV1_0, DeviceV1_1}; pub use entry::{EntryV1_0, EntryV1_1}; pub use instance::{InstanceV1_0, InstanceV1_1}; -use std::mem; -use vk; -pub trait FunctionPointers { - type InstanceFp: InstanceLoader + Clone; - type DeviceFp: DeviceLoader + Clone; - type EntryFp: EntryLoader + Clone; -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct V1_1; -impl FunctionPointers for V1_1 { - type InstanceFp = InstanceFpV1_1; - type DeviceFp = DeviceFpV1_1; - type EntryFp = EntryFpV1_1; -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct V1_0; -impl FunctionPointers for V1_0 { - type InstanceFp = InstanceFpV1_0; - type DeviceFp = DeviceFpV1_0; - type EntryFp = EntryFpV1_0; -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct EntryFpV1_0 { - pub entry_fn: vk::EntryFnV1_0, -} - -impl EntryLoader for EntryFpV1_0 { - fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { - &self.entry_fn - } - unsafe fn load(static_fn: &vk::StaticFn) -> Self { - let entry_fn = vk::EntryFnV1_0::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) - }); - EntryFpV1_0 { entry_fn: entry_fn } - } -} - -pub trait EntryLoader: Sized { - fn fp_v1_0(&self) -> &vk::EntryFnV1_0; - unsafe fn load(static_fn: &vk::StaticFn) -> Self; -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct EntryFpV1_1 { - pub entry_fn_1_0: vk::EntryFnV1_0, - pub entry_fn_1_1: vk::EntryFnV1_1, -} - -impl EntryLoader for EntryFpV1_1 { - fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { - &self.entry_fn_1_0 - } - unsafe fn load(static_fn: &vk::StaticFn) -> Self { - let entry_fn_1_0 = vk::EntryFnV1_0::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) - }); - let entry_fn_1_1 = vk::EntryFnV1_1::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr())) - }); - - EntryFpV1_1 { - entry_fn_1_0, - entry_fn_1_1, - } - } -} - -pub trait InstanceLoader: Sized { - unsafe fn load( - static_fn: &vk::StaticFn, - instance: vk::Instance, - ) -> Self; -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct InstanceFpV1_0 { - pub instance_fn: vk::InstanceFnV1_0, -} - -impl InstanceLoader for InstanceFpV1_0 { - unsafe fn load( - static_fn: &vk::StaticFn, - instance: vk::Instance, - ) -> Self { - let instance_fn = vk::InstanceFnV1_0::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) - }); - InstanceFpV1_0 { - instance_fn: instance_fn, - } - } -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct InstanceFpV1_1 { - pub instance_fn_1_0: vk::InstanceFnV1_0, - pub instance_fn_1_1: vk::InstanceFnV1_1, -} - -impl InstanceLoader for InstanceFpV1_1 { - unsafe fn load( - static_fn: &vk::StaticFn, - instance: vk::Instance, - ) -> Self { - let instance_fn_1_0 = vk::InstanceFnV1_0::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) - }); - let instance_fn_1_1 = vk::InstanceFnV1_1::load(|name| { - mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) - }); - - InstanceFpV1_1 { - instance_fn_1_0, - instance_fn_1_1, - } - } -} - -pub trait DeviceLoader: Sized { - unsafe fn load( - instance_fn: &vk::InstanceFnV1_0, - device: vk::Device, - ) -> Self; -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct DeviceFpV1_0 { - pub device_fn: vk::DeviceFnV1_0, -} - -impl DeviceLoader for DeviceFpV1_0 { - unsafe fn load( - instance_fn: &vk::InstanceFnV1_0, - device: vk::Device, - ) -> Self { - let device_fn = vk::DeviceFnV1_0::load(|name| { - mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) - }); - DeviceFpV1_0 { - device_fn: device_fn, - } - } -} - -#[allow(non_camel_case_types)] -#[derive(Clone)] -pub struct DeviceFpV1_1 { - pub device_fn_1_0: vk::DeviceFnV1_0, - pub device_fn_1_1: vk::DeviceFnV1_1, -} - -impl DeviceLoader for DeviceFpV1_1 { - unsafe fn load( - instance_fn: &vk::InstanceFnV1_0, - device: vk::Device, - ) -> Self { - let device_fn_1_0 = vk::DeviceFnV1_0::load(|name| { - mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) - }); - let device_fn_1_1 = vk::DeviceFnV1_1::load(|name| { - mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr())) - }); - DeviceFpV1_1 { - device_fn_1_0, - device_fn_1_1, - } - } -} diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index d87df89..5aece4c 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -1,5 +1,4 @@ extern crate ash; -#[macro_use] extern crate examples; extern crate image; diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index 12a3b85..c0ba9f1 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -1,5 +1,4 @@ extern crate ash; -#[macro_use] extern crate examples; use ash::util::*; From 3f9a28af7e6a71a2a3cb76464ca22099ea3f6b21 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 14:38:32 +0100 Subject: [PATCH 117/122] Regenerate vk.rs --- ash/src/vk.rs | 5406 ++++++++++++++++++------------------------------- 1 file changed, 2018 insertions(+), 3388 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index cb279af..692dd6e 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -6974,9 +6974,8 @@ impl fmt::Debug for PhysicalDeviceProperties { .field("device_type", &self.device_type) .field("device_name", &unsafe { ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const i8) - }).field("pipeline_cache_uuid", &unsafe { - ::std::ffi::CStr::from_ptr(self.pipeline_cache_uuid.as_ptr() as *const i8) - }).field("limits", &self.limits) + }).field("pipeline_cache_uuid", &self.pipeline_cache_uuid) + .field("limits", &self.limits) .field("sparse_properties", &self.sparse_properties) .finish() } @@ -7295,9 +7294,11 @@ impl fmt::Debug for AllocationCallbacks { ).field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) .field( "pfn_internal_allocation", - &(self.pfn_internal_allocation as *const ()), - ).field("pfn_internal_free", &(self.pfn_internal_free as *const ())) - .finish() + &(self.pfn_internal_allocation.map(|x| x as *const ())), + ).field( + "pfn_internal_free", + &(self.pfn_internal_free.map(|x| x as *const ())), + ).finish() } } impl ::std::default::Default for AllocationCallbacks { @@ -7660,18 +7661,6 @@ pub struct PhysicalDeviceMemoryProperties { pub memory_heap_count: u32, pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], } -impl ::std::fmt::Debug for PhysicalDeviceMemoryProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("PhysicalDeviceMemoryProperties") - .field("memory_type_count", &self.memory_type_count) - .field("memory_types", &unsafe { - ::std::ffi::CStr::from_ptr(self.memory_types.as_ptr() as *const i8) - }).field("memory_heap_count", &self.memory_heap_count) - .field("memory_heaps", &unsafe { - ::std::ffi::CStr::from_ptr(self.memory_heaps.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for PhysicalDeviceMemoryProperties { fn default() -> PhysicalDeviceMemoryProperties { PhysicalDeviceMemoryProperties { @@ -9676,18 +9665,6 @@ pub struct ImageBlit { pub dst_subresource: ImageSubresourceLayers, pub dst_offsets: [Offset3D; 2], } -impl ::std::fmt::Debug for ImageBlit { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("ImageBlit") - .field("src_subresource", &self.src_subresource) - .field("src_offsets", &unsafe { - ::std::ffi::CStr::from_ptr(self.src_offsets.as_ptr() as *const i8) - }).field("dst_subresource", &self.dst_subresource) - .field("dst_offsets", &unsafe { - ::std::ffi::CStr::from_ptr(self.dst_offsets.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for ImageBlit { fn default() -> ImageBlit { ImageBlit { @@ -11134,21 +11111,6 @@ pub struct PipelineColorBlendStateCreateInfo { pub p_attachments: *const PipelineColorBlendAttachmentState, pub blend_constants: [c_float; 4], } -impl ::std::fmt::Debug for PipelineColorBlendStateCreateInfo { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("PipelineColorBlendStateCreateInfo") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("flags", &self.flags) - .field("logic_op_enable", &self.logic_op_enable) - .field("logic_op", &self.logic_op) - .field("attachment_count", &self.attachment_count) - .field("p_attachments", &self.p_attachments) - .field("blend_constants", &unsafe { - ::std::ffi::CStr::from_ptr(self.blend_constants.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for PipelineColorBlendStateCreateInfo { fn default() -> PipelineColorBlendStateCreateInfo { PipelineColorBlendStateCreateInfo { @@ -13461,238 +13423,6 @@ pub struct PhysicalDeviceLimits { pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, pub non_coherent_atom_size: DeviceSize, } -impl ::std::fmt::Debug for PhysicalDeviceLimits { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("PhysicalDeviceLimits") - .field("max_image_dimension1_d", &self.max_image_dimension1_d) - .field("max_image_dimension2_d", &self.max_image_dimension2_d) - .field("max_image_dimension3_d", &self.max_image_dimension3_d) - .field("max_image_dimension_cube", &self.max_image_dimension_cube) - .field("max_image_array_layers", &self.max_image_array_layers) - .field("max_texel_buffer_elements", &self.max_texel_buffer_elements) - .field("max_uniform_buffer_range", &self.max_uniform_buffer_range) - .field("max_storage_buffer_range", &self.max_storage_buffer_range) - .field("max_push_constants_size", &self.max_push_constants_size) - .field( - "max_memory_allocation_count", - &self.max_memory_allocation_count, - ).field( - "max_sampler_allocation_count", - &self.max_sampler_allocation_count, - ).field("buffer_image_granularity", &self.buffer_image_granularity) - .field("sparse_address_space_size", &self.sparse_address_space_size) - .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets) - .field( - "max_per_stage_descriptor_samplers", - &self.max_per_stage_descriptor_samplers, - ).field( - "max_per_stage_descriptor_uniform_buffers", - &self.max_per_stage_descriptor_uniform_buffers, - ).field( - "max_per_stage_descriptor_storage_buffers", - &self.max_per_stage_descriptor_storage_buffers, - ).field( - "max_per_stage_descriptor_sampled_images", - &self.max_per_stage_descriptor_sampled_images, - ).field( - "max_per_stage_descriptor_storage_images", - &self.max_per_stage_descriptor_storage_images, - ).field( - "max_per_stage_descriptor_input_attachments", - &self.max_per_stage_descriptor_input_attachments, - ).field("max_per_stage_resources", &self.max_per_stage_resources) - .field( - "max_descriptor_set_samplers", - &self.max_descriptor_set_samplers, - ).field( - "max_descriptor_set_uniform_buffers", - &self.max_descriptor_set_uniform_buffers, - ).field( - "max_descriptor_set_uniform_buffers_dynamic", - &self.max_descriptor_set_uniform_buffers_dynamic, - ).field( - "max_descriptor_set_storage_buffers", - &self.max_descriptor_set_storage_buffers, - ).field( - "max_descriptor_set_storage_buffers_dynamic", - &self.max_descriptor_set_storage_buffers_dynamic, - ).field( - "max_descriptor_set_sampled_images", - &self.max_descriptor_set_sampled_images, - ).field( - "max_descriptor_set_storage_images", - &self.max_descriptor_set_storage_images, - ).field( - "max_descriptor_set_input_attachments", - &self.max_descriptor_set_input_attachments, - ).field( - "max_vertex_input_attributes", - &self.max_vertex_input_attributes, - ).field("max_vertex_input_bindings", &self.max_vertex_input_bindings) - .field( - "max_vertex_input_attribute_offset", - &self.max_vertex_input_attribute_offset, - ).field( - "max_vertex_input_binding_stride", - &self.max_vertex_input_binding_stride, - ).field( - "max_vertex_output_components", - &self.max_vertex_output_components, - ).field( - "max_tessellation_generation_level", - &self.max_tessellation_generation_level, - ).field( - "max_tessellation_patch_size", - &self.max_tessellation_patch_size, - ).field( - "max_tessellation_control_per_vertex_input_components", - &self.max_tessellation_control_per_vertex_input_components, - ).field( - "max_tessellation_control_per_vertex_output_components", - &self.max_tessellation_control_per_vertex_output_components, - ).field( - "max_tessellation_control_per_patch_output_components", - &self.max_tessellation_control_per_patch_output_components, - ).field( - "max_tessellation_control_total_output_components", - &self.max_tessellation_control_total_output_components, - ).field( - "max_tessellation_evaluation_input_components", - &self.max_tessellation_evaluation_input_components, - ).field( - "max_tessellation_evaluation_output_components", - &self.max_tessellation_evaluation_output_components, - ).field( - "max_geometry_shader_invocations", - &self.max_geometry_shader_invocations, - ).field( - "max_geometry_input_components", - &self.max_geometry_input_components, - ).field( - "max_geometry_output_components", - &self.max_geometry_output_components, - ).field( - "max_geometry_output_vertices", - &self.max_geometry_output_vertices, - ).field( - "max_geometry_total_output_components", - &self.max_geometry_total_output_components, - ).field( - "max_fragment_input_components", - &self.max_fragment_input_components, - ).field( - "max_fragment_output_attachments", - &self.max_fragment_output_attachments, - ).field( - "max_fragment_dual_src_attachments", - &self.max_fragment_dual_src_attachments, - ).field( - "max_fragment_combined_output_resources", - &self.max_fragment_combined_output_resources, - ).field( - "max_compute_shared_memory_size", - &self.max_compute_shared_memory_size, - ).field("max_compute_work_group_count", &unsafe { - ::std::ffi::CStr::from_ptr(self.max_compute_work_group_count.as_ptr() as *const i8) - }).field( - "max_compute_work_group_invocations", - &self.max_compute_work_group_invocations, - ).field("max_compute_work_group_size", &unsafe { - ::std::ffi::CStr::from_ptr(self.max_compute_work_group_size.as_ptr() as *const i8) - }).field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits) - .field("sub_texel_precision_bits", &self.sub_texel_precision_bits) - .field("mipmap_precision_bits", &self.mipmap_precision_bits) - .field( - "max_draw_indexed_index_value", - &self.max_draw_indexed_index_value, - ).field("max_draw_indirect_count", &self.max_draw_indirect_count) - .field("max_sampler_lod_bias", &self.max_sampler_lod_bias) - .field("max_sampler_anisotropy", &self.max_sampler_anisotropy) - .field("max_viewports", &self.max_viewports) - .field("max_viewport_dimensions", &unsafe { - ::std::ffi::CStr::from_ptr(self.max_viewport_dimensions.as_ptr() as *const i8) - }).field("viewport_bounds_range", &unsafe { - ::std::ffi::CStr::from_ptr(self.viewport_bounds_range.as_ptr() as *const i8) - }).field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits) - .field("min_memory_map_alignment", &self.min_memory_map_alignment) - .field( - "min_texel_buffer_offset_alignment", - &self.min_texel_buffer_offset_alignment, - ).field( - "min_uniform_buffer_offset_alignment", - &self.min_uniform_buffer_offset_alignment, - ).field( - "min_storage_buffer_offset_alignment", - &self.min_storage_buffer_offset_alignment, - ).field("min_texel_offset", &self.min_texel_offset) - .field("max_texel_offset", &self.max_texel_offset) - .field("min_texel_gather_offset", &self.min_texel_gather_offset) - .field("max_texel_gather_offset", &self.max_texel_gather_offset) - .field("min_interpolation_offset", &self.min_interpolation_offset) - .field("max_interpolation_offset", &self.max_interpolation_offset) - .field( - "sub_pixel_interpolation_offset_bits", - &self.sub_pixel_interpolation_offset_bits, - ).field("max_framebuffer_width", &self.max_framebuffer_width) - .field("max_framebuffer_height", &self.max_framebuffer_height) - .field("max_framebuffer_layers", &self.max_framebuffer_layers) - .field( - "framebuffer_color_sample_counts", - &self.framebuffer_color_sample_counts, - ).field( - "framebuffer_depth_sample_counts", - &self.framebuffer_depth_sample_counts, - ).field( - "framebuffer_stencil_sample_counts", - &self.framebuffer_stencil_sample_counts, - ).field( - "framebuffer_no_attachments_sample_counts", - &self.framebuffer_no_attachments_sample_counts, - ).field("max_color_attachments", &self.max_color_attachments) - .field( - "sampled_image_color_sample_counts", - &self.sampled_image_color_sample_counts, - ).field( - "sampled_image_integer_sample_counts", - &self.sampled_image_integer_sample_counts, - ).field( - "sampled_image_depth_sample_counts", - &self.sampled_image_depth_sample_counts, - ).field( - "sampled_image_stencil_sample_counts", - &self.sampled_image_stencil_sample_counts, - ).field( - "storage_image_sample_counts", - &self.storage_image_sample_counts, - ).field("max_sample_mask_words", &self.max_sample_mask_words) - .field( - "timestamp_compute_and_graphics", - &self.timestamp_compute_and_graphics, - ).field("timestamp_period", &self.timestamp_period) - .field("max_clip_distances", &self.max_clip_distances) - .field("max_cull_distances", &self.max_cull_distances) - .field( - "max_combined_clip_and_cull_distances", - &self.max_combined_clip_and_cull_distances, - ).field("discrete_queue_priorities", &self.discrete_queue_priorities) - .field("point_size_range", &unsafe { - ::std::ffi::CStr::from_ptr(self.point_size_range.as_ptr() as *const i8) - }).field("line_width_range", &unsafe { - ::std::ffi::CStr::from_ptr(self.line_width_range.as_ptr() as *const i8) - }).field("point_size_granularity", &self.point_size_granularity) - .field("line_width_granularity", &self.line_width_granularity) - .field("strict_lines", &self.strict_lines) - .field("standard_sample_locations", &self.standard_sample_locations) - .field( - "optimal_buffer_copy_offset_alignment", - &self.optimal_buffer_copy_offset_alignment, - ).field( - "optimal_buffer_copy_row_pitch_alignment", - &self.optimal_buffer_copy_row_pitch_alignment, - ).field("non_coherent_atom_size", &self.non_coherent_atom_size) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceLimits { fn default() -> PhysicalDeviceLimits { PhysicalDeviceLimits { @@ -16572,17 +16302,6 @@ pub struct DebugMarkerMarkerInfoEXT { pub p_marker_name: *const c_char, pub color: [c_float; 4], } -impl ::std::fmt::Debug for DebugMarkerMarkerInfoEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("DebugMarkerMarkerInfoEXT") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("p_marker_name", &self.p_marker_name) - .field("color", &unsafe { - ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for DebugMarkerMarkerInfoEXT { fn default() -> DebugMarkerMarkerInfoEXT { DebugMarkerMarkerInfoEXT { @@ -18959,22 +18678,6 @@ pub struct PhysicalDeviceIDProperties { pub device_node_mask: u32, pub device_luid_valid: Bool32, } -impl ::std::fmt::Debug for PhysicalDeviceIDProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("PhysicalDeviceIDProperties") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("device_uuid", &unsafe { - ::std::ffi::CStr::from_ptr(self.device_uuid.as_ptr() as *const i8) - }).field("driver_uuid", &unsafe { - ::std::ffi::CStr::from_ptr(self.driver_uuid.as_ptr() as *const i8) - }).field("device_luid", &unsafe { - ::std::ffi::CStr::from_ptr(self.device_luid.as_ptr() as *const i8) - }).field("device_node_mask", &self.device_node_mask) - .field("device_luid_valid", &self.device_luid_valid) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceIDProperties { fn default() -> PhysicalDeviceIDProperties { PhysicalDeviceIDProperties { @@ -21116,18 +20819,6 @@ pub struct PhysicalDeviceGroupProperties { pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, } -impl ::std::fmt::Debug for PhysicalDeviceGroupProperties { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("PhysicalDeviceGroupProperties") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("physical_device_count", &self.physical_device_count) - .field("physical_devices", &unsafe { - ::std::ffi::CStr::from_ptr(self.physical_devices.as_ptr() as *const i8) - }).field("subset_allocation", &self.subset_allocation) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceGroupProperties { fn default() -> PhysicalDeviceGroupProperties { PhysicalDeviceGroupProperties { @@ -21686,17 +21377,6 @@ pub struct DeviceGroupPresentCapabilitiesKHR { pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE], pub modes: DeviceGroupPresentModeFlagsKHR, } -impl ::std::fmt::Debug for DeviceGroupPresentCapabilitiesKHR { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("DeviceGroupPresentCapabilitiesKHR") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("present_mask", &unsafe { - ::std::ffi::CStr::from_ptr(self.present_mask.as_ptr() as *const i8) - }).field("modes", &self.modes) - .finish() - } -} impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { fn default() -> DeviceGroupPresentCapabilitiesKHR { DeviceGroupPresentCapabilitiesKHR { @@ -25130,28 +24810,6 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub sample_location_sub_pixel_bits: u32, pub variable_sample_locations: Bool32, } -impl ::std::fmt::Debug for PhysicalDeviceSampleLocationsPropertiesEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("PhysicalDeviceSampleLocationsPropertiesEXT") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field( - "sample_location_sample_counts", - &self.sample_location_sample_counts, - ).field( - "max_sample_location_grid_size", - &self.max_sample_location_grid_size, - ).field("sample_location_coordinate_range", &unsafe { - ::std::ffi::CStr::from_ptr( - self.sample_location_coordinate_range.as_ptr() as *const i8 - ) - }).field( - "sample_location_sub_pixel_bits", - &self.sample_location_sub_pixel_bits, - ).field("variable_sample_locations", &self.variable_sample_locations) - .finish() - } -} impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { fn default() -> PhysicalDeviceSampleLocationsPropertiesEXT { PhysicalDeviceSampleLocationsPropertiesEXT { @@ -26024,20 +25682,6 @@ pub struct ShaderStatisticsInfoAMD { pub num_available_sgprs: u32, pub compute_work_group_size: [u32; 3], } -impl ::std::fmt::Debug for ShaderStatisticsInfoAMD { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("ShaderStatisticsInfoAMD") - .field("shader_stage_mask", &self.shader_stage_mask) - .field("resource_usage", &self.resource_usage) - .field("num_physical_vgprs", &self.num_physical_vgprs) - .field("num_physical_sgprs", &self.num_physical_sgprs) - .field("num_available_vgprs", &self.num_available_vgprs) - .field("num_available_sgprs", &self.num_available_sgprs) - .field("compute_work_group_size", &unsafe { - ::std::ffi::CStr::from_ptr(self.compute_work_group_size.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for ShaderStatisticsInfoAMD { fn default() -> ShaderStatisticsInfoAMD { ShaderStatisticsInfoAMD { @@ -26302,17 +25946,6 @@ pub struct DebugUtilsLabelEXT { pub p_label_name: *const c_char, pub color: [c_float; 4], } -impl ::std::fmt::Debug for DebugUtilsLabelEXT { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { - fmt.debug_struct("DebugUtilsLabelEXT") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("p_label_name", &self.p_label_name) - .field("color", &unsafe { - ::std::ffi::CStr::from_ptr(self.color.as_ptr() as *const i8) - }).finish() - } -} impl ::std::default::Default for DebugUtilsLabelEXT { fn default() -> DebugUtilsLabelEXT { DebugUtilsLabelEXT { @@ -40110,6 +39743,466 @@ fn display_flags( } Ok(()) } +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for CommandBufferResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[( @@ -40119,6 +40212,613 @@ impl fmt::Display for CommandBufferResetFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ImageType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40134,437 +40834,13 @@ impl fmt::Display for ImageType { } } } -impl fmt::Display for StructureType { +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::APPLICATION_INFO => Some("APPLICATION_INFO"), - Self::INSTANCE_CREATE_INFO => Some("INSTANCE_CREATE_INFO"), - Self::DEVICE_QUEUE_CREATE_INFO => Some("DEVICE_QUEUE_CREATE_INFO"), - Self::DEVICE_CREATE_INFO => Some("DEVICE_CREATE_INFO"), - Self::SUBMIT_INFO => Some("SUBMIT_INFO"), - Self::MEMORY_ALLOCATE_INFO => Some("MEMORY_ALLOCATE_INFO"), - Self::MAPPED_MEMORY_RANGE => Some("MAPPED_MEMORY_RANGE"), - Self::BIND_SPARSE_INFO => Some("BIND_SPARSE_INFO"), - Self::FENCE_CREATE_INFO => Some("FENCE_CREATE_INFO"), - Self::SEMAPHORE_CREATE_INFO => Some("SEMAPHORE_CREATE_INFO"), - Self::EVENT_CREATE_INFO => Some("EVENT_CREATE_INFO"), - Self::QUERY_POOL_CREATE_INFO => Some("QUERY_POOL_CREATE_INFO"), - Self::BUFFER_CREATE_INFO => Some("BUFFER_CREATE_INFO"), - Self::BUFFER_VIEW_CREATE_INFO => Some("BUFFER_VIEW_CREATE_INFO"), - Self::IMAGE_CREATE_INFO => Some("IMAGE_CREATE_INFO"), - Self::IMAGE_VIEW_CREATE_INFO => Some("IMAGE_VIEW_CREATE_INFO"), - Self::SHADER_MODULE_CREATE_INFO => Some("SHADER_MODULE_CREATE_INFO"), - Self::PIPELINE_CACHE_CREATE_INFO => Some("PIPELINE_CACHE_CREATE_INFO"), - Self::PIPELINE_SHADER_STAGE_CREATE_INFO => Some("PIPELINE_SHADER_STAGE_CREATE_INFO"), - Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => { - Some("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO") - } - Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => { - Some("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO") - } - Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => { - Some("PIPELINE_TESSELLATION_STATE_CREATE_INFO") - } - Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => { - Some("PIPELINE_VIEWPORT_STATE_CREATE_INFO") - } - Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => { - Some("PIPELINE_RASTERIZATION_STATE_CREATE_INFO") - } - Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => { - Some("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO") - } - Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => { - Some("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO") - } - Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => { - Some("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO") - } - Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => Some("PIPELINE_DYNAMIC_STATE_CREATE_INFO"), - Self::GRAPHICS_PIPELINE_CREATE_INFO => Some("GRAPHICS_PIPELINE_CREATE_INFO"), - Self::COMPUTE_PIPELINE_CREATE_INFO => Some("COMPUTE_PIPELINE_CREATE_INFO"), - Self::PIPELINE_LAYOUT_CREATE_INFO => Some("PIPELINE_LAYOUT_CREATE_INFO"), - Self::SAMPLER_CREATE_INFO => Some("SAMPLER_CREATE_INFO"), - Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => Some("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"), - Self::DESCRIPTOR_POOL_CREATE_INFO => Some("DESCRIPTOR_POOL_CREATE_INFO"), - Self::DESCRIPTOR_SET_ALLOCATE_INFO => Some("DESCRIPTOR_SET_ALLOCATE_INFO"), - Self::WRITE_DESCRIPTOR_SET => Some("WRITE_DESCRIPTOR_SET"), - Self::COPY_DESCRIPTOR_SET => Some("COPY_DESCRIPTOR_SET"), - Self::FRAMEBUFFER_CREATE_INFO => Some("FRAMEBUFFER_CREATE_INFO"), - Self::RENDER_PASS_CREATE_INFO => Some("RENDER_PASS_CREATE_INFO"), - Self::COMMAND_POOL_CREATE_INFO => Some("COMMAND_POOL_CREATE_INFO"), - Self::COMMAND_BUFFER_ALLOCATE_INFO => Some("COMMAND_BUFFER_ALLOCATE_INFO"), - Self::COMMAND_BUFFER_INHERITANCE_INFO => Some("COMMAND_BUFFER_INHERITANCE_INFO"), - Self::COMMAND_BUFFER_BEGIN_INFO => Some("COMMAND_BUFFER_BEGIN_INFO"), - Self::RENDER_PASS_BEGIN_INFO => Some("RENDER_PASS_BEGIN_INFO"), - Self::BUFFER_MEMORY_BARRIER => Some("BUFFER_MEMORY_BARRIER"), - Self::IMAGE_MEMORY_BARRIER => Some("IMAGE_MEMORY_BARRIER"), - Self::MEMORY_BARRIER => Some("MEMORY_BARRIER"), - Self::LOADER_INSTANCE_CREATE_INFO => Some("LOADER_INSTANCE_CREATE_INFO"), - Self::LOADER_DEVICE_CREATE_INFO => Some("LOADER_DEVICE_CREATE_INFO"), - Self::SWAPCHAIN_CREATE_INFO_KHR => Some("SWAPCHAIN_CREATE_INFO_KHR"), - Self::PRESENT_INFO_KHR => Some("PRESENT_INFO_KHR"), - Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => { - Some("DEVICE_GROUP_PRESENT_CAPABILITIES_KHR") - } - Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => Some("IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), - Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => { - Some("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR") - } - Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => Some("ACQUIRE_NEXT_IMAGE_INFO_KHR"), - Self::DEVICE_GROUP_PRESENT_INFO_KHR => Some("DEVICE_GROUP_PRESENT_INFO_KHR"), - Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => { - Some("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR") - } - Self::DISPLAY_MODE_CREATE_INFO_KHR => Some("DISPLAY_MODE_CREATE_INFO_KHR"), - Self::DISPLAY_SURFACE_CREATE_INFO_KHR => Some("DISPLAY_SURFACE_CREATE_INFO_KHR"), - Self::DISPLAY_PRESENT_INFO_KHR => Some("DISPLAY_PRESENT_INFO_KHR"), - Self::XLIB_SURFACE_CREATE_INFO_KHR => Some("XLIB_SURFACE_CREATE_INFO_KHR"), - Self::XCB_SURFACE_CREATE_INFO_KHR => Some("XCB_SURFACE_CREATE_INFO_KHR"), - Self::WAYLAND_SURFACE_CREATE_INFO_KHR => Some("WAYLAND_SURFACE_CREATE_INFO_KHR"), - Self::MIR_SURFACE_CREATE_INFO_KHR => Some("MIR_SURFACE_CREATE_INFO_KHR"), - Self::ANDROID_SURFACE_CREATE_INFO_KHR => Some("ANDROID_SURFACE_CREATE_INFO_KHR"), - Self::WIN32_SURFACE_CREATE_INFO_KHR => Some("WIN32_SURFACE_CREATE_INFO_KHR"), - Self::NATIVE_BUFFER_ANDROID => Some("NATIVE_BUFFER_ANDROID"), - Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => { - Some("DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT") - } - Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => { - Some("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD") - } - Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"), - Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"), - Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"), - Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { - Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") - } - Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => { - Some("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV") - } - Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => { - Some("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV") - } - Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { - Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") - } - Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => { - Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV") - } - Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => Some("EXPORT_MEMORY_ALLOCATE_INFO_NV"), - Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"), - Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"), - Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => { - Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV") - } - Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"), - Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"), - Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { - Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR") - } - Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { - Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR") - } - Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => Some("MEMORY_WIN32_HANDLE_PROPERTIES_KHR"), - Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => Some("MEMORY_GET_WIN32_HANDLE_INFO_KHR"), - Self::IMPORT_MEMORY_FD_INFO_KHR => Some("IMPORT_MEMORY_FD_INFO_KHR"), - Self::MEMORY_FD_PROPERTIES_KHR => Some("MEMORY_FD_PROPERTIES_KHR"), - Self::MEMORY_GET_FD_INFO_KHR => Some("MEMORY_GET_FD_INFO_KHR"), - Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => { - Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR") - } - Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { - Some("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") - } - Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { - Some("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") - } - Self::D3D12_FENCE_SUBMIT_INFO_KHR => Some("D3D12_FENCE_SUBMIT_INFO_KHR"), - Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => { - Some("SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR") - } - Self::IMPORT_SEMAPHORE_FD_INFO_KHR => Some("IMPORT_SEMAPHORE_FD_INFO_KHR"), - Self::SEMAPHORE_GET_FD_INFO_KHR => Some("SEMAPHORE_GET_FD_INFO_KHR"), - Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => { - Some("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR") - } - Self::PRESENT_REGIONS_KHR => Some("PRESENT_REGIONS_KHR"), - Self::OBJECT_TABLE_CREATE_INFO_NVX => Some("OBJECT_TABLE_CREATE_INFO_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX => { - Some("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX") - } - Self::CMD_PROCESS_COMMANDS_INFO_NVX => Some("CMD_PROCESS_COMMANDS_INFO_NVX"), - Self::CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX => { - Some("CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX") - } - Self::DEVICE_GENERATED_COMMANDS_LIMITS_NVX => { - Some("DEVICE_GENERATED_COMMANDS_LIMITS_NVX") - } - Self::DEVICE_GENERATED_COMMANDS_FEATURES_NVX => { - Some("DEVICE_GENERATED_COMMANDS_FEATURES_NVX") - } - Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => { - Some("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV") - } - Self::SURFACE_CAPABILITIES_2_EXT => Some("SURFACE_CAPABILITIES_2_EXT"), - Self::DISPLAY_POWER_INFO_EXT => Some("DISPLAY_POWER_INFO_EXT"), - Self::DEVICE_EVENT_INFO_EXT => Some("DEVICE_EVENT_INFO_EXT"), - Self::DISPLAY_EVENT_INFO_EXT => Some("DISPLAY_EVENT_INFO_EXT"), - Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => Some("SWAPCHAIN_COUNTER_CREATE_INFO_EXT"), - Self::PRESENT_TIMES_INFO_GOOGLE => Some("PRESENT_TIMES_INFO_GOOGLE"), - Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => { - Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX") - } - Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => { - Some("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV") - } - Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT") - } - Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT") - } - Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT") - } - Self::HDR_METADATA_EXT => Some("HDR_METADATA_EXT"), - Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => { - Some("SHARED_PRESENT_SURFACE_CAPABILITIES_KHR") - } - Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"), - Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"), - Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => Some("FENCE_GET_WIN32_HANDLE_INFO_KHR"), - Self::IMPORT_FENCE_FD_INFO_KHR => Some("IMPORT_FENCE_FD_INFO_KHR"), - Self::FENCE_GET_FD_INFO_KHR => Some("FENCE_GET_FD_INFO_KHR"), - Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => Some("PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"), - Self::SURFACE_CAPABILITIES_2_KHR => Some("SURFACE_CAPABILITIES_2_KHR"), - Self::SURFACE_FORMAT_2_KHR => Some("SURFACE_FORMAT_2_KHR"), - Self::DISPLAY_PROPERTIES_2_KHR => Some("DISPLAY_PROPERTIES_2_KHR"), - Self::DISPLAY_PLANE_PROPERTIES_2_KHR => Some("DISPLAY_PLANE_PROPERTIES_2_KHR"), - Self::DISPLAY_MODE_PROPERTIES_2_KHR => Some("DISPLAY_MODE_PROPERTIES_2_KHR"), - Self::DISPLAY_PLANE_INFO_2_KHR => Some("DISPLAY_PLANE_INFO_2_KHR"), - Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => Some("DISPLAY_PLANE_CAPABILITIES_2_KHR"), - Self::IOS_SURFACE_CREATE_INFO_M => Some("IOS_SURFACE_CREATE_INFO_M"), - Self::MACOS_SURFACE_CREATE_INFO_M => Some("MACOS_SURFACE_CREATE_INFO_M"), - Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => Some("DEBUG_UTILS_OBJECT_NAME_INFO_EXT"), - Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => Some("DEBUG_UTILS_OBJECT_TAG_INFO_EXT"), - Self::DEBUG_UTILS_LABEL_EXT => Some("DEBUG_UTILS_LABEL_EXT"), - Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => { - Some("DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT") - } - Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => { - Some("DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT") - } - Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => { - Some("ANDROID_HARDWARE_BUFFER_USAGE_ANDROID") - } - Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => { - Some("ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID") - } - Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => { - Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID") - } - Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { - Some("IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") - } - Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { - Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") - } - Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"), - Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT") - } - Self::SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT => { - Some("SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT") - } - Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"), - Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => { - Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT") - } - Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT") - } - Self::MULTISAMPLE_PROPERTIES_EXT => Some("MULTISAMPLE_PROPERTIES_EXT"), - Self::IMAGE_FORMAT_LIST_CREATE_INFO_KHR => Some("IMAGE_FORMAT_LIST_CREATE_INFO_KHR"), - Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => { - Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT") - } - Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT") - } - Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT") - } - Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => { - Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV") - } - Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => { - Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV") - } - Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"), - Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => { - Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT") - } - Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT => { - Some("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT => { - Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT") - } - Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT") - } - Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT => { - Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT") - } - Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT => { - Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT") - } - Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT => { - Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT") - } - Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => { - Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT") - } - Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => Some("MEMORY_HOST_POINTER_PROPERTIES_EXT"), - Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT") - } - Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => { - Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD") - } - Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT") - } - Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { - Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") - } - Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"), - Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"), - Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => { - Some("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES") - } - Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"), - Self::MEMORY_DEDICATED_ALLOCATE_INFO => Some("MEMORY_DEDICATED_ALLOCATE_INFO"), - Self::MEMORY_ALLOCATE_FLAGS_INFO => Some("MEMORY_ALLOCATE_FLAGS_INFO"), - Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => { - Some("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO") - } - Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => { - Some("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO") - } - Self::DEVICE_GROUP_SUBMIT_INFO => Some("DEVICE_GROUP_SUBMIT_INFO"), - Self::DEVICE_GROUP_BIND_SPARSE_INFO => Some("DEVICE_GROUP_BIND_SPARSE_INFO"), - Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => { - Some("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO") - } - Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => { - Some("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO") - } - Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => Some("PHYSICAL_DEVICE_GROUP_PROPERTIES"), - Self::DEVICE_GROUP_DEVICE_CREATE_INFO => Some("DEVICE_GROUP_DEVICE_CREATE_INFO"), - Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => Some("BUFFER_MEMORY_REQUIREMENTS_INFO_2"), - Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => Some("IMAGE_MEMORY_REQUIREMENTS_INFO_2"), - Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => { - Some("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2") - } - Self::MEMORY_REQUIREMENTS_2 => Some("MEMORY_REQUIREMENTS_2"), - Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => Some("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"), - Self::PHYSICAL_DEVICE_FEATURES_2 => Some("PHYSICAL_DEVICE_FEATURES_2"), - Self::PHYSICAL_DEVICE_PROPERTIES_2 => Some("PHYSICAL_DEVICE_PROPERTIES_2"), - Self::FORMAT_PROPERTIES_2 => Some("FORMAT_PROPERTIES_2"), - Self::IMAGE_FORMAT_PROPERTIES_2 => Some("IMAGE_FORMAT_PROPERTIES_2"), - Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => { - Some("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2") - } - Self::QUEUE_FAMILY_PROPERTIES_2 => Some("QUEUE_FAMILY_PROPERTIES_2"), - Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => { - Some("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2") - } - Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2 => Some("SPARSE_IMAGE_FORMAT_PROPERTIES_2"), - Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => { - Some("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2") - } - Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => { - Some("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES") - } - Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => { - Some("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO") - } - Self::IMAGE_VIEW_USAGE_CREATE_INFO => Some("IMAGE_VIEW_USAGE_CREATE_INFO"), - Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => { - Some("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO") - } - Self::RENDER_PASS_MULTIVIEW_CREATE_INFO => Some("RENDER_PASS_MULTIVIEW_CREATE_INFO"), - Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES => Some("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"), - Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => { - Some("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES") - } - Self::PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES => { - Some("PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES") - } - Self::PROTECTED_SUBMIT_INFO => Some("PROTECTED_SUBMIT_INFO"), - Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => { - Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES") - } - Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => { - Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES") - } - Self::DEVICE_QUEUE_INFO_2 => Some("DEVICE_QUEUE_INFO_2"), - Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO => { - Some("SAMPLER_YCBCR_CONVERSION_CREATE_INFO") - } - Self::SAMPLER_YCBCR_CONVERSION_INFO => Some("SAMPLER_YCBCR_CONVERSION_INFO"), - Self::BIND_IMAGE_PLANE_MEMORY_INFO => Some("BIND_IMAGE_PLANE_MEMORY_INFO"), - Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => { - Some("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO") - } - Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => { - Some("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES") - } - Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => { - Some("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES") - } - Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => { - Some("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO") - } - Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => { - Some("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO") - } - Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES => Some("EXTERNAL_IMAGE_FORMAT_PROPERTIES"), - Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => { - Some("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO") - } - Self::EXTERNAL_BUFFER_PROPERTIES => Some("EXTERNAL_BUFFER_PROPERTIES"), - Self::PHYSICAL_DEVICE_ID_PROPERTIES => Some("PHYSICAL_DEVICE_ID_PROPERTIES"), - Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO => Some("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"), - Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO => Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"), - Self::EXPORT_MEMORY_ALLOCATE_INFO => Some("EXPORT_MEMORY_ALLOCATE_INFO"), - Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => { - Some("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO") - } - Self::EXTERNAL_FENCE_PROPERTIES => Some("EXTERNAL_FENCE_PROPERTIES"), - Self::EXPORT_FENCE_CREATE_INFO => Some("EXPORT_FENCE_CREATE_INFO"), - Self::EXPORT_SEMAPHORE_CREATE_INFO => Some("EXPORT_SEMAPHORE_CREATE_INFO"), - Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => { - Some("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO") - } - Self::EXTERNAL_SEMAPHORE_PROPERTIES => Some("EXTERNAL_SEMAPHORE_PROPERTIES"), - Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => { - Some("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES") - } - Self::DESCRIPTOR_SET_LAYOUT_SUPPORT => Some("DESCRIPTOR_SET_LAYOUT_SUPPORT"), - Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES => { - Some("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES") - } + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), _ => None, }; if let Some(x) = name { @@ -40574,6 +40850,767 @@ impl fmt::Display for StructureType { } } } +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40637,12 +41674,16 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for AttachmentLoadOp { +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { @@ -40652,1239 +41693,17 @@ impl fmt::Display for AttachmentLoadOp { } } } -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { +impl fmt::Display for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -41909,6 +41728,84 @@ impl fmt::Display for DynamicState { } } } +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -42349,123 +42246,6 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for AttachmentStoreOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -42480,785 +42260,21 @@ impl fmt::Display for AttachmentStoreOp { } } } -impl fmt::Display for SamplerReductionModeEXT { +impl fmt::Display for SemaphoreImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[( @@ -43268,39 +42284,20 @@ impl fmt::Display for CommandPoolResetFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { +impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), _ => None, }; if let Some(x) = name { @@ -43310,366 +42307,25 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { +impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), ]; display_flags(f, KNOWN, self.0) } @@ -43701,87 +42357,12 @@ impl fmt::Display for ColorSpaceKHR { } } } -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), _ => None, }; if let Some(x) = name { @@ -43807,25 +42388,74 @@ impl fmt::Display for SubgroupFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", ), ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SemaphoreImportFlags { +impl fmt::Display for FenceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} From 30e6c5dee70ddce326d622202cf5f3c1b4a62fb3 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 14:48:57 +0100 Subject: [PATCH 118/122] Regenerate vk.rs --- ash/src/vk.rs | 8174 ++++++++++++++++++++++++------------------------- 1 file changed, 3990 insertions(+), 4184 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 6fec190..d27fa3c 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -3131,7 +3131,7 @@ impl DeviceFnV1_0 { cmd_set_line_width: unsafe { extern "system" fn cmd_set_line_width( _command_buffer: CommandBuffer, - _line_width: c_float, + _line_width: f32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_line_width))) } @@ -3147,9 +3147,9 @@ impl DeviceFnV1_0 { cmd_set_depth_bias: unsafe { extern "system" fn cmd_set_depth_bias( _command_buffer: CommandBuffer, - _depth_bias_constant_factor: c_float, - _depth_bias_clamp: c_float, - _depth_bias_slope_factor: c_float, + _depth_bias_constant_factor: f32, + _depth_bias_clamp: f32, + _depth_bias_slope_factor: f32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias))) } @@ -3165,7 +3165,7 @@ impl DeviceFnV1_0 { cmd_set_blend_constants: unsafe { extern "system" fn cmd_set_blend_constants( _command_buffer: CommandBuffer, - _blend_constants: [c_float; 4], + _blend_constants: [f32; 4], ) -> c_void { panic!(concat!( "Unable to load ", @@ -3184,8 +3184,8 @@ impl DeviceFnV1_0 { cmd_set_depth_bounds: unsafe { extern "system" fn cmd_set_depth_bounds( _command_buffer: CommandBuffer, - _min_depth_bounds: c_float, - _max_depth_bounds: c_float, + _min_depth_bounds: f32, + _max_depth_bounds: f32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds))) } @@ -6793,27 +6793,27 @@ impl<'a> ::std::ops::Deref for ViewportBuilder<'a> { } } impl<'a> ViewportBuilder<'a> { - pub fn x(mut self, x: c_float) -> ViewportBuilder<'a> { + pub fn x(mut self, x: f32) -> ViewportBuilder<'a> { self.inner.x = x; self } - pub fn y(mut self, y: c_float) -> ViewportBuilder<'a> { + pub fn y(mut self, y: f32) -> ViewportBuilder<'a> { self.inner.y = y; self } - pub fn width(mut self, width: c_float) -> ViewportBuilder<'a> { + pub fn width(mut self, width: f32) -> ViewportBuilder<'a> { self.inner.width = width; self } - pub fn height(mut self, height: c_float) -> ViewportBuilder<'a> { + pub fn height(mut self, height: f32) -> ViewportBuilder<'a> { self.inner.height = height; self } - pub fn min_depth(mut self, min_depth: c_float) -> ViewportBuilder<'a> { + pub fn min_depth(mut self, min_depth: f32) -> ViewportBuilder<'a> { self.inner.min_depth = min_depth; self } - pub fn max_depth(mut self, max_depth: c_float) -> ViewportBuilder<'a> { + pub fn max_depth(mut self, max_depth: f32) -> ViewportBuilder<'a> { self.inner.max_depth = max_depth; self } @@ -7422,7 +7422,7 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> { } pub fn queue_priorities( mut self, - queue_priorities: &'a [c_float], + queue_priorities: &'a [f32], ) -> DeviceQueueCreateInfoBuilder<'a> { self.inner.queue_count = queue_priorities.len() as u32; self.inner.p_queue_priorities = queue_priorities.as_ptr(); @@ -10874,28 +10874,28 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { } pub fn depth_bias_constant_factor( mut self, - depth_bias_constant_factor: c_float, + depth_bias_constant_factor: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { self.inner.depth_bias_constant_factor = depth_bias_constant_factor; self } pub fn depth_bias_clamp( mut self, - depth_bias_clamp: c_float, + depth_bias_clamp: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { self.inner.depth_bias_clamp = depth_bias_clamp; self } pub fn depth_bias_slope_factor( mut self, - depth_bias_slope_factor: c_float, + depth_bias_slope_factor: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { self.inner.depth_bias_slope_factor = depth_bias_slope_factor; self } pub fn line_width( mut self, - line_width: c_float, + line_width: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { self.inner.line_width = line_width; self @@ -10974,7 +10974,7 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { } pub fn min_sample_shading( mut self, - min_sample_shading: c_float, + min_sample_shading: f32, ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { self.inner.min_sample_shading = min_sample_shading; self @@ -11168,7 +11168,7 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { } pub fn blend_constants( mut self, - blend_constants: [c_float; 4], + blend_constants: [f32; 4], ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { self.inner.blend_constants = blend_constants; self @@ -11405,14 +11405,14 @@ impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { } pub fn min_depth_bounds( mut self, - min_depth_bounds: c_float, + min_depth_bounds: f32, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { self.inner.min_depth_bounds = min_depth_bounds; self } pub fn max_depth_bounds( mut self, - max_depth_bounds: c_float, + max_depth_bounds: f32, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { self.inner.max_depth_bounds = max_depth_bounds; self @@ -11862,7 +11862,7 @@ impl<'a> SamplerCreateInfoBuilder<'a> { self.inner.address_mode_w = address_mode_w; self } - pub fn mip_lod_bias(mut self, mip_lod_bias: c_float) -> SamplerCreateInfoBuilder<'a> { + pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> SamplerCreateInfoBuilder<'a> { self.inner.mip_lod_bias = mip_lod_bias; self } @@ -11870,7 +11870,7 @@ impl<'a> SamplerCreateInfoBuilder<'a> { self.inner.anisotropy_enable = anisotropy_enable; self } - pub fn max_anisotropy(mut self, max_anisotropy: c_float) -> SamplerCreateInfoBuilder<'a> { + pub fn max_anisotropy(mut self, max_anisotropy: f32) -> SamplerCreateInfoBuilder<'a> { self.inner.max_anisotropy = max_anisotropy; self } @@ -11882,11 +11882,11 @@ impl<'a> SamplerCreateInfoBuilder<'a> { self.inner.compare_op = compare_op; self } - pub fn min_lod(mut self, min_lod: c_float) -> SamplerCreateInfoBuilder<'a> { + pub fn min_lod(mut self, min_lod: f32) -> SamplerCreateInfoBuilder<'a> { self.inner.min_lod = min_lod; self } - pub fn max_lod(mut self, max_lod: c_float) -> SamplerCreateInfoBuilder<'a> { + pub fn max_lod(mut self, max_lod: f32) -> SamplerCreateInfoBuilder<'a> { self.inner.max_lod = max_lod; self } @@ -12275,7 +12275,7 @@ impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> { } } impl<'a> ClearDepthStencilValueBuilder<'a> { - pub fn depth(mut self, depth: c_float) -> ClearDepthStencilValueBuilder<'a> { + pub fn depth(mut self, depth: f32) -> ClearDepthStencilValueBuilder<'a> { self.inner.depth = depth; self } @@ -13988,14 +13988,14 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> { } pub fn max_sampler_lod_bias( mut self, - max_sampler_lod_bias: c_float, + max_sampler_lod_bias: f32, ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.max_sampler_lod_bias = max_sampler_lod_bias; self } pub fn max_sampler_anisotropy( mut self, - max_sampler_anisotropy: c_float, + max_sampler_anisotropy: f32, ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.max_sampler_anisotropy = max_sampler_anisotropy; self @@ -14013,7 +14013,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> { } pub fn viewport_bounds_range( mut self, - viewport_bounds_range: [c_float; 2], + viewport_bounds_range: [f32; 2], ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.viewport_bounds_range = viewport_bounds_range; self @@ -14077,14 +14077,14 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> { } pub fn min_interpolation_offset( mut self, - min_interpolation_offset: c_float, + min_interpolation_offset: f32, ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.min_interpolation_offset = min_interpolation_offset; self } pub fn max_interpolation_offset( mut self, - max_interpolation_offset: c_float, + max_interpolation_offset: f32, ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.max_interpolation_offset = max_interpolation_offset; self @@ -14202,10 +14202,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> { self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics; self } - pub fn timestamp_period( - mut self, - timestamp_period: c_float, - ) -> PhysicalDeviceLimitsBuilder<'a> { + pub fn timestamp_period(mut self, timestamp_period: f32) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.timestamp_period = timestamp_period; self } @@ -14239,28 +14236,28 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> { } pub fn point_size_range( mut self, - point_size_range: [c_float; 2], + point_size_range: [f32; 2], ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.point_size_range = point_size_range; self } pub fn line_width_range( mut self, - line_width_range: [c_float; 2], + line_width_range: [f32; 2], ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.line_width_range = line_width_range; self } pub fn point_size_granularity( mut self, - point_size_granularity: c_float, + point_size_granularity: f32, ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.point_size_granularity = point_size_granularity; self } pub fn line_width_granularity( mut self, - line_width_granularity: c_float, + line_width_granularity: f32, ) -> PhysicalDeviceLimitsBuilder<'a> { self.inner.line_width_granularity = line_width_granularity; self @@ -15157,7 +15154,7 @@ impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { self.inner.transform = transform; self } - pub fn global_alpha(mut self, global_alpha: c_float) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + pub fn global_alpha(mut self, global_alpha: f32) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { self.inner.global_alpha = global_alpha; self } @@ -16334,7 +16331,7 @@ impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { self.inner.p_marker_name = marker_name.as_ptr(); self } - pub fn color(mut self, color: [c_float; 4]) -> DebugMarkerMarkerInfoEXTBuilder<'a> { + pub fn color(mut self, color: [f32; 4]) -> DebugMarkerMarkerInfoEXTBuilder<'a> { self.inner.color = color; self } @@ -21923,11 +21920,11 @@ impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> { } } impl<'a> XYColorEXTBuilder<'a> { - pub fn x(mut self, x: c_float) -> XYColorEXTBuilder<'a> { + pub fn x(mut self, x: f32) -> XYColorEXTBuilder<'a> { self.inner.x = x; self } - pub fn y(mut self, y: c_float) -> XYColorEXTBuilder<'a> { + pub fn y(mut self, y: f32) -> XYColorEXTBuilder<'a> { self.inner.y = y; self } @@ -22009,24 +22006,24 @@ impl<'a> HdrMetadataEXTBuilder<'a> { self.inner.white_point = white_point; self } - pub fn max_luminance(mut self, max_luminance: c_float) -> HdrMetadataEXTBuilder<'a> { + pub fn max_luminance(mut self, max_luminance: f32) -> HdrMetadataEXTBuilder<'a> { self.inner.max_luminance = max_luminance; self } - pub fn min_luminance(mut self, min_luminance: c_float) -> HdrMetadataEXTBuilder<'a> { + pub fn min_luminance(mut self, min_luminance: f32) -> HdrMetadataEXTBuilder<'a> { self.inner.min_luminance = min_luminance; self } pub fn max_content_light_level( mut self, - max_content_light_level: c_float, + max_content_light_level: f32, ) -> HdrMetadataEXTBuilder<'a> { self.inner.max_content_light_level = max_content_light_level; self } pub fn max_frame_average_light_level( mut self, - max_frame_average_light_level: c_float, + max_frame_average_light_level: f32, ) -> HdrMetadataEXTBuilder<'a> { self.inner.max_frame_average_light_level = max_frame_average_light_level; self @@ -22287,12 +22284,77 @@ impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { } } } +impl MacOSSurfaceCreateInfoMVK { + pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + MacOSSurfaceCreateInfoMVKBuilder { + inner: MacOSSurfaceCreateInfoMVK::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { + inner: MacOSSurfaceCreateInfoMVK, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { + type Target = MacOSSurfaceCreateInfoMVK; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { + pub fn flags( + mut self, + flags: MacOSSurfaceCreateFlagsMVK, + ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn view(mut self, view: &'a c_void) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + self.inner.p_view = view; + self + } + pub fn build(self) -> MacOSSurfaceCreateInfoMVK { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Default, Debug)] pub struct ViewportWScalingNV { pub xcoeff: f32, pub ycoeff: f32, } +impl ViewportWScalingNV { + pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> { + ViewportWScalingNVBuilder { + inner: ViewportWScalingNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct ViewportWScalingNVBuilder<'a> { + inner: ViewportWScalingNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> { + type Target = ViewportWScalingNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ViewportWScalingNVBuilder<'a> { + pub fn xcoeff(mut self, xcoeff: f32) -> ViewportWScalingNVBuilder<'a> { + self.inner.xcoeff = xcoeff; + self + } + pub fn ycoeff(mut self, ycoeff: f32) -> ViewportWScalingNVBuilder<'a> { + self.inner.ycoeff = ycoeff; + self + } + pub fn build(self) -> ViewportWScalingNV { + self.inner + } +} #[repr(C)] #[derive(Copy, Clone, Debug)] pub struct PipelineViewportWScalingStateCreateInfoNV { @@ -24450,11 +24512,11 @@ impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> { } } impl<'a> SampleLocationEXTBuilder<'a> { - pub fn x(mut self, x: c_float) -> SampleLocationEXTBuilder<'a> { + pub fn x(mut self, x: f32) -> SampleLocationEXTBuilder<'a> { self.inner.x = x; self } - pub fn y(mut self, y: c_float) -> SampleLocationEXTBuilder<'a> { + pub fn y(mut self, y: f32) -> SampleLocationEXTBuilder<'a> { self.inner.y = y; self } @@ -24789,7 +24851,7 @@ impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { } pub fn sample_location_coordinate_range( mut self, - sample_location_coordinate_range: [c_float; 2], + sample_location_coordinate_range: [f32; 2], ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { self.inner.sample_location_coordinate_range = sample_location_coordinate_range; self @@ -25173,7 +25235,7 @@ impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { } pub fn coverage_modulation_table( mut self, - coverage_modulation_table: &'a [c_float], + coverage_modulation_table: &'a [f32], ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as u32; self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr(); @@ -25910,7 +25972,7 @@ impl<'a> DebugUtilsLabelEXTBuilder<'a> { self.inner.p_label_name = label_name.as_ptr(); self } - pub fn color(mut self, color: [c_float; 4]) -> DebugUtilsLabelEXTBuilder<'a> { + pub fn color(mut self, color: [f32; 4]) -> DebugUtilsLabelEXTBuilder<'a> { self.inner.color = color; self } @@ -26324,14 +26386,14 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationProperties impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { pub fn primitive_overestimation_size( mut self, - primitive_overestimation_size: c_float, + primitive_overestimation_size: f32, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { self.inner.primitive_overestimation_size = primitive_overestimation_size; self } pub fn max_extra_primitive_overestimation_size( mut self, - max_extra_primitive_overestimation_size: c_float, + max_extra_primitive_overestimation_size: f32, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { self.inner.max_extra_primitive_overestimation_size = max_extra_primitive_overestimation_size; @@ -26339,7 +26401,7 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { } pub fn extra_primitive_overestimation_size_granularity( mut self, - extra_primitive_overestimation_size_granularity: c_float, + extra_primitive_overestimation_size_granularity: f32, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { self.inner.extra_primitive_overestimation_size_granularity = extra_primitive_overestimation_size_granularity; @@ -26612,7 +26674,7 @@ impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { } pub fn extra_primitive_overestimation_size( mut self, - extra_primitive_overestimation_size: c_float, + extra_primitive_overestimation_size: f32, ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size; self @@ -30073,62 +30135,111 @@ impl ::std::clone::Clone for KhrSurfaceFn { } } impl KhrSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSurfaceFn { + KhrSurfaceFn { destroy_surface_khr: unsafe { + extern "system" fn destroy_surface_khr( + _instance: Instance, + _surface: SurfaceKHR, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(destroy_surface_khr))) + } let raw_name = stringify!(vkDestroySurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_support_khr: unsafe { + extern "system" fn get_physical_device_surface_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _surface: SurfaceKHR, + _p_supported: *mut Bool32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_support_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_capabilities_khr: unsafe { + extern "system" fn get_physical_device_surface_capabilities_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_formats_khr: unsafe { + extern "system" fn get_physical_device_surface_formats_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormatKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_formats_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormatsKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_formats_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_present_modes_khr: unsafe { + extern "system" fn get_physical_device_surface_present_modes_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_present_mode_count: *mut u32, + _p_present_modes: *mut PresentModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_present_modes_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_present_modes_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn destroy_surface_khr( @@ -30228,98 +30339,189 @@ impl ::std::clone::Clone for KhrSwapchainFn { } } impl KhrSwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSwapchainFn { + KhrSwapchainFn { create_swapchain_khr: unsafe { + extern "system" fn create_swapchain_khr( + _device: Device, + _p_create_info: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchain: *mut SwapchainKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_swapchain_khr))) + } let raw_name = stringify!(vkCreateSwapchainKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_swapchain_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_swapchain_khr: unsafe { + extern "system" fn destroy_swapchain_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_swapchain_khr) + )) + } let raw_name = stringify!(vkDestroySwapchainKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_swapchain_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_swapchain_images_khr: unsafe { + extern "system" fn get_swapchain_images_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_swapchain_image_count: *mut u32, + _p_swapchain_images: *mut Image, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_images_khr) + )) + } let raw_name = stringify!(vkGetSwapchainImagesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_images_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_next_image_khr: unsafe { + extern "system" fn acquire_next_image_khr( + _device: Device, + _swapchain: SwapchainKHR, + _timeout: u64, + _semaphore: Semaphore, + _fence: Fence, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image_khr) + )) + } let raw_name = stringify!(vkAcquireNextImageKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_next_image_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_present_khr: unsafe { + extern "system" fn queue_present_khr( + _queue: Queue, + _p_present_info: *const PresentInfoKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_present_khr))) + } let raw_name = stringify!(vkQueuePresentKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_present_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_group_present_capabilities_khr: unsafe { + extern "system" fn get_device_group_present_capabilities_khr( + _device: Device, + _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_present_capabilities_khr) + )) + } let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_group_surface_present_modes_khr: unsafe { + extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes_khr) + )) + } let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_present_rectangles_khr: unsafe { + extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_present_rectangles_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_next_image2_khr: unsafe { + extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) + } let raw_name = stringify!(vkAcquireNextImage2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_swapchain_khr( @@ -30534,80 +30736,157 @@ impl ::std::clone::Clone for KhrDisplayFn { } } impl KhrDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDisplayFn { + KhrDisplayFn { get_physical_device_display_properties_khr: unsafe { + extern "system" fn get_physical_device_display_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_properties_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_display_plane_properties_khr: unsafe { + extern "system" fn get_physical_device_display_plane_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlanePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_plane_properties_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_plane_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_plane_supported_displays_khr: unsafe { + extern "system" fn get_display_plane_supported_displays_khr( + _physical_device: PhysicalDevice, + _plane_index: u32, + _p_display_count: *mut u32, + _p_displays: *mut DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_supported_displays_khr) + )) + } let raw_name = stringify!(vkGetDisplayPlaneSupportedDisplaysKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_plane_supported_displays_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_mode_properties_khr: unsafe { + extern "system" fn get_display_mode_properties_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_mode_properties_khr) + )) + } let raw_name = stringify!(vkGetDisplayModePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_mode_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_display_mode_khr: unsafe { + extern "system" fn create_display_mode_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_create_info: *const DisplayModeCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_mode: *mut DisplayModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_display_mode_khr) + )) + } let raw_name = stringify!(vkCreateDisplayModeKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_display_mode_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_plane_capabilities_khr: unsafe { + extern "system" fn get_display_plane_capabilities_khr( + _physical_device: PhysicalDevice, + _mode: DisplayModeKHR, + _plane_index: u32, + _p_capabilities: *mut DisplayPlaneCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_capabilities_khr) + )) + } let raw_name = stringify!(vkGetDisplayPlaneCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_plane_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_display_plane_surface_khr: unsafe { + extern "system" fn create_display_plane_surface_khr( + _instance: Instance, + _p_create_info: *const DisplaySurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_display_plane_surface_khr) + )) + } let raw_name = stringify!(vkCreateDisplayPlaneSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_display_plane_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_display_properties_khr( @@ -30731,26 +31010,33 @@ impl ::std::clone::Clone for KhrDisplaySwapchainFn { } } impl KhrDisplaySwapchainFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDisplaySwapchainFn { + KhrDisplaySwapchainFn { create_shared_swapchains_khr: unsafe { + extern "system" fn create_shared_swapchains_khr( + _device: Device, + _swapchain_count: u32, + _p_create_infos: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchains: *mut SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_shared_swapchains_khr) + )) + } let raw_name = stringify!(vkCreateSharedSwapchainsKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_shared_swapchains_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_shared_swapchains_khr( @@ -30805,35 +31091,53 @@ impl ::std::clone::Clone for KhrXlibSurfaceFn { } } impl KhrXlibSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrXlibSurfaceFn { + KhrXlibSurfaceFn { create_xlib_surface_khr: unsafe { + extern "system" fn create_xlib_surface_khr( + _instance: Instance, + _p_create_info: *const XlibSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_xlib_surface_khr) + )) + } let raw_name = stringify!(vkCreateXlibSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_xlib_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_xlib_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_xlib_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _dpy: *mut Display, + _visual_id: VisualID, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_xlib_presentation_support_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceXlibPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_xlib_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_xlib_surface_khr( @@ -30891,35 +31195,53 @@ impl ::std::clone::Clone for KhrXcbSurfaceFn { } } impl KhrXcbSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrXcbSurfaceFn { + KhrXcbSurfaceFn { create_xcb_surface_khr: unsafe { + extern "system" fn create_xcb_surface_khr( + _instance: Instance, + _p_create_info: *const XcbSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_xcb_surface_khr) + )) + } let raw_name = stringify!(vkCreateXcbSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_xcb_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_xcb_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_xcb_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _connection: *mut xcb_connection_t, + _visual_id: xcb_visualid_t, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_xcb_presentation_support_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceXcbPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_xcb_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_xcb_surface_khr( @@ -30977,35 +31299,52 @@ impl ::std::clone::Clone for KhrWaylandSurfaceFn { } } impl KhrWaylandSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrWaylandSurfaceFn { + KhrWaylandSurfaceFn { create_wayland_surface_khr: unsafe { + extern "system" fn create_wayland_surface_khr( + _instance: Instance, + _p_create_info: *const WaylandSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_wayland_surface_khr) + )) + } let raw_name = stringify!(vkCreateWaylandSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_wayland_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_wayland_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_wayland_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _display: *mut wl_display, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_wayland_presentation_support_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceWaylandPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_wayland_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_wayland_surface_khr( @@ -31060,35 +31399,52 @@ impl ::std::clone::Clone for KhrMirSurfaceFn { } } impl KhrMirSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMirSurfaceFn { + KhrMirSurfaceFn { create_mir_surface_khr: unsafe { + extern "system" fn create_mir_surface_khr( + _instance: Instance, + _p_create_info: *const MirSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_mir_surface_khr) + )) + } let raw_name = stringify!(vkCreateMirSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_mir_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_mir_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_mir_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _connection: *mut MirConnection, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_mir_presentation_support_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceMirPresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_mir_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_mir_surface_khr( @@ -31136,26 +31492,32 @@ impl ::std::clone::Clone for KhrAndroidSurfaceFn { } } impl KhrAndroidSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrAndroidSurfaceFn { + KhrAndroidSurfaceFn { create_android_surface_khr: unsafe { + extern "system" fn create_android_surface_khr( + _instance: Instance, + _p_create_info: *const AndroidSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_android_surface_khr) + )) + } let raw_name = stringify!(vkCreateAndroidSurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_android_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_android_surface_khr( @@ -31194,35 +31556,51 @@ impl ::std::clone::Clone for KhrWin32SurfaceFn { } } impl KhrWin32SurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrWin32SurfaceFn { + KhrWin32SurfaceFn { create_win32_surface_khr: unsafe { + extern "system" fn create_win32_surface_khr( + _instance: Instance, + _p_create_info: *const Win32SurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_win32_surface_khr) + )) + } let raw_name = stringify!(vkCreateWin32SurfaceKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_win32_surface_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_win32_presentation_support_khr: unsafe { + extern "system" fn get_physical_device_win32_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_win32_presentation_support_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceWin32PresentationSupportKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_win32_presentation_support_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_win32_surface_khr( @@ -31283,44 +31661,76 @@ impl ::std::clone::Clone for AndroidNativeBufferFn { } } impl AndroidNativeBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AndroidNativeBufferFn { + AndroidNativeBufferFn { get_swapchain_gralloc_usage_android: unsafe { + extern "system" fn get_swapchain_gralloc_usage_android( + _device: Device, + _format: Format, + _image_usage: ImageUsageFlags, + _gralloc_usage: *mut c_int, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_gralloc_usage_android) + )) + } let raw_name = stringify!(vkGetSwapchainGrallocUsageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_gralloc_usage_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_image_android: unsafe { + extern "system" fn acquire_image_android( + _device: Device, + _image: Image, + _native_fence_fd: c_int, + _semaphore: Semaphore, + _fence: Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_image_android) + )) + } let raw_name = stringify!(vkAcquireImageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_image_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_signal_release_image_android: unsafe { + extern "system" fn queue_signal_release_image_android( + _queue: Queue, + _wait_semaphore_count: u32, + _p_wait_semaphores: *const Semaphore, + _image: Image, + _p_native_fence_fd: *mut c_int, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(queue_signal_release_image_android) + )) + } let raw_name = stringify!(vkQueueSignalReleaseImageANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_signal_release_image_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_swapchain_gralloc_usage_android( @@ -31399,44 +31809,77 @@ impl ::std::clone::Clone for ExtDebugReportFn { } } impl ExtDebugReportFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDebugReportFn { + ExtDebugReportFn { create_debug_report_callback_ext: unsafe { + extern "system" fn create_debug_report_callback_ext( + _instance: Instance, + _p_create_info: *const DebugReportCallbackCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_callback: *mut DebugReportCallbackEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_debug_report_callback_ext) + )) + } let raw_name = stringify!(vkCreateDebugReportCallbackEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_debug_report_callback_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_debug_report_callback_ext: unsafe { + extern "system" fn destroy_debug_report_callback_ext( + _instance: Instance, + _callback: DebugReportCallbackEXT, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_debug_report_callback_ext) + )) + } let raw_name = stringify!(vkDestroyDebugReportCallbackEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_debug_report_callback_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, debug_report_message_ext: unsafe { + extern "system" fn debug_report_message_ext( + _instance: Instance, + _flags: DebugReportFlagsEXT, + _object_type: DebugReportObjectTypeEXT, + _object: u64, + _location: usize, + _message_code: i32, + _p_layer_prefix: *const c_char, + _p_message: *const c_char, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(debug_report_message_ext) + )) + } let raw_name = stringify!(vkDebugReportMessageEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + debug_report_message_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_debug_report_callback_ext( @@ -31508,17 +31951,11 @@ impl ::std::clone::Clone for NvGlslShaderFn { } } impl NvGlslShaderFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvGlslShaderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvGlslShaderFn {} } } #[doc = "Generated from \'VK_NV_glsl_shader\'"] @@ -31534,17 +31971,11 @@ impl ::std::clone::Clone for ExtDepthRangeUnrestrictedFn { } } impl ExtDepthRangeUnrestrictedFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDepthRangeUnrestrictedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtDepthRangeUnrestrictedFn {} } } pub struct KhrSamplerMirrorClampToEdgeFn {} @@ -31556,17 +31987,11 @@ impl ::std::clone::Clone for KhrSamplerMirrorClampToEdgeFn { } } impl KhrSamplerMirrorClampToEdgeFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSamplerMirrorClampToEdgeFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrSamplerMirrorClampToEdgeFn {} } } pub struct ImgFilterCubicFn {} @@ -31578,17 +32003,11 @@ impl ::std::clone::Clone for ImgFilterCubicFn { } } impl ImgFilterCubicFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgFilterCubicFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgFilterCubicFn {} } } #[doc = "Generated from \'VK_IMG_filter_cubic\'"] @@ -31608,17 +32027,11 @@ impl ::std::clone::Clone for AmdExtension17Fn { } } impl AmdExtension17Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension17Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension17Fn {} } } pub struct AmdExtension18Fn {} @@ -31630,17 +32043,11 @@ impl ::std::clone::Clone for AmdExtension18Fn { } } impl AmdExtension18Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension18Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension18Fn {} } } pub struct AmdRasterizationOrderFn {} @@ -31652,17 +32059,11 @@ impl ::std::clone::Clone for AmdRasterizationOrderFn { } } impl AmdRasterizationOrderFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdRasterizationOrderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdRasterizationOrderFn {} } } #[doc = "Generated from \'VK_AMD_rasterization_order\'"] @@ -31679,17 +32080,11 @@ impl ::std::clone::Clone for AmdExtension20Fn { } } impl AmdExtension20Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension20Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension20Fn {} } } pub struct AmdShaderTrinaryMinmaxFn {} @@ -31701,17 +32096,11 @@ impl ::std::clone::Clone for AmdShaderTrinaryMinmaxFn { } } impl AmdShaderTrinaryMinmaxFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderTrinaryMinmaxFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderTrinaryMinmaxFn {} } } pub struct AmdShaderExplicitVertexParameterFn {} @@ -31723,17 +32112,11 @@ impl ::std::clone::Clone for AmdShaderExplicitVertexParameterFn { } } impl AmdShaderExplicitVertexParameterFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderExplicitVertexParameterFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderExplicitVertexParameterFn {} } } pub struct ExtDebugMarkerFn { @@ -31767,62 +32150,105 @@ impl ::std::clone::Clone for ExtDebugMarkerFn { } } impl ExtDebugMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDebugMarkerFn { + ExtDebugMarkerFn { debug_marker_set_object_tag_ext: unsafe { + extern "system" fn debug_marker_set_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugMarkerObjectTagInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(debug_marker_set_object_tag_ext) + )) + } let raw_name = stringify!(vkDebugMarkerSetObjectTagEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + debug_marker_set_object_tag_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, debug_marker_set_object_name_ext: unsafe { + extern "system" fn debug_marker_set_object_name_ext( + _device: Device, + _p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(debug_marker_set_object_name_ext) + )) + } let raw_name = stringify!(vkDebugMarkerSetObjectNameEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + debug_marker_set_object_name_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_debug_marker_begin_ext: unsafe { + extern "system" fn cmd_debug_marker_begin_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_begin_ext) + )) + } let raw_name = stringify!(vkCmdDebugMarkerBeginEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_debug_marker_begin_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_debug_marker_end_ext: unsafe { + extern "system" fn cmd_debug_marker_end_ext( + _command_buffer: CommandBuffer, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_end_ext) + )) + } let raw_name = stringify!(vkCmdDebugMarkerEndEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_debug_marker_end_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_debug_marker_insert_ext: unsafe { + extern "system" fn cmd_debug_marker_insert_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_insert_ext) + )) + } let raw_name = stringify!(vkCmdDebugMarkerInsertEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_debug_marker_insert_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn debug_marker_set_object_tag_ext( @@ -31878,17 +32304,11 @@ impl ::std::clone::Clone for AmdExtension24Fn { } } impl AmdExtension24Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension24Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension24Fn {} } } pub struct AmdExtension25Fn {} @@ -31900,17 +32320,11 @@ impl ::std::clone::Clone for AmdExtension25Fn { } } impl AmdExtension25Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension25Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension25Fn {} } } pub struct AmdGcnShaderFn {} @@ -31922,17 +32336,11 @@ impl ::std::clone::Clone for AmdGcnShaderFn { } } impl AmdGcnShaderFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdGcnShaderFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdGcnShaderFn {} } } pub struct NvDedicatedAllocationFn {} @@ -31944,17 +32352,11 @@ impl ::std::clone::Clone for NvDedicatedAllocationFn { } } impl NvDedicatedAllocationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvDedicatedAllocationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvDedicatedAllocationFn {} } } #[doc = "Generated from \'VK_NV_dedicated_allocation\'"] @@ -31978,17 +32380,11 @@ impl ::std::clone::Clone for ExtExtension28Fn { } } impl ExtExtension28Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension28Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension28Fn {} } } pub struct NvxExtension29Fn {} @@ -32000,17 +32396,11 @@ impl ::std::clone::Clone for NvxExtension29Fn { } } impl NvxExtension29Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension29Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension29Fn {} } } pub struct NvxExtension30Fn {} @@ -32022,17 +32412,11 @@ impl ::std::clone::Clone for NvxExtension30Fn { } } impl NvxExtension30Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension30Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension30Fn {} } } pub struct NvxExtension31Fn {} @@ -32044,17 +32428,11 @@ impl ::std::clone::Clone for NvxExtension31Fn { } } impl NvxExtension31Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension31Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension31Fn {} } } pub struct AmdExtension32Fn {} @@ -32066,17 +32444,11 @@ impl ::std::clone::Clone for AmdExtension32Fn { } } impl AmdExtension32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension32Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension32Fn {} } } pub struct AmdExtension33Fn {} @@ -32088,17 +32460,11 @@ impl ::std::clone::Clone for AmdExtension33Fn { } } impl AmdExtension33Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension33Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension33Fn {} } } pub struct AmdDrawIndirectCountFn { @@ -32132,35 +32498,59 @@ impl ::std::clone::Clone for AmdDrawIndirectCountFn { } } impl AmdDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdDrawIndirectCountFn { + AmdDrawIndirectCountFn { cmd_draw_indirect_count_amd: unsafe { + extern "system" fn cmd_draw_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_amd) + )) + } let raw_name = stringify!(vkCmdDrawIndirectCountAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indirect_count_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw_indexed_indirect_count_amd: unsafe { + extern "system" fn cmd_draw_indexed_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count_amd) + )) + } let raw_name = stringify!(vkCmdDrawIndexedIndirectCountAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indexed_indirect_count_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_draw_indirect_count_amd( @@ -32213,17 +32603,11 @@ impl ::std::clone::Clone for AmdExtension35Fn { } } impl AmdExtension35Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension35Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension35Fn {} } } pub struct AmdNegativeViewportHeightFn {} @@ -32235,17 +32619,11 @@ impl ::std::clone::Clone for AmdNegativeViewportHeightFn { } } impl AmdNegativeViewportHeightFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdNegativeViewportHeightFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdNegativeViewportHeightFn {} } } pub struct AmdGpuShaderHalfFloatFn {} @@ -32257,17 +32635,11 @@ impl ::std::clone::Clone for AmdGpuShaderHalfFloatFn { } } impl AmdGpuShaderHalfFloatFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdGpuShaderHalfFloatFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdGpuShaderHalfFloatFn {} } } pub struct AmdShaderBallotFn {} @@ -32279,17 +32651,11 @@ impl ::std::clone::Clone for AmdShaderBallotFn { } } impl AmdShaderBallotFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderBallotFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderBallotFn {} } } pub struct AmdExtension39Fn {} @@ -32301,17 +32667,11 @@ impl ::std::clone::Clone for AmdExtension39Fn { } } impl AmdExtension39Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension39Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension39Fn {} } } pub struct AmdExtension40Fn {} @@ -32323,17 +32683,11 @@ impl ::std::clone::Clone for AmdExtension40Fn { } } impl AmdExtension40Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension40Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension40Fn {} } } pub struct AmdExtension41Fn {} @@ -32345,17 +32699,11 @@ impl ::std::clone::Clone for AmdExtension41Fn { } } impl AmdExtension41Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension41Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension41Fn {} } } pub struct AmdTextureGatherBiasLodFn {} @@ -32367,17 +32715,11 @@ impl ::std::clone::Clone for AmdTextureGatherBiasLodFn { } } impl AmdTextureGatherBiasLodFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdTextureGatherBiasLodFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdTextureGatherBiasLodFn {} } } #[doc = "Generated from \'VK_AMD_texture_gather_bias_lod\'"] @@ -32404,26 +32746,31 @@ impl ::std::clone::Clone for AmdShaderInfoFn { } } impl AmdShaderInfoFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderInfoFn { + AmdShaderInfoFn { get_shader_info_amd: unsafe { + extern "system" fn get_shader_info_amd( + _device: Device, + _pipeline: Pipeline, + _shader_stage: ShaderStageFlags, + _info_type: ShaderInfoTypeAMD, + _p_info_size: *mut usize, + _p_info: *mut c_void, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_shader_info_amd))) + } let raw_name = stringify!(vkGetShaderInfoAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_shader_info_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_shader_info_amd( @@ -32454,17 +32801,11 @@ impl ::std::clone::Clone for AmdExtension44Fn { } } impl AmdExtension44Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension44Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension44Fn {} } } pub struct AmdExtension45Fn {} @@ -32476,17 +32817,11 @@ impl ::std::clone::Clone for AmdExtension45Fn { } } impl AmdExtension45Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension45Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension45Fn {} } } pub struct AmdExtension46Fn {} @@ -32498,17 +32833,11 @@ impl ::std::clone::Clone for AmdExtension46Fn { } } impl AmdExtension46Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension46Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension46Fn {} } } pub struct AmdShaderImageLoadStoreLodFn {} @@ -32520,17 +32849,11 @@ impl ::std::clone::Clone for AmdShaderImageLoadStoreLodFn { } } impl AmdShaderImageLoadStoreLodFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderImageLoadStoreLodFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderImageLoadStoreLodFn {} } } pub struct NvxExtension48Fn {} @@ -32542,17 +32865,11 @@ impl ::std::clone::Clone for NvxExtension48Fn { } } impl NvxExtension48Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension48Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension48Fn {} } } pub struct GoogleExtension49Fn {} @@ -32564,17 +32881,11 @@ impl ::std::clone::Clone for GoogleExtension49Fn { } } impl GoogleExtension49Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension49Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension49Fn {} } } pub struct GoogleExtension50Fn {} @@ -32586,17 +32897,11 @@ impl ::std::clone::Clone for GoogleExtension50Fn { } } impl GoogleExtension50Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension50Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension50Fn {} } } pub struct NvxExtension51Fn {} @@ -32608,17 +32913,11 @@ impl ::std::clone::Clone for NvxExtension51Fn { } } impl NvxExtension51Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension51Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension51Fn {} } } pub struct NvxExtension52Fn {} @@ -32630,17 +32929,11 @@ impl ::std::clone::Clone for NvxExtension52Fn { } } impl NvxExtension52Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxExtension52Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxExtension52Fn {} } } pub struct NvExtension53Fn {} @@ -32652,17 +32945,11 @@ impl ::std::clone::Clone for NvExtension53Fn { } } impl NvExtension53Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension53Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension53Fn {} } } pub struct KhrMultiviewFn {} @@ -32674,17 +32961,11 @@ impl ::std::clone::Clone for KhrMultiviewFn { } } impl KhrMultiviewFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMultiviewFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMultiviewFn {} } } pub struct ImgFormatPvrtcFn {} @@ -32696,17 +32977,11 @@ impl ::std::clone::Clone for ImgFormatPvrtcFn { } } impl ImgFormatPvrtcFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgFormatPvrtcFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgFormatPvrtcFn {} } } #[doc = "Generated from \'VK_IMG_format_pvrtc\'"] @@ -32753,26 +33028,36 @@ impl ::std::clone::Clone for NvExternalMemoryCapabilitiesFn { } } impl NvExternalMemoryCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryCapabilitiesFn { + NvExternalMemoryCapabilitiesFn { get_physical_device_external_image_format_properties_nv: unsafe { + extern "system" fn get_physical_device_external_image_format_properties_nv( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _tiling: ImageTiling, + _usage: ImageUsageFlags, + _flags: ImageCreateFlags, + _external_handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_image_format_properties_nv) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_external_image_format_properties_nv + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_external_image_format_properties_nv( @@ -32807,17 +33092,11 @@ impl ::std::clone::Clone for NvExternalMemoryFn { } } impl NvExternalMemoryFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExternalMemoryFn {} } } #[doc = "Generated from \'VK_NV_external_memory\'"] @@ -32846,26 +33125,32 @@ impl ::std::clone::Clone for NvExternalMemoryWin32Fn { } } impl NvExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExternalMemoryWin32Fn { + NvExternalMemoryWin32Fn { get_memory_win32_handle_nv: unsafe { + extern "system" fn get_memory_win32_handle_nv( + _device: Device, + _memory: DeviceMemory, + _handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_nv) + )) + } let raw_name = stringify!(vkGetMemoryWin32HandleNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_win32_handle_nv + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_win32_handle_nv( @@ -32895,17 +33180,11 @@ impl ::std::clone::Clone for NvWin32KeyedMutexFn { } } impl NvWin32KeyedMutexFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvWin32KeyedMutexFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvWin32KeyedMutexFn {} } } #[doc = "Generated from \'VK_NV_win32_keyed_mutex\'"] @@ -32921,17 +33200,11 @@ impl ::std::clone::Clone for KhrGetPhysicalDeviceProperties2Fn { } } impl KhrGetPhysicalDeviceProperties2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetPhysicalDeviceProperties2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrGetPhysicalDeviceProperties2Fn {} } } pub struct KhrDeviceGroupFn { get_device_group_present_capabilities_khr : extern "system" fn ( device : Device , p_device_group_present_capabilities : *mut DeviceGroupPresentCapabilitiesKHR , ) -> Result , get_device_group_surface_present_modes_khr : extern "system" fn ( device : Device , surface : SurfaceKHR , p_modes : *mut DeviceGroupPresentModeFlagsKHR , ) -> Result , get_physical_device_present_rectangles_khr : extern "system" fn ( physical_device : PhysicalDevice , surface : SurfaceKHR , p_rect_count : *mut u32 , p_rects : *mut Rect2D , ) -> Result , acquire_next_image2_khr : extern "system" fn ( device : Device , p_acquire_info : *const AcquireNextImageInfoKHR , p_image_index : *mut u32 , ) -> Result , } @@ -32951,53 +33224,91 @@ impl ::std::clone::Clone for KhrDeviceGroupFn { } } impl KhrDeviceGroupFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDeviceGroupFn { + KhrDeviceGroupFn { get_device_group_present_capabilities_khr: unsafe { + extern "system" fn get_device_group_present_capabilities_khr( + _device: Device, + _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_present_capabilities_khr) + )) + } let raw_name = stringify!(vkGetDeviceGroupPresentCapabilitiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_device_group_surface_present_modes_khr: unsafe { + extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes_khr) + )) + } let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_present_rectangles_khr: unsafe { + extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_present_rectangles_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDevicePresentRectanglesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, acquire_next_image2_khr: unsafe { + extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) + } let raw_name = stringify!(vkAcquireNextImage2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_device_group_present_capabilities_khr( @@ -33050,17 +33361,11 @@ impl ::std::clone::Clone for ExtValidationFlagsFn { } } impl ExtValidationFlagsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtValidationFlagsFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtValidationFlagsFn {} } } #[doc = "Generated from \'VK_EXT_validation_flags\'"] @@ -33085,26 +33390,29 @@ impl ::std::clone::Clone for NnViSurfaceFn { } } impl NnViSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NnViSurfaceFn { + NnViSurfaceFn { create_vi_surface_nn: unsafe { + extern "system" fn create_vi_surface_nn( + _instance: Instance, + _p_create_info: *const ViSurfaceCreateInfoNN, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_vi_surface_nn))) + } let raw_name = stringify!(vkCreateViSurfaceNN); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_vi_surface_nn + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_vi_surface_nn( @@ -33130,17 +33438,11 @@ impl ::std::clone::Clone for KhrShaderDrawParametersFn { } } impl KhrShaderDrawParametersFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrShaderDrawParametersFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrShaderDrawParametersFn {} } } pub struct ExtShaderSubgroupBallotFn {} @@ -33152,17 +33454,11 @@ impl ::std::clone::Clone for ExtShaderSubgroupBallotFn { } } impl ExtShaderSubgroupBallotFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderSubgroupBallotFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderSubgroupBallotFn {} } } pub struct ExtShaderSubgroupVoteFn {} @@ -33174,17 +33470,11 @@ impl ::std::clone::Clone for ExtShaderSubgroupVoteFn { } } impl ExtShaderSubgroupVoteFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderSubgroupVoteFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderSubgroupVoteFn {} } } pub struct ArmExtension01Fn {} @@ -33196,17 +33486,11 @@ impl ::std::clone::Clone for ArmExtension01Fn { } } impl ArmExtension01Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ArmExtension01Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ArmExtension01Fn {} } } pub struct ArmExtension02Fn {} @@ -33218,17 +33502,11 @@ impl ::std::clone::Clone for ArmExtension02Fn { } } impl ArmExtension02Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ArmExtension02Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ArmExtension02Fn {} } } pub struct ImgExtension69Fn {} @@ -33240,17 +33518,11 @@ impl ::std::clone::Clone for ImgExtension69Fn { } } impl ImgExtension69Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension69Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension69Fn {} } } pub struct KhrMaintenance1Fn {} @@ -33262,17 +33534,11 @@ impl ::std::clone::Clone for KhrMaintenance1Fn { } } impl KhrMaintenance1Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMaintenance1Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMaintenance1Fn {} } } pub struct KhrDeviceGroupCreationFn {} @@ -33284,17 +33550,11 @@ impl ::std::clone::Clone for KhrDeviceGroupCreationFn { } } impl KhrDeviceGroupCreationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDeviceGroupCreationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrDeviceGroupCreationFn {} } } pub struct KhrExternalMemoryCapabilitiesFn {} @@ -33306,17 +33566,11 @@ impl ::std::clone::Clone for KhrExternalMemoryCapabilitiesFn { } } impl KhrExternalMemoryCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalMemoryCapabilitiesFn {} } } pub struct KhrExternalMemoryFn {} @@ -33328,17 +33582,11 @@ impl ::std::clone::Clone for KhrExternalMemoryFn { } } impl KhrExternalMemoryFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalMemoryFn {} } } pub struct KhrExternalMemoryWin32Fn { @@ -33367,35 +33615,52 @@ impl ::std::clone::Clone for KhrExternalMemoryWin32Fn { } } impl KhrExternalMemoryWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryWin32Fn { + KhrExternalMemoryWin32Fn { get_memory_win32_handle_khr: unsafe { + extern "system" fn get_memory_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_khr) + )) + } let raw_name = stringify!(vkGetMemoryWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_memory_win32_handle_properties_khr: unsafe { + extern "system" fn get_memory_win32_handle_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _handle: HANDLE, + _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_properties_khr) + )) + } let raw_name = stringify!(vkGetMemoryWin32HandlePropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_win32_handle_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_win32_handle_khr( @@ -33462,35 +33727,49 @@ impl ::std::clone::Clone for KhrExternalMemoryFdFn { } } impl KhrExternalMemoryFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalMemoryFdFn { + KhrExternalMemoryFdFn { get_memory_fd_khr: unsafe { + extern "system" fn get_memory_fd_khr( + _device: Device, + _p_get_fd_info: *const MemoryGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_memory_fd_khr))) + } let raw_name = stringify!(vkGetMemoryFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_memory_fd_properties_khr: unsafe { + extern "system" fn get_memory_fd_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _fd: c_int, + _p_memory_fd_properties: *mut MemoryFdPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_fd_properties_khr) + )) + } let raw_name = stringify!(vkGetMemoryFdPropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_fd_properties_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_fd_khr( @@ -33532,17 +33811,11 @@ impl ::std::clone::Clone for KhrWin32KeyedMutexFn { } } impl KhrWin32KeyedMutexFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrWin32KeyedMutexFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrWin32KeyedMutexFn {} } } #[doc = "Generated from \'VK_KHR_win32_keyed_mutex\'"] @@ -33558,17 +33831,11 @@ impl ::std::clone::Clone for KhrExternalSemaphoreCapabilitiesFn { } } impl KhrExternalSemaphoreCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalSemaphoreCapabilitiesFn {} } } pub struct KhrExternalSemaphoreFn {} @@ -33580,17 +33847,11 @@ impl ::std::clone::Clone for KhrExternalSemaphoreFn { } } impl KhrExternalSemaphoreFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalSemaphoreFn {} } } pub struct KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_import_semaphore_win32_handle_info : *const ImportSemaphoreWin32HandleInfoKHR , ) -> Result , get_semaphore_win32_handle_khr : extern "system" fn ( device : Device , p_get_win32_handle_info : *const SemaphoreGetWin32HandleInfoKHR , p_handle : *mut HANDLE , ) -> Result , } @@ -33605,35 +33866,50 @@ impl ::std::clone::Clone for KhrExternalSemaphoreWin32Fn { } } impl KhrExternalSemaphoreWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreWin32Fn { + KhrExternalSemaphoreWin32Fn { import_semaphore_win32_handle_khr: unsafe { + extern "system" fn import_semaphore_win32_handle_khr( + _device: Device, + _p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_win32_handle_khr) + )) + } let raw_name = stringify!(vkImportSemaphoreWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_semaphore_win32_handle_khr: unsafe { + extern "system" fn get_semaphore_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_win32_handle_khr) + )) + } let raw_name = stringify!(vkGetSemaphoreWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_semaphore_win32_handle_khr( @@ -33691,35 +33967,47 @@ impl ::std::clone::Clone for KhrExternalSemaphoreFdFn { } } impl KhrExternalSemaphoreFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalSemaphoreFdFn { + KhrExternalSemaphoreFdFn { import_semaphore_fd_khr: unsafe { + extern "system" fn import_semaphore_fd_khr( + _device: Device, + _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_fd_khr) + )) + } let raw_name = stringify!(vkImportSemaphoreFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_semaphore_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_semaphore_fd_khr: unsafe { + extern "system" fn get_semaphore_fd_khr( + _device: Device, + _p_get_fd_info: *const SemaphoreGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_semaphore_fd_khr))) + } let raw_name = stringify!(vkGetSemaphoreFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_semaphore_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_semaphore_fd_khr( @@ -33776,35 +34064,56 @@ impl ::std::clone::Clone for KhrPushDescriptorFn { } } impl KhrPushDescriptorFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrPushDescriptorFn { + KhrPushDescriptorFn { cmd_push_descriptor_set_khr: unsafe { + extern "system" fn cmd_push_descriptor_set_khr( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + _descriptor_write_count: u32, + _p_descriptor_writes: *const WriteDescriptorSet, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_khr) + )) + } let raw_name = stringify!(vkCmdPushDescriptorSetKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_push_descriptor_set_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_push_descriptor_set_with_template_khr: unsafe { + extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_with_template_khr) + )) + } let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_push_descriptor_set_khr( @@ -33859,17 +34168,11 @@ impl ::std::clone::Clone for ExtExtension82Fn { } } impl ExtExtension82Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension82Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension82Fn {} } } pub struct KhrExtension83Fn {} @@ -33881,17 +34184,11 @@ impl ::std::clone::Clone for KhrExtension83Fn { } } impl KhrExtension83Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension83Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension83Fn {} } } pub struct Khr16bitStorageFn {} @@ -33903,17 +34200,11 @@ impl ::std::clone::Clone for Khr16bitStorageFn { } } impl Khr16bitStorageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = Khr16bitStorageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + Khr16bitStorageFn {} } } pub struct KhrIncrementalPresentFn {} @@ -33925,17 +34216,11 @@ impl ::std::clone::Clone for KhrIncrementalPresentFn { } } impl KhrIncrementalPresentFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrIncrementalPresentFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrIncrementalPresentFn {} } } #[doc = "Generated from \'VK_KHR_incremental_present\'"] @@ -33963,26 +34248,33 @@ impl ::std::clone::Clone for KhrDescriptorUpdateTemplateFn { } } impl KhrDescriptorUpdateTemplateFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDescriptorUpdateTemplateFn { + KhrDescriptorUpdateTemplateFn { cmd_push_descriptor_set_with_template_khr: unsafe { + extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_with_template_khr) + )) + } let raw_name = stringify!(vkCmdPushDescriptorSetWithTemplateKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_push_descriptor_set_with_template_khr( @@ -34078,98 +34370,192 @@ impl ::std::clone::Clone for NvxDeviceGeneratedCommandsFn { } } impl NvxDeviceGeneratedCommandsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxDeviceGeneratedCommandsFn { + NvxDeviceGeneratedCommandsFn { cmd_process_commands_nvx: unsafe { + extern "system" fn cmd_process_commands_nvx( + _command_buffer: CommandBuffer, + _p_process_commands_info: *const CmdProcessCommandsInfoNVX, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_process_commands_nvx) + )) + } let raw_name = stringify!(vkCmdProcessCommandsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_process_commands_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_reserve_space_for_commands_nvx: unsafe { + extern "system" fn cmd_reserve_space_for_commands_nvx( + _command_buffer: CommandBuffer, + _p_reserve_space_info: *const CmdReserveSpaceForCommandsInfoNVX, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_reserve_space_for_commands_nvx) + )) + } let raw_name = stringify!(vkCmdReserveSpaceForCommandsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_reserve_space_for_commands_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_indirect_commands_layout_nvx: unsafe { + extern "system" fn create_indirect_commands_layout_nvx( + _device: Device, + _p_create_info: *const IndirectCommandsLayoutCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_indirect_commands_layout: *mut IndirectCommandsLayoutNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_indirect_commands_layout_nvx) + )) + } let raw_name = stringify!(vkCreateIndirectCommandsLayoutNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_indirect_commands_layout_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_indirect_commands_layout_nvx: unsafe { + extern "system" fn destroy_indirect_commands_layout_nvx( + _device: Device, + _indirect_commands_layout: IndirectCommandsLayoutNVX, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_indirect_commands_layout_nvx) + )) + } let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_indirect_commands_layout_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_object_table_nvx: unsafe { + extern "system" fn create_object_table_nvx( + _device: Device, + _p_create_info: *const ObjectTableCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_object_table: *mut ObjectTableNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_object_table_nvx) + )) + } let raw_name = stringify!(vkCreateObjectTableNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_object_table_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_object_table_nvx: unsafe { + extern "system" fn destroy_object_table_nvx( + _device: Device, + _object_table: ObjectTableNVX, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_object_table_nvx) + )) + } let raw_name = stringify!(vkDestroyObjectTableNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_object_table_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, register_objects_nvx: unsafe { + extern "system" fn register_objects_nvx( + _device: Device, + _object_table: ObjectTableNVX, + _object_count: u32, + _pp_object_table_entries: *const *const ObjectTableEntryNVX, + _p_object_indices: *const u32, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(register_objects_nvx))) + } let raw_name = stringify!(vkRegisterObjectsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + register_objects_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, unregister_objects_nvx: unsafe { + extern "system" fn unregister_objects_nvx( + _device: Device, + _object_table: ObjectTableNVX, + _object_count: u32, + _p_object_entry_types: *const ObjectEntryTypeNVX, + _p_object_indices: *const u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(unregister_objects_nvx) + )) + } let raw_name = stringify!(vkUnregisterObjectsNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + unregister_objects_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_generated_commands_properties_nvx: unsafe { + extern "system" fn get_physical_device_generated_commands_properties_nvx( + _physical_device: PhysicalDevice, + _p_features: *mut DeviceGeneratedCommandsFeaturesNVX, + _p_limits: *mut DeviceGeneratedCommandsLimitsNVX, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_generated_commands_properties_nvx) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_generated_commands_properties_nvx + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_process_commands_nvx( @@ -34333,26 +34719,32 @@ impl ::std::clone::Clone for NvClipSpaceWScalingFn { } } impl NvClipSpaceWScalingFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvClipSpaceWScalingFn { + NvClipSpaceWScalingFn { cmd_set_viewport_w_scaling_nv: unsafe { + extern "system" fn cmd_set_viewport_w_scaling_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_w_scalings: *const ViewportWScalingNV, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_w_scaling_nv) + )) + } let raw_name = stringify!(vkCmdSetViewportWScalingNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_viewport_w_scaling_nv + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_set_viewport_w_scaling_nv( @@ -34392,26 +34784,27 @@ impl ::std::clone::Clone for ExtDirectModeDisplayFn { } } impl ExtDirectModeDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDirectModeDisplayFn { + ExtDirectModeDisplayFn { release_display_ext: unsafe { + extern "system" fn release_display_ext( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(release_display_ext))) + } let raw_name = stringify!(vkReleaseDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + release_display_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn release_display_ext( @@ -34444,35 +34837,52 @@ impl ::std::clone::Clone for ExtAcquireXlibDisplayFn { } } impl ExtAcquireXlibDisplayFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtAcquireXlibDisplayFn { + ExtAcquireXlibDisplayFn { acquire_xlib_display_ext: unsafe { + extern "system" fn acquire_xlib_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_xlib_display_ext) + )) + } let raw_name = stringify!(vkAcquireXlibDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + acquire_xlib_display_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_rand_r_output_display_ext: unsafe { + extern "system" fn get_rand_r_output_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _rr_output: RROutput, + _p_display: *mut DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_rand_r_output_display_ext) + )) + } let raw_name = stringify!(vkGetRandROutputDisplayEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_rand_r_output_display_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn acquire_xlib_display_ext( @@ -34512,26 +34922,31 @@ impl ::std::clone::Clone for ExtDisplaySurfaceCounterFn { } } impl ExtDisplaySurfaceCounterFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDisplaySurfaceCounterFn { + ExtDisplaySurfaceCounterFn { get_physical_device_surface_capabilities2_ext: unsafe { + extern "system" fn get_physical_device_surface_capabilities2_ext( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilities2EXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities2_ext) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2EXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_capabilities2_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_surface_capabilities2_ext( @@ -34591,53 +35006,95 @@ impl ::std::clone::Clone for ExtDisplayControlFn { } } impl ExtDisplayControlFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDisplayControlFn { + ExtDisplayControlFn { display_power_control_ext: unsafe { + extern "system" fn display_power_control_ext( + _device: Device, + _display: DisplayKHR, + _p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(display_power_control_ext) + )) + } let raw_name = stringify!(vkDisplayPowerControlEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + display_power_control_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, register_device_event_ext: unsafe { + extern "system" fn register_device_event_ext( + _device: Device, + _p_device_event_info: *const DeviceEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(register_device_event_ext) + )) + } let raw_name = stringify!(vkRegisterDeviceEventEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + register_device_event_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, register_display_event_ext: unsafe { + extern "system" fn register_display_event_ext( + _device: Device, + _display: DisplayKHR, + _p_display_event_info: *const DisplayEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(register_display_event_ext) + )) + } let raw_name = stringify!(vkRegisterDisplayEventEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + register_display_event_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_swapchain_counter_ext: unsafe { + extern "system" fn get_swapchain_counter_ext( + _device: Device, + _swapchain: SwapchainKHR, + _counter: SurfaceCounterFlagsEXT, + _p_counter_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_counter_ext) + )) + } let raw_name = stringify!(vkGetSwapchainCounterEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_counter_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn display_power_control_ext( @@ -34725,35 +35182,52 @@ impl ::std::clone::Clone for GoogleDisplayTimingFn { } } impl GoogleDisplayTimingFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleDisplayTimingFn { + GoogleDisplayTimingFn { get_refresh_cycle_duration_google: unsafe { + extern "system" fn get_refresh_cycle_duration_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_refresh_cycle_duration_google) + )) + } let raw_name = stringify!(vkGetRefreshCycleDurationGOOGLE); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_refresh_cycle_duration_google + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_past_presentation_timing_google: unsafe { + extern "system" fn get_past_presentation_timing_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_presentation_timing_count: *mut u32, + _p_presentation_timings: *mut PastPresentationTimingGOOGLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_past_presentation_timing_google) + )) + } let raw_name = stringify!(vkGetPastPresentationTimingGOOGLE); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_past_presentation_timing_google + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_refresh_cycle_duration_google( @@ -34792,17 +35266,11 @@ impl ::std::clone::Clone for NvSampleMaskOverrideCoverageFn { } } impl NvSampleMaskOverrideCoverageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvSampleMaskOverrideCoverageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvSampleMaskOverrideCoverageFn {} } } pub struct NvGeometryShaderPassthroughFn {} @@ -34814,17 +35282,11 @@ impl ::std::clone::Clone for NvGeometryShaderPassthroughFn { } } impl NvGeometryShaderPassthroughFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvGeometryShaderPassthroughFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvGeometryShaderPassthroughFn {} } } pub struct NvViewportArray2Fn {} @@ -34836,17 +35298,11 @@ impl ::std::clone::Clone for NvViewportArray2Fn { } } impl NvViewportArray2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvViewportArray2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvViewportArray2Fn {} } } pub struct NvxMultiviewPerViewAttributesFn {} @@ -34858,17 +35314,11 @@ impl ::std::clone::Clone for NvxMultiviewPerViewAttributesFn { } } impl NvxMultiviewPerViewAttributesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvxMultiviewPerViewAttributesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvxMultiviewPerViewAttributesFn {} } } #[doc = "Generated from \'VK_NVX_multiview_per_view_attributes\'"] @@ -34893,17 +35343,11 @@ impl ::std::clone::Clone for NvViewportSwizzleFn { } } impl NvViewportSwizzleFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvViewportSwizzleFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvViewportSwizzleFn {} } } #[doc = "Generated from \'VK_NV_viewport_swizzle\'"] @@ -34928,26 +35372,32 @@ impl ::std::clone::Clone for ExtDiscardRectanglesFn { } } impl ExtDiscardRectanglesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDiscardRectanglesFn { + ExtDiscardRectanglesFn { cmd_set_discard_rectangle_ext: unsafe { + extern "system" fn cmd_set_discard_rectangle_ext( + _command_buffer: CommandBuffer, + _first_discard_rectangle: u32, + _discard_rectangle_count: u32, + _p_discard_rectangles: *const Rect2D, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_discard_rectangle_ext) + )) + } let raw_name = stringify!(vkCmdSetDiscardRectangleEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_discard_rectangle_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_set_discard_rectangle_ext( @@ -34986,17 +35436,11 @@ impl ::std::clone::Clone for NvExtension101Fn { } } impl NvExtension101Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension101Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension101Fn {} } } pub struct ExtConservativeRasterizationFn {} @@ -35008,17 +35452,11 @@ impl ::std::clone::Clone for ExtConservativeRasterizationFn { } } impl ExtConservativeRasterizationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtConservativeRasterizationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtConservativeRasterizationFn {} } } #[doc = "Generated from \'VK_EXT_conservative_rasterization\'"] @@ -35040,17 +35478,11 @@ impl ::std::clone::Clone for NvExtension103Fn { } } impl NvExtension103Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension103Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension103Fn {} } } pub struct NvExtension104Fn {} @@ -35062,17 +35494,11 @@ impl ::std::clone::Clone for NvExtension104Fn { } } impl NvExtension104Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension104Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension104Fn {} } } pub struct ExtSwapchainColorspaceFn {} @@ -35084,17 +35510,11 @@ impl ::std::clone::Clone for ExtSwapchainColorspaceFn { } } impl ExtSwapchainColorspaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtSwapchainColorspaceFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtSwapchainColorspaceFn {} } } #[doc = "Generated from \'VK_EXT_swapchain_colorspace\'"] @@ -35171,26 +35591,29 @@ impl ::std::clone::Clone for ExtHdrMetadataFn { } } impl ExtHdrMetadataFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtHdrMetadataFn { + ExtHdrMetadataFn { set_hdr_metadata_ext: unsafe { + extern "system" fn set_hdr_metadata_ext( + _device: Device, + _swapchain_count: u32, + _p_swapchains: *const SwapchainKHR, + _p_metadata: *const HdrMetadataEXT, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext))) + } let raw_name = stringify!(vkSetHdrMetadataEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + set_hdr_metadata_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn set_hdr_metadata_ext( @@ -35216,17 +35639,11 @@ impl ::std::clone::Clone for ImgExtension107Fn { } } impl ImgExtension107Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension107Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension107Fn {} } } pub struct ImgExtension108Fn {} @@ -35238,17 +35655,11 @@ impl ::std::clone::Clone for ImgExtension108Fn { } } impl ImgExtension108Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension108Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension108Fn {} } } pub struct ImgExtension109Fn {} @@ -35260,17 +35671,11 @@ impl ::std::clone::Clone for ImgExtension109Fn { } } impl ImgExtension109Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension109Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension109Fn {} } } pub struct ImgExtension110Fn {} @@ -35282,17 +35687,11 @@ impl ::std::clone::Clone for ImgExtension110Fn { } } impl ImgExtension110Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension110Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension110Fn {} } } pub struct ImgExtension111Fn {} @@ -35304,17 +35703,11 @@ impl ::std::clone::Clone for ImgExtension111Fn { } } impl ImgExtension111Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ImgExtension111Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ImgExtension111Fn {} } } pub struct KhrSharedPresentableImageFn { @@ -35330,26 +35723,30 @@ impl ::std::clone::Clone for KhrSharedPresentableImageFn { } } impl KhrSharedPresentableImageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSharedPresentableImageFn { + KhrSharedPresentableImageFn { get_swapchain_status_khr: unsafe { + extern "system" fn get_swapchain_status_khr( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_status_khr) + )) + } let raw_name = stringify!(vkGetSwapchainStatusKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_swapchain_status_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_swapchain_status_khr( @@ -35385,17 +35782,11 @@ impl ::std::clone::Clone for KhrExternalFenceCapabilitiesFn { } } impl KhrExternalFenceCapabilitiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceCapabilitiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalFenceCapabilitiesFn {} } } pub struct KhrExternalFenceFn {} @@ -35407,17 +35798,11 @@ impl ::std::clone::Clone for KhrExternalFenceFn { } } impl KhrExternalFenceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExternalFenceFn {} } } pub struct KhrExternalFenceWin32Fn { @@ -35444,35 +35829,50 @@ impl ::std::clone::Clone for KhrExternalFenceWin32Fn { } } impl KhrExternalFenceWin32Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceWin32Fn { + KhrExternalFenceWin32Fn { import_fence_win32_handle_khr: unsafe { + extern "system" fn import_fence_win32_handle_khr( + _device: Device, + _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_fence_win32_handle_khr) + )) + } let raw_name = stringify!(vkImportFenceWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_fence_win32_handle_khr: unsafe { + extern "system" fn get_fence_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_fence_win32_handle_khr) + )) + } let raw_name = stringify!(vkGetFenceWin32HandleKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_fence_win32_handle_khr( @@ -35524,35 +35924,44 @@ impl ::std::clone::Clone for KhrExternalFenceFdFn { } } impl KhrExternalFenceFdFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExternalFenceFdFn { + KhrExternalFenceFdFn { import_fence_fd_khr: unsafe { + extern "system" fn import_fence_fd_khr( + _device: Device, + _p_import_fence_fd_info: *const ImportFenceFdInfoKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(import_fence_fd_khr))) + } let raw_name = stringify!(vkImportFenceFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + import_fence_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_fence_fd_khr: unsafe { + extern "system" fn get_fence_fd_khr( + _device: Device, + _p_get_fd_info: *const FenceGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_fence_fd_khr))) + } let raw_name = stringify!(vkGetFenceFdKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_fence_fd_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn import_fence_fd_khr( @@ -35588,17 +35997,11 @@ impl ::std::clone::Clone for KhrExtension117Fn { } } impl KhrExtension117Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension117Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension117Fn {} } } pub struct KhrMaintenance2Fn {} @@ -35610,17 +36013,11 @@ impl ::std::clone::Clone for KhrMaintenance2Fn { } } impl KhrMaintenance2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMaintenance2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMaintenance2Fn {} } } pub struct KhrExtension119Fn {} @@ -35632,17 +36029,11 @@ impl ::std::clone::Clone for KhrExtension119Fn { } } impl KhrExtension119Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension119Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension119Fn {} } } pub struct KhrGetSurfaceCapabilities2Fn { @@ -35672,35 +36063,52 @@ impl ::std::clone::Clone for KhrGetSurfaceCapabilities2Fn { } } impl KhrGetSurfaceCapabilities2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetSurfaceCapabilities2Fn { + KhrGetSurfaceCapabilities2Fn { get_physical_device_surface_capabilities2_khr: unsafe { + extern "system" fn get_physical_device_surface_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_capabilities: *mut SurfaceCapabilities2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities2_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceCapabilities2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_capabilities2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_surface_formats2_khr: unsafe { + extern "system" fn get_physical_device_surface_formats2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormat2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_formats2_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceSurfaceFormats2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_surface_formats2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_surface_capabilities2_khr( @@ -35751,17 +36159,11 @@ impl ::std::clone::Clone for KhrVariablePointersFn { } } impl KhrVariablePointersFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrVariablePointersFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrVariablePointersFn {} } } pub struct KhrGetDisplayProperties2Fn { @@ -35806,53 +36208,92 @@ impl ::std::clone::Clone for KhrGetDisplayProperties2Fn { } } impl KhrGetDisplayProperties2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetDisplayProperties2Fn { + KhrGetDisplayProperties2Fn { get_physical_device_display_properties2_khr: unsafe { + extern "system" fn get_physical_device_display_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_properties2_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_properties2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_display_plane_properties2_khr: unsafe { + extern "system" fn get_physical_device_display_plane_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlaneProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_plane_properties2_khr) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_display_plane_properties2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_mode_properties2_khr: unsafe { + extern "system" fn get_display_mode_properties2_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModeProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_mode_properties2_khr) + )) + } let raw_name = stringify!(vkGetDisplayModeProperties2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_mode_properties2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_display_plane_capabilities2_khr: unsafe { + extern "system" fn get_display_plane_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_display_plane_info: *const DisplayPlaneInfo2KHR, + _p_capabilities: *mut DisplayPlaneCapabilities2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_capabilities2_khr) + )) + } let raw_name = stringify!(vkGetDisplayPlaneCapabilities2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_display_plane_capabilities2_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_physical_device_display_properties2_khr( @@ -35944,26 +36385,32 @@ impl ::std::clone::Clone for MvkIosSurfaceFn { } } impl MvkIosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = MvkIosSurfaceFn { + MvkIosSurfaceFn { create_ios_surface_mvk: unsafe { + extern "system" fn create_ios_surface_mvk( + _instance: Instance, + _p_create_info: *const IOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ios_surface_mvk) + )) + } let raw_name = stringify!(vkCreateIOSSurfaceMVK); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_ios_surface_mvk + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_ios_surface_mvk( @@ -35998,26 +36445,32 @@ impl ::std::clone::Clone for MvkMacosSurfaceFn { } } impl MvkMacosSurfaceFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = MvkMacosSurfaceFn { + MvkMacosSurfaceFn { create_mac_os_surface_mvk: unsafe { + extern "system" fn create_mac_os_surface_mvk( + _instance: Instance, + _p_create_info: *const MacOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_mac_os_surface_mvk) + )) + } let raw_name = stringify!(vkCreateMacOSSurfaceMVK); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_mac_os_surface_mvk + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_mac_os_surface_mvk( @@ -36043,17 +36496,11 @@ impl ::std::clone::Clone for MvkMoltenvkFn { } } impl MvkMoltenvkFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = MvkMoltenvkFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + MvkMoltenvkFn {} } } pub struct ExtExternalMemoryDmaBufFn {} @@ -36065,17 +36512,11 @@ impl ::std::clone::Clone for ExtExternalMemoryDmaBufFn { } } impl ExtExternalMemoryDmaBufFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExternalMemoryDmaBufFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExternalMemoryDmaBufFn {} } } #[doc = "Generated from \'VK_EXT_external_memory_dma_buf\'"] @@ -36092,17 +36533,11 @@ impl ::std::clone::Clone for ExtQueueFamilyForeignFn { } } impl ExtQueueFamilyForeignFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtQueueFamilyForeignFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtQueueFamilyForeignFn {} } } pub struct KhrDedicatedAllocationFn {} @@ -36114,17 +36549,11 @@ impl ::std::clone::Clone for KhrDedicatedAllocationFn { } } impl KhrDedicatedAllocationFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDedicatedAllocationFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrDedicatedAllocationFn {} } } pub struct ExtDebugUtilsFn { @@ -36185,116 +36614,221 @@ impl ::std::clone::Clone for ExtDebugUtilsFn { } } impl ExtDebugUtilsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDebugUtilsFn { + ExtDebugUtilsFn { set_debug_utils_object_name_ext: unsafe { + extern "system" fn set_debug_utils_object_name_ext( + _device: Device, + _p_name_info: *const DebugUtilsObjectNameInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_debug_utils_object_name_ext) + )) + } let raw_name = stringify!(vkSetDebugUtilsObjectNameEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + set_debug_utils_object_name_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, set_debug_utils_object_tag_ext: unsafe { + extern "system" fn set_debug_utils_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugUtilsObjectTagInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_debug_utils_object_tag_ext) + )) + } let raw_name = stringify!(vkSetDebugUtilsObjectTagEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + set_debug_utils_object_tag_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_begin_debug_utils_label_ext: unsafe { + extern "system" fn queue_begin_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(queue_begin_debug_utils_label_ext) + )) + } let raw_name = stringify!(vkQueueBeginDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_end_debug_utils_label_ext: unsafe { + extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(queue_end_debug_utils_label_ext) + )) + } let raw_name = stringify!(vkQueueEndDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, queue_insert_debug_utils_label_ext: unsafe { + extern "system" fn queue_insert_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(queue_insert_debug_utils_label_ext) + )) + } let raw_name = stringify!(vkQueueInsertDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + queue_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_begin_debug_utils_label_ext: unsafe { + extern "system" fn cmd_begin_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_debug_utils_label_ext) + )) + } let raw_name = stringify!(vkCmdBeginDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_end_debug_utils_label_ext: unsafe { + extern "system" fn cmd_end_debug_utils_label_ext( + _command_buffer: CommandBuffer, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_debug_utils_label_ext) + )) + } let raw_name = stringify!(vkCmdEndDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_insert_debug_utils_label_ext: unsafe { + extern "system" fn cmd_insert_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_insert_debug_utils_label_ext) + )) + } let raw_name = stringify!(vkCmdInsertDebugUtilsLabelEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, create_debug_utils_messenger_ext: unsafe { + extern "system" fn create_debug_utils_messenger_ext( + _instance: Instance, + _p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_messenger: *mut DebugUtilsMessengerEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_debug_utils_messenger_ext) + )) + } let raw_name = stringify!(vkCreateDebugUtilsMessengerEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_debug_utils_messenger_ext: unsafe { + extern "system" fn destroy_debug_utils_messenger_ext( + _instance: Instance, + _messenger: DebugUtilsMessengerEXT, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_debug_utils_messenger_ext) + )) + } let raw_name = stringify!(vkDestroyDebugUtilsMessengerEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, submit_debug_utils_message_ext: unsafe { + extern "system" fn submit_debug_utils_message_ext( + _instance: Instance, + _message_severity: DebugUtilsMessageSeverityFlagsEXT, + _message_types: DebugUtilsMessageTypeFlagsEXT, + _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(submit_debug_utils_message_ext) + )) + } let raw_name = stringify!(vkSubmitDebugUtilsMessageEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + submit_debug_utils_message_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn set_debug_utils_object_name_ext( @@ -36428,35 +36962,51 @@ impl ::std::clone::Clone for AndroidExternalMemoryAndroidHardwareBufferFn { } } impl AndroidExternalMemoryAndroidHardwareBufferFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AndroidExternalMemoryAndroidHardwareBufferFn { + AndroidExternalMemoryAndroidHardwareBufferFn { get_android_hardware_buffer_properties_android: unsafe { + extern "system" fn get_android_hardware_buffer_properties_android( + _device: Device, + _buffer: *const AHardwareBuffer, + _p_properties: *mut AndroidHardwareBufferPropertiesANDROID, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_android_hardware_buffer_properties_android) + )) + } let raw_name = stringify!(vkGetAndroidHardwareBufferPropertiesANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_android_hardware_buffer_properties_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_memory_android_hardware_buffer_android: unsafe { + extern "system" fn get_memory_android_hardware_buffer_android( + _device: Device, + _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + _p_buffer: *mut *mut AHardwareBuffer, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_android_hardware_buffer_android) + )) + } let raw_name = stringify!(vkGetMemoryAndroidHardwareBufferANDROID); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_android_hardware_buffer_android + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_android_hardware_buffer_properties_android( @@ -36514,17 +37064,11 @@ impl ::std::clone::Clone for ExtSamplerFilterMinmaxFn { } } impl ExtSamplerFilterMinmaxFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtSamplerFilterMinmaxFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtSamplerFilterMinmaxFn {} } } #[doc = "Generated from \'VK_EXT_sampler_filter_minmax\'"] @@ -36549,17 +37093,11 @@ impl ::std::clone::Clone for KhrStorageBufferStorageClassFn { } } impl KhrStorageBufferStorageClassFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrStorageBufferStorageClassFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrStorageBufferStorageClassFn {} } } pub struct AmdGpuShaderInt16Fn {} @@ -36571,17 +37109,11 @@ impl ::std::clone::Clone for AmdGpuShaderInt16Fn { } } impl AmdGpuShaderInt16Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdGpuShaderInt16Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdGpuShaderInt16Fn {} } } pub struct AmdExtension134Fn {} @@ -36593,17 +37125,11 @@ impl ::std::clone::Clone for AmdExtension134Fn { } } impl AmdExtension134Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension134Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension134Fn {} } } pub struct AmdExtension135Fn {} @@ -36615,17 +37141,11 @@ impl ::std::clone::Clone for AmdExtension135Fn { } } impl AmdExtension135Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension135Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension135Fn {} } } pub struct AmdExtension136Fn {} @@ -36637,17 +37157,11 @@ impl ::std::clone::Clone for AmdExtension136Fn { } } impl AmdExtension136Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension136Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension136Fn {} } } pub struct AmdMixedAttachmentSamplesFn {} @@ -36659,17 +37173,11 @@ impl ::std::clone::Clone for AmdMixedAttachmentSamplesFn { } } impl AmdMixedAttachmentSamplesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdMixedAttachmentSamplesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdMixedAttachmentSamplesFn {} } } pub struct AmdShaderFragmentMaskFn {} @@ -36681,17 +37189,11 @@ impl ::std::clone::Clone for AmdShaderFragmentMaskFn { } } impl AmdShaderFragmentMaskFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderFragmentMaskFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderFragmentMaskFn {} } } pub struct AmdExtension139Fn {} @@ -36703,17 +37205,11 @@ impl ::std::clone::Clone for AmdExtension139Fn { } } impl AmdExtension139Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension139Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension139Fn {} } } pub struct AmdExtension140Fn {} @@ -36725,17 +37221,11 @@ impl ::std::clone::Clone for AmdExtension140Fn { } } impl AmdExtension140Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension140Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension140Fn {} } } pub struct ExtShaderStencilExportFn {} @@ -36747,17 +37237,11 @@ impl ::std::clone::Clone for ExtShaderStencilExportFn { } } impl ExtShaderStencilExportFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderStencilExportFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderStencilExportFn {} } } pub struct AmdExtension142Fn {} @@ -36769,17 +37253,11 @@ impl ::std::clone::Clone for AmdExtension142Fn { } } impl AmdExtension142Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension142Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension142Fn {} } } pub struct AmdExtension143Fn {} @@ -36791,17 +37269,11 @@ impl ::std::clone::Clone for AmdExtension143Fn { } } impl AmdExtension143Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension143Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension143Fn {} } } pub struct ExtSampleLocationsFn { @@ -36829,35 +37301,50 @@ impl ::std::clone::Clone for ExtSampleLocationsFn { } } impl ExtSampleLocationsFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtSampleLocationsFn { + ExtSampleLocationsFn { cmd_set_sample_locations_ext: unsafe { + extern "system" fn cmd_set_sample_locations_ext( + _command_buffer: CommandBuffer, + _p_sample_locations_info: *const SampleLocationsInfoEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_locations_ext) + )) + } let raw_name = stringify!(vkCmdSetSampleLocationsEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_set_sample_locations_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_physical_device_multisample_properties_ext: unsafe { + extern "system" fn get_physical_device_multisample_properties_ext( + _physical_device: PhysicalDevice, + _samples: SampleCountFlags, + _p_multisample_properties: *mut MultisamplePropertiesEXT, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_multisample_properties_ext) + )) + } let raw_name = stringify!(vkGetPhysicalDeviceMultisamplePropertiesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_physical_device_multisample_properties_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_set_sample_locations_ext( @@ -36917,17 +37404,11 @@ impl ::std::clone::Clone for KhrRelaxedBlockLayoutFn { } } impl KhrRelaxedBlockLayoutFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrRelaxedBlockLayoutFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrRelaxedBlockLayoutFn {} } } pub struct KhrGetMemoryRequirements2Fn {} @@ -36939,17 +37420,11 @@ impl ::std::clone::Clone for KhrGetMemoryRequirements2Fn { } } impl KhrGetMemoryRequirements2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrGetMemoryRequirements2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrGetMemoryRequirements2Fn {} } } pub struct KhrImageFormatListFn {} @@ -36961,17 +37436,11 @@ impl ::std::clone::Clone for KhrImageFormatListFn { } } impl KhrImageFormatListFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrImageFormatListFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrImageFormatListFn {} } } #[doc = "Generated from \'VK_KHR_image_format_list\'"] @@ -36987,17 +37456,11 @@ impl ::std::clone::Clone for ExtBlendOperationAdvancedFn { } } impl ExtBlendOperationAdvancedFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtBlendOperationAdvancedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtBlendOperationAdvancedFn {} } } #[doc = "Generated from \'VK_EXT_blend_operation_advanced\'"] @@ -37211,17 +37674,11 @@ impl ::std::clone::Clone for NvFragmentCoverageToColorFn { } } impl NvFragmentCoverageToColorFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvFragmentCoverageToColorFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvFragmentCoverageToColorFn {} } } #[doc = "Generated from \'VK_NV_fragment_coverage_to_color\'"] @@ -37237,17 +37694,11 @@ impl ::std::clone::Clone for NvExtension151Fn { } } impl NvExtension151Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension151Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension151Fn {} } } pub struct NvExtension152Fn {} @@ -37259,17 +37710,11 @@ impl ::std::clone::Clone for NvExtension152Fn { } } impl NvExtension152Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension152Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension152Fn {} } } pub struct NvFramebufferMixedSamplesFn {} @@ -37281,17 +37726,11 @@ impl ::std::clone::Clone for NvFramebufferMixedSamplesFn { } } impl NvFramebufferMixedSamplesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvFramebufferMixedSamplesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvFramebufferMixedSamplesFn {} } } #[doc = "Generated from \'VK_NV_framebuffer_mixed_samples\'"] @@ -37307,17 +37746,11 @@ impl ::std::clone::Clone for NvFillRectangleFn { } } impl NvFillRectangleFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvFillRectangleFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvFillRectangleFn {} } } #[doc = "Generated from \'VK_NV_fill_rectangle\'"] @@ -37333,17 +37766,11 @@ impl ::std::clone::Clone for NvExtension155Fn { } } impl NvExtension155Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension155Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension155Fn {} } } pub struct ExtPostDepthCoverageFn {} @@ -37355,17 +37782,11 @@ impl ::std::clone::Clone for ExtPostDepthCoverageFn { } } impl ExtPostDepthCoverageFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtPostDepthCoverageFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtPostDepthCoverageFn {} } } pub struct KhrSamplerYcbcrConversionFn {} @@ -37377,17 +37798,11 @@ impl ::std::clone::Clone for KhrSamplerYcbcrConversionFn { } } impl KhrSamplerYcbcrConversionFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrSamplerYcbcrConversionFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrSamplerYcbcrConversionFn {} } } pub struct KhrBindMemory2Fn {} @@ -37399,17 +37814,11 @@ impl ::std::clone::Clone for KhrBindMemory2Fn { } } impl KhrBindMemory2Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrBindMemory2Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrBindMemory2Fn {} } } pub struct ExtExtension159Fn {} @@ -37421,17 +37830,11 @@ impl ::std::clone::Clone for ExtExtension159Fn { } } impl ExtExtension159Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension159Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension159Fn {} } } pub struct ExtExtension160Fn {} @@ -37443,17 +37846,11 @@ impl ::std::clone::Clone for ExtExtension160Fn { } } impl ExtExtension160Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension160Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension160Fn {} } } pub struct ExtValidationCacheFn { @@ -37495,53 +37892,94 @@ impl ::std::clone::Clone for ExtValidationCacheFn { } } impl ExtValidationCacheFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtValidationCacheFn { + ExtValidationCacheFn { create_validation_cache_ext: unsafe { + extern "system" fn create_validation_cache_ext( + _device: Device, + _p_create_info: *const ValidationCacheCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_validation_cache: *mut ValidationCacheEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_validation_cache_ext) + )) + } let raw_name = stringify!(vkCreateValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + create_validation_cache_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, destroy_validation_cache_ext: unsafe { + extern "system" fn destroy_validation_cache_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_validation_cache_ext) + )) + } let raw_name = stringify!(vkDestroyValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + destroy_validation_cache_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, merge_validation_caches_ext: unsafe { + extern "system" fn merge_validation_caches_ext( + _device: Device, + _dst_cache: ValidationCacheEXT, + _src_cache_count: u32, + _p_src_caches: *const ValidationCacheEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(merge_validation_caches_ext) + )) + } let raw_name = stringify!(vkMergeValidationCachesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + merge_validation_caches_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, get_validation_cache_data_ext: unsafe { + extern "system" fn get_validation_cache_data_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_validation_cache_data_ext) + )) + } let raw_name = stringify!(vkGetValidationCacheDataEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_validation_cache_data_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn create_validation_cache_ext( @@ -37601,17 +38039,11 @@ impl ::std::clone::Clone for ExtDescriptorIndexingFn { } } impl ExtDescriptorIndexingFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtDescriptorIndexingFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtDescriptorIndexingFn {} } } #[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] @@ -37657,17 +38089,11 @@ impl ::std::clone::Clone for ExtShaderViewportIndexLayerFn { } } impl ExtShaderViewportIndexLayerFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtShaderViewportIndexLayerFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtShaderViewportIndexLayerFn {} } } pub struct NvExtension164Fn {} @@ -37679,17 +38105,11 @@ impl ::std::clone::Clone for NvExtension164Fn { } } impl NvExtension164Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension164Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension164Fn {} } } pub struct NvExtension165Fn {} @@ -37701,17 +38121,11 @@ impl ::std::clone::Clone for NvExtension165Fn { } } impl NvExtension165Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension165Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension165Fn {} } } pub struct NvExtension166Fn {} @@ -37723,17 +38137,11 @@ impl ::std::clone::Clone for NvExtension166Fn { } } impl NvExtension166Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension166Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension166Fn {} } } pub struct NvExtension167Fn {} @@ -37745,17 +38153,11 @@ impl ::std::clone::Clone for NvExtension167Fn { } } impl NvExtension167Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension167Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension167Fn {} } } pub struct NvExtension168Fn {} @@ -37767,17 +38169,11 @@ impl ::std::clone::Clone for NvExtension168Fn { } } impl NvExtension168Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension168Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension168Fn {} } } pub struct KhrMaintenance3Fn {} @@ -37789,17 +38185,11 @@ impl ::std::clone::Clone for KhrMaintenance3Fn { } } impl KhrMaintenance3Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrMaintenance3Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrMaintenance3Fn {} } } pub struct KhrDrawIndirectCountFn { @@ -37833,35 +38223,59 @@ impl ::std::clone::Clone for KhrDrawIndirectCountFn { } } impl KhrDrawIndirectCountFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrDrawIndirectCountFn { + KhrDrawIndirectCountFn { cmd_draw_indirect_count_khr: unsafe { + extern "system" fn cmd_draw_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_khr) + )) + } let raw_name = stringify!(vkCmdDrawIndirectCountKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indirect_count_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, cmd_draw_indexed_indirect_count_khr: unsafe { + extern "system" fn cmd_draw_indexed_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count_khr) + )) + } let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_draw_indexed_indirect_count_khr + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_draw_indirect_count_khr( @@ -37914,17 +38328,11 @@ impl ::std::clone::Clone for QcomExtension171Fn { } } impl QcomExtension171Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension171Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension171Fn {} } } pub struct QcomExtension172Fn {} @@ -37936,17 +38344,11 @@ impl ::std::clone::Clone for QcomExtension172Fn { } } impl QcomExtension172Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension172Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension172Fn {} } } pub struct QcomExtension173Fn {} @@ -37958,17 +38360,11 @@ impl ::std::clone::Clone for QcomExtension173Fn { } } impl QcomExtension173Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension173Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension173Fn {} } } pub struct QcomExtension174Fn {} @@ -37980,17 +38376,11 @@ impl ::std::clone::Clone for QcomExtension174Fn { } } impl QcomExtension174Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = QcomExtension174Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + QcomExtension174Fn {} } } pub struct ExtGlobalPriorityFn {} @@ -38002,17 +38392,11 @@ impl ::std::clone::Clone for ExtGlobalPriorityFn { } } impl ExtGlobalPriorityFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtGlobalPriorityFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtGlobalPriorityFn {} } } #[doc = "Generated from \'VK_EXT_global_priority\'"] @@ -38032,17 +38416,11 @@ impl ::std::clone::Clone for ExtExtension176Fn { } } impl ExtExtension176Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension176Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension176Fn {} } } pub struct ExtExtension177Fn {} @@ -38054,17 +38432,11 @@ impl ::std::clone::Clone for ExtExtension177Fn { } } impl ExtExtension177Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension177Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension177Fn {} } } pub struct ExtExtension178Fn {} @@ -38076,17 +38448,11 @@ impl ::std::clone::Clone for ExtExtension178Fn { } } impl ExtExtension178Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension178Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension178Fn {} } } pub struct ExtExternalMemoryHostFn { @@ -38108,26 +38474,32 @@ impl ::std::clone::Clone for ExtExternalMemoryHostFn { } } impl ExtExternalMemoryHostFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExternalMemoryHostFn { + ExtExternalMemoryHostFn { get_memory_host_pointer_properties_ext: unsafe { + extern "system" fn get_memory_host_pointer_properties_ext( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _p_host_pointer: *const c_void, + _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_host_pointer_properties_ext) + )) + } let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + get_memory_host_pointer_properties_ext + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn get_memory_host_pointer_properties_ext( @@ -38186,26 +38558,33 @@ impl ::std::clone::Clone for AmdBufferMarkerFn { } } impl AmdBufferMarkerFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdBufferMarkerFn { + AmdBufferMarkerFn { cmd_write_buffer_marker_amd: unsafe { + extern "system" fn cmd_write_buffer_marker_amd( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _marker: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_buffer_marker_amd) + )) + } let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - _err_str.push(raw_name); + cmd_write_buffer_marker_amd + } else { + ::std::mem::transmute(val) } - ::std::mem::transmute(val) }, - }; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) } } pub unsafe fn cmd_write_buffer_marker_amd( @@ -38234,17 +38613,11 @@ impl ::std::clone::Clone for AmdExtension181Fn { } } impl AmdExtension181Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension181Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension181Fn {} } } pub struct AmdExtension182Fn {} @@ -38256,17 +38629,11 @@ impl ::std::clone::Clone for AmdExtension182Fn { } } impl AmdExtension182Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension182Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension182Fn {} } } pub struct AmdExtension183Fn {} @@ -38278,17 +38645,11 @@ impl ::std::clone::Clone for AmdExtension183Fn { } } impl AmdExtension183Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension183Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension183Fn {} } } pub struct AmdExtension184Fn {} @@ -38300,17 +38661,11 @@ impl ::std::clone::Clone for AmdExtension184Fn { } } impl AmdExtension184Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension184Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension184Fn {} } } pub struct AmdExtension185Fn {} @@ -38322,17 +38677,11 @@ impl ::std::clone::Clone for AmdExtension185Fn { } } impl AmdExtension185Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension185Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension185Fn {} } } pub struct AmdShaderCorePropertiesFn {} @@ -38344,17 +38693,11 @@ impl ::std::clone::Clone for AmdShaderCorePropertiesFn { } } impl AmdShaderCorePropertiesFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdShaderCorePropertiesFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdShaderCorePropertiesFn {} } } #[doc = "Generated from \'VK_AMD_shader_core_properties\'"] @@ -38370,17 +38713,11 @@ impl ::std::clone::Clone for AmdExtension187Fn { } } impl AmdExtension187Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension187Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension187Fn {} } } pub struct AmdExtension188Fn {} @@ -38392,17 +38729,11 @@ impl ::std::clone::Clone for AmdExtension188Fn { } } impl AmdExtension188Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension188Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension188Fn {} } } pub struct AmdExtension189Fn {} @@ -38414,17 +38745,11 @@ impl ::std::clone::Clone for AmdExtension189Fn { } } impl AmdExtension189Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension189Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension189Fn {} } } pub struct AmdExtension190Fn {} @@ -38436,17 +38761,11 @@ impl ::std::clone::Clone for AmdExtension190Fn { } } impl AmdExtension190Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = AmdExtension190Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + AmdExtension190Fn {} } } pub struct ExtVertexAttributeDivisorFn {} @@ -38458,17 +38777,11 @@ impl ::std::clone::Clone for ExtVertexAttributeDivisorFn { } } impl ExtVertexAttributeDivisorFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtVertexAttributeDivisorFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtVertexAttributeDivisorFn {} } } #[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] @@ -38489,17 +38802,11 @@ impl ::std::clone::Clone for GoogleExtension192Fn { } } impl GoogleExtension192Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension192Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension192Fn {} } } pub struct GoogleExtension193Fn {} @@ -38511,17 +38818,11 @@ impl ::std::clone::Clone for GoogleExtension193Fn { } } impl GoogleExtension193Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension193Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension193Fn {} } } pub struct GoogleExtension194Fn {} @@ -38533,17 +38834,11 @@ impl ::std::clone::Clone for GoogleExtension194Fn { } } impl GoogleExtension194Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension194Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension194Fn {} } } pub struct GoogleExtension195Fn {} @@ -38555,17 +38850,11 @@ impl ::std::clone::Clone for GoogleExtension195Fn { } } impl GoogleExtension195Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension195Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension195Fn {} } } pub struct GoogleExtension196Fn {} @@ -38577,17 +38866,11 @@ impl ::std::clone::Clone for GoogleExtension196Fn { } } impl GoogleExtension196Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = GoogleExtension196Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + GoogleExtension196Fn {} } } pub struct ExtExtension197Fn {} @@ -38599,17 +38882,11 @@ impl ::std::clone::Clone for ExtExtension197Fn { } } impl ExtExtension197Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ExtExtension197Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ExtExtension197Fn {} } } pub struct ArmExtension198Fn {} @@ -38621,17 +38898,11 @@ impl ::std::clone::Clone for ArmExtension198Fn { } } impl ArmExtension198Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = ArmExtension198Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + ArmExtension198Fn {} } } pub struct NvShaderSubgroupPartitionedFn {} @@ -38643,17 +38914,11 @@ impl ::std::clone::Clone for NvShaderSubgroupPartitionedFn { } } impl NvShaderSubgroupPartitionedFn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvShaderSubgroupPartitionedFn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvShaderSubgroupPartitionedFn {} } } #[doc = "Generated from \'VK_NV_shader_subgroup_partitioned\'"] @@ -38669,17 +38934,11 @@ impl ::std::clone::Clone for KhrExtension200Fn { } } impl KhrExtension200Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension200Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension200Fn {} } } pub struct KhrExtension201Fn {} @@ -38691,17 +38950,11 @@ impl ::std::clone::Clone for KhrExtension201Fn { } } impl KhrExtension201Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension201Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension201Fn {} } } pub struct NvExtension202Fn {} @@ -38713,17 +38966,11 @@ impl ::std::clone::Clone for NvExtension202Fn { } } impl NvExtension202Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension202Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension202Fn {} } } pub struct NvExtension203Fn {} @@ -38735,17 +38982,11 @@ impl ::std::clone::Clone for NvExtension203Fn { } } impl NvExtension203Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension203Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension203Fn {} } } pub struct NvExtension204Fn {} @@ -38757,17 +38998,11 @@ impl ::std::clone::Clone for NvExtension204Fn { } } impl NvExtension204Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension204Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension204Fn {} } } pub struct NvExtension205Fn {} @@ -38779,17 +39014,11 @@ impl ::std::clone::Clone for NvExtension205Fn { } } impl NvExtension205Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension205Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension205Fn {} } } pub struct NvExtension206Fn {} @@ -38801,17 +39030,11 @@ impl ::std::clone::Clone for NvExtension206Fn { } } impl NvExtension206Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension206Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension206Fn {} } } pub struct NvExtension207Fn {} @@ -38823,17 +39046,11 @@ impl ::std::clone::Clone for NvExtension207Fn { } } impl NvExtension207Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = NvExtension207Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + NvExtension207Fn {} } } pub struct KhrExtension208Fn {} @@ -38845,17 +39062,11 @@ impl ::std::clone::Clone for KhrExtension208Fn { } } impl KhrExtension208Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension208Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension208Fn {} } } pub struct KhrExtension209Fn {} @@ -38867,17 +39078,11 @@ impl ::std::clone::Clone for KhrExtension209Fn { } } impl KhrExtension209Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension209Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension209Fn {} } } pub struct IntelExtension210Fn {} @@ -38889,17 +39094,11 @@ impl ::std::clone::Clone for IntelExtension210Fn { } } impl IntelExtension210Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = IntelExtension210Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + IntelExtension210Fn {} } } pub struct IntelExtension211Fn {} @@ -38911,17 +39110,11 @@ impl ::std::clone::Clone for IntelExtension211Fn { } } impl IntelExtension211Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = IntelExtension211Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + IntelExtension211Fn {} } } pub struct KhrExtension212Fn {} @@ -38933,17 +39126,11 @@ impl ::std::clone::Clone for KhrExtension212Fn { } } impl KhrExtension212Fn { - pub fn load(mut _f: F) -> ::std::result::Result> + pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - let mut _err_str = Vec::new(); - let s = KhrExtension212Fn {}; - if _err_str.is_empty() { - Ok(s) - } else { - Err(_err_str) - } + KhrExtension212Fn {} } } #[doc = "Generated from \'VK_VERSION_1_1\'"] @@ -39512,15 +39699,11 @@ fn display_flags( } Ok(()) } -impl fmt::Display for PresentModeKHR { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -39530,6 +39713,591 @@ impl fmt::Display for PresentModeKHR { } } } +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39544,6 +40312,823 @@ impl fmt::Display for VertexInputRate { } } } +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39573,196 +41158,12 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -39826,76 +41227,14 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { +impl fmt::Display for StencilFaceFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", ), ]; display_flags(f, KNOWN, self.0) @@ -39911,21 +41250,16 @@ impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { @@ -39935,10 +41269,31 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for DisplayEventTypeEXT { +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), _ => None, }; if let Some(x) = name { @@ -39948,160 +41303,6 @@ impl fmt::Display for DisplayEventTypeEXT { } } } -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DescriptorSetLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40117,11 +41318,14 @@ impl fmt::Display for DescriptorSetLayoutCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationCheckEXT { +impl fmt::Display for SamplerYcbcrModelConversion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), _ => None, }; if let Some(x) = name { @@ -40131,36 +41335,10 @@ impl fmt::Display for ValidationCheckEXT { } } } -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -40170,174 +41348,11 @@ impl fmt::Display for BorderColor { } } } -impl fmt::Display for SamplerMipmapMode { +impl fmt::Display for TessellationDomainOrigin { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), _ => None, }; if let Some(x) = name { @@ -40360,64 +41375,66 @@ impl fmt::Display for InternalAllocationType { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { +impl fmt::Display for AttachmentLoadOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for PipelineStageFlags { +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", ), ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", ), ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", ), ]; display_flags(f, KNOWN, self.0) @@ -40480,94 +41497,6 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40587,216 +41516,28 @@ impl fmt::Display for ExternalMemoryFeatureFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageUsageFlags { +impl fmt::Display for SubgroupFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndexType { +impl fmt::Display for FenceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -40818,20 +41559,125 @@ impl fmt::Display for ShaderStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ConservativeRasterizationModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -40847,937 +41693,17 @@ impl fmt::Display for ConservativeRasterizationModeEXT { } } } -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { + Self::KEEP => Some("KEEP"), Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StructureType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::APPLICATION_INFO => Some("APPLICATION_INFO"), - Self::INSTANCE_CREATE_INFO => Some("INSTANCE_CREATE_INFO"), - Self::DEVICE_QUEUE_CREATE_INFO => Some("DEVICE_QUEUE_CREATE_INFO"), - Self::DEVICE_CREATE_INFO => Some("DEVICE_CREATE_INFO"), - Self::SUBMIT_INFO => Some("SUBMIT_INFO"), - Self::MEMORY_ALLOCATE_INFO => Some("MEMORY_ALLOCATE_INFO"), - Self::MAPPED_MEMORY_RANGE => Some("MAPPED_MEMORY_RANGE"), - Self::BIND_SPARSE_INFO => Some("BIND_SPARSE_INFO"), - Self::FENCE_CREATE_INFO => Some("FENCE_CREATE_INFO"), - Self::SEMAPHORE_CREATE_INFO => Some("SEMAPHORE_CREATE_INFO"), - Self::EVENT_CREATE_INFO => Some("EVENT_CREATE_INFO"), - Self::QUERY_POOL_CREATE_INFO => Some("QUERY_POOL_CREATE_INFO"), - Self::BUFFER_CREATE_INFO => Some("BUFFER_CREATE_INFO"), - Self::BUFFER_VIEW_CREATE_INFO => Some("BUFFER_VIEW_CREATE_INFO"), - Self::IMAGE_CREATE_INFO => Some("IMAGE_CREATE_INFO"), - Self::IMAGE_VIEW_CREATE_INFO => Some("IMAGE_VIEW_CREATE_INFO"), - Self::SHADER_MODULE_CREATE_INFO => Some("SHADER_MODULE_CREATE_INFO"), - Self::PIPELINE_CACHE_CREATE_INFO => Some("PIPELINE_CACHE_CREATE_INFO"), - Self::PIPELINE_SHADER_STAGE_CREATE_INFO => Some("PIPELINE_SHADER_STAGE_CREATE_INFO"), - Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => { - Some("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO") - } - Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => { - Some("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO") - } - Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => { - Some("PIPELINE_TESSELLATION_STATE_CREATE_INFO") - } - Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => { - Some("PIPELINE_VIEWPORT_STATE_CREATE_INFO") - } - Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => { - Some("PIPELINE_RASTERIZATION_STATE_CREATE_INFO") - } - Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => { - Some("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO") - } - Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => { - Some("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO") - } - Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => { - Some("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO") - } - Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => Some("PIPELINE_DYNAMIC_STATE_CREATE_INFO"), - Self::GRAPHICS_PIPELINE_CREATE_INFO => Some("GRAPHICS_PIPELINE_CREATE_INFO"), - Self::COMPUTE_PIPELINE_CREATE_INFO => Some("COMPUTE_PIPELINE_CREATE_INFO"), - Self::PIPELINE_LAYOUT_CREATE_INFO => Some("PIPELINE_LAYOUT_CREATE_INFO"), - Self::SAMPLER_CREATE_INFO => Some("SAMPLER_CREATE_INFO"), - Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => Some("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"), - Self::DESCRIPTOR_POOL_CREATE_INFO => Some("DESCRIPTOR_POOL_CREATE_INFO"), - Self::DESCRIPTOR_SET_ALLOCATE_INFO => Some("DESCRIPTOR_SET_ALLOCATE_INFO"), - Self::WRITE_DESCRIPTOR_SET => Some("WRITE_DESCRIPTOR_SET"), - Self::COPY_DESCRIPTOR_SET => Some("COPY_DESCRIPTOR_SET"), - Self::FRAMEBUFFER_CREATE_INFO => Some("FRAMEBUFFER_CREATE_INFO"), - Self::RENDER_PASS_CREATE_INFO => Some("RENDER_PASS_CREATE_INFO"), - Self::COMMAND_POOL_CREATE_INFO => Some("COMMAND_POOL_CREATE_INFO"), - Self::COMMAND_BUFFER_ALLOCATE_INFO => Some("COMMAND_BUFFER_ALLOCATE_INFO"), - Self::COMMAND_BUFFER_INHERITANCE_INFO => Some("COMMAND_BUFFER_INHERITANCE_INFO"), - Self::COMMAND_BUFFER_BEGIN_INFO => Some("COMMAND_BUFFER_BEGIN_INFO"), - Self::RENDER_PASS_BEGIN_INFO => Some("RENDER_PASS_BEGIN_INFO"), - Self::BUFFER_MEMORY_BARRIER => Some("BUFFER_MEMORY_BARRIER"), - Self::IMAGE_MEMORY_BARRIER => Some("IMAGE_MEMORY_BARRIER"), - Self::MEMORY_BARRIER => Some("MEMORY_BARRIER"), - Self::LOADER_INSTANCE_CREATE_INFO => Some("LOADER_INSTANCE_CREATE_INFO"), - Self::LOADER_DEVICE_CREATE_INFO => Some("LOADER_DEVICE_CREATE_INFO"), - Self::SWAPCHAIN_CREATE_INFO_KHR => Some("SWAPCHAIN_CREATE_INFO_KHR"), - Self::PRESENT_INFO_KHR => Some("PRESENT_INFO_KHR"), - Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => { - Some("DEVICE_GROUP_PRESENT_CAPABILITIES_KHR") - } - Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => Some("IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), - Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => { - Some("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR") - } - Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => Some("ACQUIRE_NEXT_IMAGE_INFO_KHR"), - Self::DEVICE_GROUP_PRESENT_INFO_KHR => Some("DEVICE_GROUP_PRESENT_INFO_KHR"), - Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => { - Some("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR") - } - Self::DISPLAY_MODE_CREATE_INFO_KHR => Some("DISPLAY_MODE_CREATE_INFO_KHR"), - Self::DISPLAY_SURFACE_CREATE_INFO_KHR => Some("DISPLAY_SURFACE_CREATE_INFO_KHR"), - Self::DISPLAY_PRESENT_INFO_KHR => Some("DISPLAY_PRESENT_INFO_KHR"), - Self::XLIB_SURFACE_CREATE_INFO_KHR => Some("XLIB_SURFACE_CREATE_INFO_KHR"), - Self::XCB_SURFACE_CREATE_INFO_KHR => Some("XCB_SURFACE_CREATE_INFO_KHR"), - Self::WAYLAND_SURFACE_CREATE_INFO_KHR => Some("WAYLAND_SURFACE_CREATE_INFO_KHR"), - Self::MIR_SURFACE_CREATE_INFO_KHR => Some("MIR_SURFACE_CREATE_INFO_KHR"), - Self::ANDROID_SURFACE_CREATE_INFO_KHR => Some("ANDROID_SURFACE_CREATE_INFO_KHR"), - Self::WIN32_SURFACE_CREATE_INFO_KHR => Some("WIN32_SURFACE_CREATE_INFO_KHR"), - Self::NATIVE_BUFFER_ANDROID => Some("NATIVE_BUFFER_ANDROID"), - Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => { - Some("DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT") - } - Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => { - Some("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD") - } - Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"), - Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"), - Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"), - Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { - Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") - } - Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => { - Some("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV") - } - Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => { - Some("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV") - } - Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { - Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") - } - Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => { - Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV") - } - Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => Some("EXPORT_MEMORY_ALLOCATE_INFO_NV"), - Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"), - Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"), - Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => { - Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV") - } - Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"), - Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"), - Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { - Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR") - } - Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { - Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR") - } - Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => Some("MEMORY_WIN32_HANDLE_PROPERTIES_KHR"), - Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => Some("MEMORY_GET_WIN32_HANDLE_INFO_KHR"), - Self::IMPORT_MEMORY_FD_INFO_KHR => Some("IMPORT_MEMORY_FD_INFO_KHR"), - Self::MEMORY_FD_PROPERTIES_KHR => Some("MEMORY_FD_PROPERTIES_KHR"), - Self::MEMORY_GET_FD_INFO_KHR => Some("MEMORY_GET_FD_INFO_KHR"), - Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => { - Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR") - } - Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { - Some("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") - } - Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { - Some("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") - } - Self::D3D12_FENCE_SUBMIT_INFO_KHR => Some("D3D12_FENCE_SUBMIT_INFO_KHR"), - Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => { - Some("SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR") - } - Self::IMPORT_SEMAPHORE_FD_INFO_KHR => Some("IMPORT_SEMAPHORE_FD_INFO_KHR"), - Self::SEMAPHORE_GET_FD_INFO_KHR => Some("SEMAPHORE_GET_FD_INFO_KHR"), - Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => { - Some("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR") - } - Self::PRESENT_REGIONS_KHR => Some("PRESENT_REGIONS_KHR"), - Self::OBJECT_TABLE_CREATE_INFO_NVX => Some("OBJECT_TABLE_CREATE_INFO_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX => { - Some("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX") - } - Self::CMD_PROCESS_COMMANDS_INFO_NVX => Some("CMD_PROCESS_COMMANDS_INFO_NVX"), - Self::CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX => { - Some("CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX") - } - Self::DEVICE_GENERATED_COMMANDS_LIMITS_NVX => { - Some("DEVICE_GENERATED_COMMANDS_LIMITS_NVX") - } - Self::DEVICE_GENERATED_COMMANDS_FEATURES_NVX => { - Some("DEVICE_GENERATED_COMMANDS_FEATURES_NVX") - } - Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => { - Some("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV") - } - Self::SURFACE_CAPABILITIES_2_EXT => Some("SURFACE_CAPABILITIES_2_EXT"), - Self::DISPLAY_POWER_INFO_EXT => Some("DISPLAY_POWER_INFO_EXT"), - Self::DEVICE_EVENT_INFO_EXT => Some("DEVICE_EVENT_INFO_EXT"), - Self::DISPLAY_EVENT_INFO_EXT => Some("DISPLAY_EVENT_INFO_EXT"), - Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => Some("SWAPCHAIN_COUNTER_CREATE_INFO_EXT"), - Self::PRESENT_TIMES_INFO_GOOGLE => Some("PRESENT_TIMES_INFO_GOOGLE"), - Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => { - Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX") - } - Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => { - Some("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV") - } - Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT") - } - Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT") - } - Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT") - } - Self::HDR_METADATA_EXT => Some("HDR_METADATA_EXT"), - Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => { - Some("SHARED_PRESENT_SURFACE_CAPABILITIES_KHR") - } - Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"), - Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"), - Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => Some("FENCE_GET_WIN32_HANDLE_INFO_KHR"), - Self::IMPORT_FENCE_FD_INFO_KHR => Some("IMPORT_FENCE_FD_INFO_KHR"), - Self::FENCE_GET_FD_INFO_KHR => Some("FENCE_GET_FD_INFO_KHR"), - Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => Some("PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"), - Self::SURFACE_CAPABILITIES_2_KHR => Some("SURFACE_CAPABILITIES_2_KHR"), - Self::SURFACE_FORMAT_2_KHR => Some("SURFACE_FORMAT_2_KHR"), - Self::DISPLAY_PROPERTIES_2_KHR => Some("DISPLAY_PROPERTIES_2_KHR"), - Self::DISPLAY_PLANE_PROPERTIES_2_KHR => Some("DISPLAY_PLANE_PROPERTIES_2_KHR"), - Self::DISPLAY_MODE_PROPERTIES_2_KHR => Some("DISPLAY_MODE_PROPERTIES_2_KHR"), - Self::DISPLAY_PLANE_INFO_2_KHR => Some("DISPLAY_PLANE_INFO_2_KHR"), - Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => Some("DISPLAY_PLANE_CAPABILITIES_2_KHR"), - Self::IOS_SURFACE_CREATE_INFO_M => Some("IOS_SURFACE_CREATE_INFO_M"), - Self::MACOS_SURFACE_CREATE_INFO_M => Some("MACOS_SURFACE_CREATE_INFO_M"), - Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => Some("DEBUG_UTILS_OBJECT_NAME_INFO_EXT"), - Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => Some("DEBUG_UTILS_OBJECT_TAG_INFO_EXT"), - Self::DEBUG_UTILS_LABEL_EXT => Some("DEBUG_UTILS_LABEL_EXT"), - Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => { - Some("DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT") - } - Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => { - Some("DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT") - } - Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => { - Some("ANDROID_HARDWARE_BUFFER_USAGE_ANDROID") - } - Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => { - Some("ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID") - } - Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => { - Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID") - } - Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { - Some("IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") - } - Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { - Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") - } - Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"), - Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT") - } - Self::SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT => { - Some("SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT") - } - Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"), - Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => { - Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT") - } - Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT") - } - Self::MULTISAMPLE_PROPERTIES_EXT => Some("MULTISAMPLE_PROPERTIES_EXT"), - Self::IMAGE_FORMAT_LIST_CREATE_INFO_KHR => Some("IMAGE_FORMAT_LIST_CREATE_INFO_KHR"), - Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => { - Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT") - } - Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT") - } - Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT") - } - Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => { - Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV") - } - Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => { - Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV") - } - Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"), - Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => { - Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT") - } - Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT => { - Some("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT => { - Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT") - } - Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT") - } - Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT => { - Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT") - } - Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT => { - Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT") - } - Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT => { - Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT") - } - Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => { - Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT") - } - Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => Some("MEMORY_HOST_POINTER_PROPERTIES_EXT"), - Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT") - } - Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => { - Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD") - } - Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => { - Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT") - } - Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => { - Some("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT") - } - Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { - Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") - } - Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"), - Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"), - Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => { - Some("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES") - } - Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"), - Self::MEMORY_DEDICATED_ALLOCATE_INFO => Some("MEMORY_DEDICATED_ALLOCATE_INFO"), - Self::MEMORY_ALLOCATE_FLAGS_INFO => Some("MEMORY_ALLOCATE_FLAGS_INFO"), - Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => { - Some("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO") - } - Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => { - Some("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO") - } - Self::DEVICE_GROUP_SUBMIT_INFO => Some("DEVICE_GROUP_SUBMIT_INFO"), - Self::DEVICE_GROUP_BIND_SPARSE_INFO => Some("DEVICE_GROUP_BIND_SPARSE_INFO"), - Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => { - Some("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO") - } - Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => { - Some("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO") - } - Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => Some("PHYSICAL_DEVICE_GROUP_PROPERTIES"), - Self::DEVICE_GROUP_DEVICE_CREATE_INFO => Some("DEVICE_GROUP_DEVICE_CREATE_INFO"), - Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => Some("BUFFER_MEMORY_REQUIREMENTS_INFO_2"), - Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => Some("IMAGE_MEMORY_REQUIREMENTS_INFO_2"), - Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => { - Some("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), _ => None, }; if let Some(x) = name { @@ -41787,12 +41713,11 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for VendorId { +impl fmt::Display for DiscardRectangleModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), _ => None, }; if let Some(x) = name { @@ -41802,12 +41727,26 @@ impl fmt::Display for VendorId { } } } -impl fmt::Display for SemaphoreImportFlags { +impl fmt::Display for DeviceQueueCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -42248,12 +42187,158 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for DeviceQueueCreateFlags { +impl fmt::Display for CullModeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -42265,78 +42350,34 @@ impl fmt::Display for CompositeAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { +impl fmt::Display for DescriptorBindingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), _ => None, }; if let Some(x) = name { @@ -42359,17 +42400,12 @@ impl fmt::Display for DeviceEventTypeEXT { } } } -impl fmt::Display for ViewportCoordinateSwizzleNV { +impl fmt::Display for VendorId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), _ => None, }; if let Some(x) = name { @@ -42379,233 +42415,3 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} From 36566f8fa1e7acdf084174d7819b9245c11d2dc3 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 18:05:03 +0100 Subject: [PATCH 119/122] Update readme --- README.md | 166 +++++++++++++++++------------------------------------- 1 file changed, 53 insertions(+), 113 deletions(-) diff --git a/README.md b/README.md index d187ef5..f9d3798 100644 --- a/README.md +++ b/README.md @@ -11,19 +11,15 @@ A very lightweight wrapper around Vulkan [![Crates.io Version](https://img.shields.io/crates/v/ash.svg)](https://crates.io/crates/ash) [![](https://tokei.rs/b1/github/maikklein/ash)](https://github.com/MaikKlein/ash) -## Stable yet? -I don't expect any big changes anymore. The library will still remain < 1.0 until I had time to use it in a real project. If you encounter any problems, feel free to open an [Issue](https://github.com/MaikKlein/ash/issues). - -## Why Ash? -- [x] Lightweight Vulkan wrapper -- [x] Low overhead -- [x] Additional type safety -- [x] Trait based, version specific loader - -## What does it do? +## Overview +- [x]: A true Vulkan API without compromises +- [x]: Convenience features that don't limit the functionality +- [x]: Function pointer loading +- [x]: No validation, everything is **unsafe** +- [x]: Generated from `vk.xml` +## Features ### Explicit returns with `Result` -Functions return a `type VkResult = Result` instead of an error code. No mutable references for the output are required. ```Rust // function signature pub fn create_instance(&self, @@ -35,7 +31,8 @@ let instance = entry.create_instance(&create_info, None) ``` -Always returns a `Vec` for functions that output multiple values. +### Returns a `Vec` (*when possible*) for functions that output multiple values. + ```Rust pub fn get_swapchain_images_khr(&self, swapchain: vk::SwapchainKHR) @@ -43,23 +40,8 @@ pub fn get_swapchain_images_khr(&self, let present_images = swapchain_loader.get_swapchain_images_khr(swapchain).unwrap(); ``` -### Slices -Ash always uses slices in functions. +### Slices in functions ```Rust -// C -void vkCmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -// Rust pub fn cmd_pipeline_barrier(&self, command_buffer: vk::CommandBuffer, src_stage_mask: vk::PipelineStageFlags, @@ -68,77 +50,61 @@ pub fn cmd_pipeline_barrier(&self, memory_barriers: &[vk::MemoryBarrier], buffer_memory_barriers: &[vk::BufferMemoryBarrier], image_memory_barriers: &[vk::ImageMemoryBarrier]); - -device.cmd_pipeline_barrier(setup_command_buffer, - vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT, - vk::PIPELINE_STAGE_TOP_OF_PIPE_BIT, - vk::DependencyFlags::empty(), - &[], - &[], - &[layout_transition_barrier]); - ``` -### Type safety -Ash still uses raw Vulkan structs. The only difference is type safety. Everything that can be an enum is an enum like `vk::StructureType`, flags are implemented similar to the `Bitflags` crate. Ash also follows the Rust style guide. The reason that Ash uses raw Vulkan structs is to be extensible, just like the Vulkan spec. +### Default implementation for all types ```Rust -let pool_create_info = vk::CommandPoolCreateInfo { - s_type: vk::StructureType::CommandPoolCreateInfo, - p_next: ptr::null(), - flags: vk::COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, - queue_family_index: queue_family_index, +// 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() }; -let pool = device.create_command_pool(&pool_create_info, None).unwrap(); +``` +### Builder pattern +```Rust +let pipeline_vertex_input_state_create_info = vk::PipelineVertexInputStateCreateInfo::builder() + .vertex_binding_descriptions(&Vertex::binding_descriptions()) + .vertex_attribute_descriptions(&Vertex::attribute_descriptions()).build(); +``` +*Note*: No validation is done, the lifetimes only have to live as long as the builder object. It is the responsibility of the user to make sure that the pointers are valid. +### Flags and constants as associated constants + +```Rust +dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_READ + | vk::AccessFlags::COLOR_ATTACHMENT_WRITE, ``` -Additionally pointers like `Instance`, `Device`, `Queue` etc are hidden behind a type. Those pointers can only be constructed from within `Ash` which eliminates some invalid API usage and has the benefit of making some functions in Vulkan **safe**. +```Rust +pipeline_bind_point: 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 +``` + +### Interop + +```Rust +PipelineBindPoint::from_raw(bindpoint); +``` ### Function pointer loading Ash also takes care of loading the function pointers. Function pointers are split into 3 categories, Entry, Instance and Device. The reason for not loading it into a global is that in Vulkan you can have multiple devices and each device will load its own function pointers to achieve better performance. Click [here](https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers/blob/master/loader/LoaderAndLayerInterface.md) for more information. -Ash also manages multiple versions of Vulkan without any breakage. You will never run into any runtime error because you tried to access a function pointer that failed to load. Function pointers either load successfully or fail and return an error. - -```Rust -use ash::{Device, Instance}; -// Specifies the version that you want to load -use ash::version::V1_0; -// Those traits implement the version specific functions -use ash::version::{InstanceV1_0, DeviceV1_0, EntryV1_0}; -let entry = Entry::::new().unwrap(); -let instance = entry.create_instance(...).expect("Instance creation error."); -let device = instance.create_device(...).expect("Device creation error."); -``` - -A `V1_X` struct is used to indicate the version. -```Rust -// Define your types -type YourDevice = Device; -type YourInstance = Instance; -``` - -You can upgrade to a future version without any breakage. -```Rust -// For example, switching from V1_0 to V1_3 will not cause any breakage. -type YourDevice = Device; -type YourInstance = Instance; -``` - -A newer version can always be converted to an older version. -```Rust -let newer_device: Device = ...; -let older_device: Device = newer_device.into(); -``` - -Or specify the *minimum* version that you require with a trait. -```Rust -fn do_something_with_a_device(device: &Device){} -``` - ### 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). You still have to tell Vulkan which instance or device extensions you want to load. +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::Swapchain; -let swapchain_loader = Swapchain::new(&instance, &device).expect("Unable to load swapchain"); +let swapchain_loader = Swapchain::new(&instance, &device); let swapchain = swapchain_loader.create_swapchain_khr(&swapchain_create_info).unwrap(); ``` @@ -156,16 +122,8 @@ fn extension_names() -> Vec<*const i8> { ``` ### Implicit handles -You don't have to pass an Instance or Device handle anymore, this is done implicitly for you. This makes sure that you will always use the most optimal implementation for your `Device`. +Handles from Instance or Device are passed implicitly. ```Rust -// C -VkResult vkCreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool); - -// Rust pub fn create_command_pool(&self, create_info: &vk::CommandPoolCreateInfo) -> VkResult; @@ -197,24 +155,6 @@ cargo run --bin texture ``` ![texture](http://i.imgur.com/trow00H.png) -## Roadmap - -### Extensions -- [x] Swapchain -- [x] Surface -- [x] XlibSurface -- [x] DebugReport -- [x] Win32Surface -- [x] MirSurface -- [x] XcbSurface -- [x] AndroidSurface -- [x] WaylandSurface -- [ ] Display - -### In progress -- Wrapping the complete spec -- Version specific loader - ## A thanks to * [Api with no secrets](https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1) From 50b42e97be2ab039bfc322ad9b6697196bca8176 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 18:06:48 +0100 Subject: [PATCH 120/122] Fix rendering in readme --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index f9d3798..33fe13d 100644 --- a/README.md +++ b/README.md @@ -12,11 +12,11 @@ A very lightweight wrapper around Vulkan [![](https://tokei.rs/b1/github/maikklein/ash)](https://github.com/MaikKlein/ash) ## Overview -- [x]: A true Vulkan API without compromises -- [x]: Convenience features that don't limit the functionality -- [x]: Function pointer loading -- [x]: No validation, everything is **unsafe** -- [x]: Generated from `vk.xml` +- [x] A true Vulkan API without compromises +- [x] Convenience features that don't limit the functionality +- [x] Function pointer loading +- [x] No validation, everything is **unsafe** +- [x] Generated from `vk.xml` ## Features ### Explicit returns with `Result` From 2811bd49eb6786695bd0d88d81f76e3c512b2296 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 11 Nov 2018 18:29:11 +0100 Subject: [PATCH 121/122] Update the changelog --- Changelog.md | 45 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 42 insertions(+), 3 deletions(-) diff --git a/Changelog.md b/Changelog.md index 1909e0b..341f676 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,6 +1,45 @@ -- 0.18.0: Fixes arm build => uses libc everywhere. Remove `AlignByteSlice`. +# 0.25.0 -- 0.17.0: Refactor Align to use vk::DeviceSize. +* Adds support for Vulkan 1.1 -- 0.16.0: `map_memory` now returns a void ptr. `ash::util::Align` is a helper struct that +* Constants are not represented as an `enum` anymore. Constants and flags are both represented as associated constants. + +```Rust +flags: vk::COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, +//to +flags: vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER_BIT, + +``` + +* Pretty printing for flags + +* Handles can be loaded from outside of ash. See `SomeHandle::from_raw`. This is useful if you need to interact with a C library. + +* Removing versioning from ash. `V1_X` are now gone. Versioning had very little benefit in practice, `Entry`, `Instance` and `Device` are now version free. A custom loader can still be implemented. The various traits still remain `DeviceV1_0`. + +* `vk.rs` is now generated from `vk.xml` + +* Ash now includes all docs inside the `vk.xml`, and are visible in rustdoc. + +* `Default` is now implemented for all structs + +* There is now a builder pattern + +* Handles are now `#[repr(transparent)]` + +* Various bug fixes + + +# 0.18.0 +* Fixes arm build => uses libc everywhere. Remove `AlignByteSlice`. + +# 0.17.0 + +* Refactor Align to use vk::DeviceSize. + +# 0.16.0 + +* `map_memory` now returns a void ptr + +* `ash::util::Align` is a helper struct that can write to aligned memory. From 3544018bfd0d42621df23bc0fbe42c83fb014991 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 12 Nov 2018 11:25:47 +0100 Subject: [PATCH 122/122] Remove unused unsafe blocks --- ash/src/instance.rs | 26 +++++++++----------------- 1 file changed, 9 insertions(+), 17 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index a13c8cf..df5146c 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -14,10 +14,7 @@ pub struct Instance { instance_fn_1_1: vk::InstanceFnV1_1, } impl Instance { - pub unsafe fn load( - static_fn: &vk::StaticFn, - instance: vk::Instance, - ) -> Self { + pub unsafe fn load(static_fn: &vk::StaticFn, instance: vk::Instance) -> Self { let instance_fn_1_0 = vk::InstanceFnV1_0::load(|name| { mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) }); @@ -84,7 +81,7 @@ pub trait InstanceV1_1: InstanceV1_0 { fn enumerate_physical_device_groups( &self, - out: &mut [vk::PhysicalDeviceGroupProperties] + out: &mut [vk::PhysicalDeviceGroupProperties], ) -> VkResult<()> { unsafe { let mut group_count = out.len() as u32; @@ -95,7 +92,9 @@ pub trait InstanceV1_1: InstanceV1_0 { ); if err_code == vk::Result::SUCCESS { Ok(()) - } else { Err(err_code) } + } else { + Err(err_code) + } } } @@ -114,13 +113,8 @@ pub trait InstanceV1_1: InstanceV1_0 { format: vk::Format, out: &mut vk::FormatProperties2, ) { - unsafe { - self.fp_v1_1().get_physical_device_format_properties2( - physical_device, - format, - out, - ); - } + self.fp_v1_1() + .get_physical_device_format_properties2(physical_device, format, out); } unsafe fn get_physical_device_image_format_properties2( @@ -172,10 +166,8 @@ pub trait InstanceV1_1: InstanceV1_0 { physical_device: vk::PhysicalDevice, out: &mut vk::PhysicalDeviceMemoryProperties2, ) { - unsafe { - self.fp_v1_1() - .get_physical_device_memory_properties2(physical_device, out); - } + self.fp_v1_1() + .get_physical_device_memory_properties2(physical_device, out); } unsafe fn get_physical_device_sparse_image_format_properties2_len(